Re: Need for scm_remember_upto_here_* in guile-2.0

[David Kastrup]

Chris Vine <address@hidden> writes:

> On Wed, 23 Sep 2015 09:26:27 +0200
> David Kastrup <address@hidden> wrote:
>
>> Also, a pointer to an array (rather than something more opaque like
>> SCM) is much more likely to be subject to strength reduction and
>> address arithmetic by the compiler, leading to a situation where
>> looping through some array does not leave a live pointer in
>> registers and stack frame in a form recognizable by libgc.
>
> However, I haven't understood your point about arrays.  If they are
> allocated with malloc() you need a finaliser and you may need to call
> scm_remember_upto_here_1() to prevent the smob's finaliser from firing
> while they are still in use.  If they are allocated with
> scm_gc_malloc() you don't, as I understand it.  Were you making a
> point in addition to that, and if so could you expand on it for me?

The point is that libgc may be less reliable with recognizing a typical
C/C++ array still being in use than with SCM values because the compiler
is more likely to mangle array access beyond recognition by stack frame
inspection.

For example, if you index arrays starting from 1 (or have indexing
expressions with similar effects), the actual register from which the
compiler does its indexing may lie strictly outside of the allocated
area for an array.

A compiler may also choose to convert a loop running from indexes 0 to
n-1 to one running from -n to -1 in order to have a nicer terminating
condition.  Again, with strength reduction this may lead to the actual
libgc-recognizable pointer being clear outside of the allocated array.

SCM is defined in a manner where the compiler has far fewer useful
transformations at its disposal for the normal operations.  So the
likelihood of libgc making mistakes is just lower.

-- 
David Kastrup