On Jul 11, 2008, at 9:59 AM, David Greene wrote:
> On Wednesday 09 July 2008 13:49, David Greene wrote:
>
>>> then it seems you're doing
>>>
>>> for each function
>>> generate_ir
>>> convert_to_llvm_ir
>>> optimize_llvm_ir
>>
>> Yep.
>
> Ok, I've mostly got a mechanism to do what I want:
>
> 1. As each function comes in for op/codegen, clone it and save off
> the clone and its associated ValueMap (I call these clones
> "pristine"
> functions.
>
> 2. After all processing is done, clone the resulting Module (this
> has all of
> the global data and the optimized functions). Save the ValueMap
> from this
> operation.
The global data is also optimized at this point. Will it map properly
with un-optimized pristine functions ?
-
Devang
>
>
> 3. Merge the ValueMaps from the Module clone and all the pristine
> function
> ValueMaps so that if V->V' in the Module map and V->V''
in the
> pristine
> function map, make V''->V' in the Module map.
>
> 4. Fix up arguments to the pristine functions _a_la_ what is done in
> CloneModule.
>
> 5. Delete the function bodies of all functions in the cloned Module
> (these are
> the optimized bodies) by calling deleteBody on them.
>
> 6. Call CloneFunctionInto to clone the pristine functions into the
> cloned
> Module.
>
> 7. Fix up linkages (set function linkages in the Module to what they
> are in
> the pristine function clones (they were changed to External by
> deleteBody).
>
> 8. Delete all the pristine Function clones, they are now cloned into
> the
> cloned Module.
>
> This should work as I understand things, but I have a question about
> Function::deleteBody. It calls dropAllReferences which has the
> following
> scary comment:
>
> /// dropAllReferences() - This method causes all the
> subinstructions to "let
> /// go" of all references that they are maintaining. This allows
> one to
> /// 'delete' a whole module at a time, even though there may be
> circular
> /// references... first all references are dropped, and all use
> counts go to
> /// zero. Then everything is deleted for real. Note that no
> operations are
> /// valid on an object that has "dropped all references", except
> operator
> /// delete.
> ///
> /// Since no other object in the module can have references into
> the body of
> a
> /// function, dropping all references deletes the entire body of the
> function,
> /// including any contained basic blocks.
> ///
>
> Is it really true I can't do anything else to a Function after
> calling this?
> Can I clone into it via CloneFunctionInto?
>
> -Dave
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev