Re: Great Circle and Ada?

[bobduff@world.std.com (Robert A Duff)]

In article <51mj21$jif@watnews1.watson.ibm.com>,
Norman H. Cohen <ncohen@watson.ibm.com> wrote:
>However, a CONSERVATIVE garbage collector makes guesses about which words
>are pointers precisely because it has no information about how the
>compiler has laid out storage.  The only knowledge exploited by a
>conservative garbage collector is knowledge of the data structure
>(typically boundary tags) used by the run-time system's allocator.

I wouldn't say that's the *only* knowledge.  The conservative GC also
knows (or hopes!) that the compiler represents access types or pointers
or whatever language feature it is using machine addresses.  And that
these machine addresses always point at the data, or perhaps in the
middle of the data.

There are *lots* of tricks compilers can play that will break a
conservative garbage collector.  Virtual origins is one.  Playing games
with pointer representation is another.  E.g. packing a small integer
field and a pointer into one 32-bit word.  (A pointer doesn't always
need all 32 bits -- the low bits are always zero, because the thing is
known to be aligned, and the high bits are known, because the compiler
knows where the heap and other data is in the address space).  How about
the Lisp-ish tricks for representing fixnums vs. bignums?

Compiler writers blame it on the conservative gc, and gc writers blame
it on the compiler.  ;-)  Either way, there has to be *some* known
information about the interface between the two, or gc won't work.

- Bob