[LLVMdev] Improving Garbage Collection

Peter Lawrence peterl95124 at sbcglobal.net
Tue Jul 19 10:06:31 PDT 2011

           how about having the front-end generate an llvm.safe.point 
() intrinsic call at
the desired safe points,  and having the addresses of the GC roots  
(at that point,
can vary from call to call) be the parameters (with noescape  
attribute) to the intrinsic,

IIUC currently the GC roots are tagged, and all analysis and  
transform optimizations
have to special case these tagged objects, but if instead their  
addresses were taken at
the safe points no special casing would have to be done -- all  
analysis and transform
optimizations already know how to deal with objects whose address is  

and since llvm does already have a "noescape" (not sure that's the  
correct name?)
attribute for parameters, these addresses won't be misinterpreted by  
any alias
analysis either, and llvm is free to go ahead and keep these values  
in registers
between safe points  -- you can stop asking how to allow GC roots as  
SSA values,
any traditional load-store optimization pass will do it for you for  

*** without you having to insert explicit load and store  
instructions, and having to
somehow mark them as non-delete-able, or always omit optimization  
passes that
you would otherwise like to have enabled ***

and also without you having to store NULL into a safe point to end  
its lifetime.
and I would suggest eliminating the gcroot() intrinsic as it's  
information content
would be redundant.

thoughts, comments ???

-Peter Lawrence.

On Jul 18, 2011, at 10:53 PM, Talin wrote:

> On Mon, Jul 18, 2011 at 11:00 AM, Peter Lawrence  
> <peterl95124 at sbcglobal.net> wrote:
> Talin,
>           do you identify safe-points in the current or proposed  
> llvm scheme, and if so how,
> or are they implicit as being at all call sites (which begs the  
> question what about leaves
> in the call tree, how does GC get started at all in that case).
> The LLVM linker has a feature where you can specify what kind of  
> safe points your collector requires - the options are Loop, Return,  
> PreCall and PostCall. You can also override this behavior and  
> examine each instruction and return a boolean indicating whether it  
> is or isn't a safe point.
> Currently I only have function calls as safe points, although I may  
> eventually enable loops as well. As far as leaf functions go,  
> consider that the call to allocate memory is also a safe point -  
> and if a function doesn't allocate any memory then we don't care if  
> the GC is involved or not.
> One complication with the current scheme is that the frontend has  
> to have a sense of where the safe points are going to be. Because  
> the current scheme requires the frontend to insert additional loads  
> and stores around safe points (for spilling register values to  
> memory so they can be traced), the frontend has to be able to guess  
> which function call might be a safe point - but it can't know for  
> sure due to the fact that optimization and inlining (which happens  
> much later) may cause the removal of the actual call instruction.  
> The safe but inefficient approach is to insert the extra loads and  
> stores around every call instruction.
> Peter Lawrence.
> -- 
> -- Talin

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20110719/d23bc323/attachment.html>

More information about the llvm-dev mailing list