similar to: [LLVMdev] Garbage collection: Multiple copies of a root

On 2009-03-20, at 05:09, Harmen van der Spek wrote: > The problem is that we want to implement some sort of copying > garbage collector. In this case, the roots on the stack must be > updated. However, if this root is also stored in an IR register, > then this pointer should be updated as well. Is there support for > identifying and updating such references in the GC

Another open question is who is responsible for inserting calls to the collector routine (or signaling a collector thread)? My impression is that this has to be done in the front-end for now since there is no support for doing this at the safe points at the moment. Is this correct? Regards, Mattias On 20 Mar 2009, at 13:09, Gordon Henriksen wrote: > On 2009-03-20, at 05:09, Harmen

Hi all, I just ran into a strange problem. When using the Equivalence-class Bottom-up Data Structure Analysis pass and pool allocation, I noticed some objects using different pool descriptors where I expected them to be in the same pool. We use svn revision 66285 of the DSA. The following 2 programs expose the problem. First the version that runs correctly, ie. producing a single DSNode.

Hi Patrick, That's right. DSNodes are coupled to the original function. For function clones, you first need to get the original function, and then use the DSNode from that function. FuncInfo contains the information if a function is a clone and what the original function is. If you want to find the corresponding DSNode for some instruction, you must call PA::FuncInfo::MapValueToOriginal(

Harmen, your suggestion of inverting the mapping almost worked (and Andrew was correct that the function I need is the same as the one in which poolinit appears). Unfortunately, it appears that this mapping only considers the original function and not any of its clones. Since the pool descriptor in question may very well only exist in a clone, I can't use this. Is there another way?

Depending on the value of dsa_pass_to_use, either EquivBUDataStructures or EQTDDataStructures is used. In the case that the top-down DSA is used, information is pushed down to nodes in callees. However, if bottom-up DSA is used, information has only been merged upwards and the nodes are not necessarily equivalent. Harmen Andrew Lenharth wrote: > On Tue, Mar 16, 2010 at 3:46 PM, Patrick

Hi, LoopBase::getExitBlocks in LoopInfo.h returns all exit basic blocks by iterating over all blocks of a loop and storing all branch targets that are outside the loop. This method allows for duplicates in the result vector, e.g.: Loop at depth 2 containing: %bb2<header><exit>,%bb1<latch>,%bb3<exit> where both bb2 and bb3 have bb4 as their exit block. This loop

Thanks for all your help so far. My problem is that what I have are the pool descriptors, which I by traversing the uses of poolinit and accessing the first argument of each call. I need to find the DSNode (in the original function) to which this pool descriptor corresponds. The rub is that this pool descriptor of course does not exist except in the clone. If I call getFuncInfo(), I get a

Hi, The poolalloc library fails in TransformFunctionBody.cpp, line 746 --- Value *ArgVal = ConstantAggregateZero::get(PoolAllocate::PoolDescPtrTy); --- opt -load /path_to_lib/libpoolalloc.dylib -poolalloc constaggr.bc -o opt.bc -f triggers the problem (bc file attached). Assertion failed: ((isa<StructType>(Ty) || isa<ArrayType>(Ty) || isa<VectorType>(Ty)) &&

You might want to have a look at PoolAllocate.h. Per function, a PA::FuncInfo structure keeps track of all DSNodes that should be pool allocated. ArgNodes contains pool arguments, NodesToPA contains nodes that are locally pool allocated and thus initialized using poolinit. PoolDescriptors contains a mapping from DSNodes to pool descriptors, and you could easily invert this mapping. Finding a

Hi Talin, On Sep 2, 2007, at 04:54, Talin wrote: > I've been looking through the documentation (http://llvm.org/docs/ > GarbageCollection.html) on how to implement a garbage collector for > LLVM and there's a couple of things that I don't quite understand. > Specifically, it says that when a stack variable goes out of scope, > you're supposed to assign a

Hi all, I've been looking through the documentation (http://llvm.org/docs/GarbageCollection.html) on how to implement a garbage collector for LLVM and there's a couple of things that I don't quite understand. Specifically, it says that when a stack variable goes out of scope, you're supposed to assign a null value to it to indicate that the value is no longer live. What I

On 2007-09-03, at 23:14, Talin wrote: > On Sep 2, 2007 5:31 AM, Gordon Henriksen <gordonhenriksen at mac.com> > wrote: > >> On Sep 2, 2007, at 04:54, Talin wrote: >> >>> I've been looking through the documentation (http://llvm.org/docs/ >>> GarbageCollection.html) on how to implement a garbage collector >>> for LLVM and there's a

Gordon Henriksen wrote: > The intrinsics are entirely neutral to collector implementation, and > thus to threading. They could easily be used to implement reference > counting, for instance, which may or may not be implemented in a > threadsafe manner. However, as with your algorithm, reference counting > does not require code generator support, and so would not justify the

It runs fine on my Snow Leopard installation. I do recall though that LLVM did not build in 64-bit mode automatically. I configured LLVM as follows to get a 64-bit build. ./configure --build=x86_64-apple-darwin10 --host=x86_64-apple-darwin10 --target=x86_64-apple-darwin1 Harmen Tommy Chheng wrote: > Hi, > Learning the ropes of LLVM. I have this simple LLVM assembly snippet > which

On Sep 2, 2007 5:31 AM, Gordon Henriksen <gordonhenriksen at mac.com> wrote: > Hi Talin, > > On Sep 2, 2007, at 04:54, Talin wrote: > > > I've been looking through the documentation (http://llvm.org/docs/ > > GarbageCollection.html) on how to implement a garbage collector for > > LLVM and there's a couple of things that I don't quite understand. >

I've written a reference-counting garbage collector for LLVM, but I'm still unclear on a few things. The following piece of code that appears on http://llvm.cs.uiuc.edu/docs/GarbageCollection.html is unclear: ;; As the pointer goes out of scope, store a null value into ;; it, to indicate that the value is no longer live. store %Object* null, %Object** %X ... How exactly does

This is really nice, it supports my (somewhere-in-the-future) work with llvm, garbage collection and persistent memories. Can/Will one garbage collector be used for several different front-end languages? If so, don't you have to put functionality to traverse objects in the language implementation, since the internal representation depends on what language that is compiled. One language's

I recently added initial support for accurate GC to LLVM, as described in this document: http://llvm.cs.uiuc.edu/docs/GarbageCollection.html I've started implementing a trivial copying collector as a testcase for it, but it is not done yet. All code generators support identification of roots on the stack though. If you're interested in such things, I would really appreciate feedback on

On Friday 27 February 2009 18:42:13 Gordon Henriksen wrote: > I agree this could be better. I think it would be prudent of you, > being aware of this problem, to structure your compiler so as to limit > the number of pieces of code which would be effected when you switch > to a copying collector. I think that would make my VM a lot more complicated for no clear practical gain. >