🚀 go-pugleaf

In article <14les7INN4m@early-bird.think.com> barmar@think.com (Barry Margolin) writes:
: Declare the structure as a union, where one case is an array of page table
: entries, and the other is the preceding stuff.  Then find the array element
: whose address is greater than the address of the end of the preceding
: stuff.  Use the address of that array element as the address of the page
: table.

Yes, that works. However, if the object is malloced, you don't
even need the union.

There's an awful lot of gobbledygook about this in the standard
but when all is said and done, the standard has eliminated the
notion that all objects are contained in a single address space.
However, each object still behaves as if it were a single address
space in the style to which we had become accustomed, with
increasing and contiguous addresses (in char*s) and the object's
alignment is determined by how it came into being. Malloced
objects are aligned with the strongest restriction possible in the
implementation.

Once you have an object, so long as you keep your pointers within
it (or at the end, provided you don't dereference the pointer)
and never generate an pointer with an alignment that is
incompatible with the alignment associated with its type, you can
do all the old pointer manipulation tricks we've all come to know
and love.

Suppose that you have a malloced area and a char pointer within
it. You suppose that the pointer points to the start of or to a
byte within some array element and you want to find the start of
the array element. This works:

	(array *)((char *)area +
		  (pointer - (char *)area)
		    / sizeof(array[0])
		    * sizeof(array[0]))

Watch out for ptrdiff_t oddities, though. (If those are a problem,
one is reduced to a certain amount of searching.)

---
Bill                            { uunet | decwrl | telesci }!twwells!bill
bill@twwells.com