diff --git a/lib/Transforms/IPO/OldPoolAllocate.cpp b/lib/Transforms/IPO/OldPoolAllocate.cpp index 9671c8049dd..7e9f15556aa 100644 --- a/lib/Transforms/IPO/OldPoolAllocate.cpp +++ b/lib/Transforms/IPO/OldPoolAllocate.cpp @@ -19,11 +19,55 @@ #include "Support/STLExtras.h" #include + // FIXME: This is dependant on the sparc backend layout conventions!! static TargetData TargetData("test"); -// Define the pass class that we implement... namespace { + // ScalarInfo - Information about an LLVM value that we know points to some + // datastructure we are processing. + // + struct ScalarInfo { + Value *Val; // Scalar value in Current Function + AllocDSNode *AllocNode; // Allocation node it points to + Value *PoolHandle; // PoolTy* LLVM value + + ScalarInfo(Value *V, AllocDSNode *AN, Value *PH) + : Val(V), AllocNode(AN), PoolHandle(PH) {} + }; + + // TransformFunctionInfo - Information about how a function eeds to be + // transformed. + // + struct TransformFunctionInfo { + // ArgInfo - Maintain information about the arguments that need to be + // processed. Each pair corresponds to an argument (whose number is the + // first element) that needs to have a pool pointer (the second element) + // passed into the transformed function with it. + // + // As a special case, "argument" number -1 corresponds to the return value. + // + vector > ArgInfo; + + // Func - The function to be transformed... + Function *Func; + + // default ctor... + TransformFunctionInfo() : Func(0) {} + + inline bool operator<(const TransformFunctionInfo &TFI) const { + return Func < TFI.Func || (Func == TFI.Func && ArgInfo < TFI.ArgInfo); + } + + void finalizeConstruction() { + // Sort the vector so that the return value is first, followed by the + // argument records, in order. + sort(ArgInfo.begin(), ArgInfo.end()); + } + }; + + + // Define the pass class that we implement... class PoolAllocate : public Pass { // PoolTy - The type of a scalar value that contains a pool pointer. PointerType *PoolTy; @@ -61,6 +105,20 @@ namespace { // Prototypes that we add to support pool allocation... Function *PoolInit, *PoolDestroy, *PoolAlloc, *PoolFree; + // The map of already transformed functions... + map TransformedFunctions; + + // getTransformedFunction - Get a transformed function, or return null if + // the function specified hasn't been transformed yet. + // + Function *getTransformedFunction(TransformFunctionInfo &TFI) const { + map::const_iterator I = + TransformedFunctions.find(TFI); + if (I != TransformedFunctions.end()) return I->second; + return 0; + } + + // addPoolPrototypes - Add prototypes for the pool methods to the specified // module and update the Pool* instance variables to point to them. // @@ -79,12 +137,21 @@ namespace { // available. // bool processFunction(Function *F); + + + void transformFunctionBody(Function *F, vector &Scalars); + + // transformFunction - Transform the specified function the specified way. + // It we have already transformed that function that way, don't do anything. + // + void transformFunction(TransformFunctionInfo &TFI); + }; } -// isNotPoolableAlloc - This is a predicate that returns true if the specified +// isNotPoolableAlloc - This is a predicate that returns true if the specified // allocation node in a data structure graph is eligable for pool allocation. // static bool isNotPoolableAlloc(const AllocDSNode *DS) { @@ -97,7 +164,6 @@ static bool isNotPoolableAlloc(const AllocDSNode *DS) { return false; } - // processFunction - Convert a function to use pool allocation where // available. // @@ -112,7 +178,7 @@ bool PoolAllocate::processFunction(Function *F) { // they are still live (they exist in the graph at all), this means we must // have scalar references to these nodes, but the scalars are never returned. // - std::vector Allocs; + vector Allocs; IPGraph.getNonEscapingAllocations(Allocs); // Filter out allocations that we cannot handle. Currently, this includes @@ -125,39 +191,147 @@ bool PoolAllocate::processFunction(Function *F) { if (Allocs.empty()) return false; // Nothing to do. + // Insert instructions into the function we are processing to create all of + // the memory pool objects themselves. This also inserts destruction code. + // This fills in the PoolDescriptors vector to be a array parallel with + // Allocs, but containing the alloca instructions that allocate the pool ptr. + // + vector PoolDescriptors; + CreatePools(F, Allocs, PoolDescriptors); + + // Loop through the value map looking for scalars that refer to nonescaping - // allocations. + // allocations. Add them to the Scalars vector. Note that we may have + // multiple entries in the Scalars vector for each value if it points to more + // than one object. // map &ValMap = IPGraph.getValueMap(); - vector > Scalars; + vector Scalars; for (map::iterator I = ValMap.begin(), E = ValMap.end(); I != E; ++I) { const PointerValSet &PVS = I->second; // Set of things pointed to by scalar + + assert(PVS.size() == 1 && + "Only handle scalars that point to one thing so far!"); + // Check to see if the scalar points to anything that is an allocation... for (unsigned i = 0, e = PVS.size(); i != e; ++i) if (AllocDSNode *Alloc = dyn_cast(PVS[i].Node)) { assert(PVS[i].Index == 0 && "Nonzero not handled yet!"); // If the allocation is in the nonescaping set... - if (find(Allocs.begin(), Allocs.end(), Alloc) != Allocs.end()) + vector::iterator AI = + find(Allocs.begin(), Allocs.end(), Alloc); + if (AI != Allocs.end()) { + unsigned IDX = AI-Allocs.begin(); // Add it to the list of scalars we have - Scalars.push_back(make_pair(I->first, Alloc)); + Scalars.push_back(ScalarInfo(I->first, Alloc, PoolDescriptors[IDX])); + } } } + // Now we need to figure out what called methods we need to transform, and + // how. To do this, we look at all of the scalars, seeing which functions are + // either used as a scalar value (so they return a data structure), or are + // passed one of our scalar values. + // + transformFunctionBody(F, Scalars); + + return true; +} + +static void addCallInfo(TransformFunctionInfo &TFI, CallInst *CI, int Arg, + Value *PoolHandle) { + assert(CI->getCalledFunction() && "Cannot handle indirect calls yet!"); + TFI.ArgInfo.push_back(make_pair(Arg, PoolHandle)); + + assert(TFI.Func == 0 || TFI.Func == CI->getCalledFunction() && + "Function call record should always call the same function!"); + TFI.Func = CI->getCalledFunction(); +} + +void PoolAllocate::transformFunctionBody(Function *F, + vector &Scalars) { cerr << "In '" << F->getName() << "': Found the following values that point to poolable nodes:\n"; for (unsigned i = 0, e = Scalars.size(); i != e; ++i) - Scalars[i].first->dump(); + Scalars[i].Val->dump(); + + // CallMap - Contain an entry for every call instruction that needs to be + // transformed. Each entry in the map contains information about what we need + // to do to each call site to change it to work. + // + map CallMap; + + // Now we need to figure out what called methods we need to transform, and + // how. To do this, we look at all of the scalars, seeing which functions are + // either used as a scalar value (so they return a data structure), or are + // passed one of our scalar values. + // + for (unsigned i = 0, e = Scalars.size(); i != e; ++i) { + Value *ScalarVal = Scalars[i].Val; + + // Check to see if the scalar _IS_ a call... + if (CallInst *CI = dyn_cast(ScalarVal)) + // If so, add information about the pool it will be returning... + addCallInfo(CallMap[CI], CI, -1, Scalars[i].PoolHandle); + + // Check to see if the scalar is an operand to a call... + for (Value::use_iterator UI = ScalarVal->use_begin(), + UE = ScalarVal->use_end(); UI != UE; ++UI) { + if (CallInst *CI = dyn_cast(*UI)) { + // Find out which operand this is to the call instruction... + User::op_iterator OI = find(CI->op_begin(), CI->op_end(), ScalarVal); + assert(OI != CI->op_end() && "Call on use list but not an operand!?"); + assert(OI != CI->op_begin() && "Pointer operand is call destination?"); + + // FIXME: This is broken if the same pointer is passed to a call more + // than once! It will get multiple entries for the first pointer. + + // Add the operand number and pool handle to the call table... + addCallInfo(CallMap[CI], CI, OI-CI->op_begin(), Scalars[i].PoolHandle); + } + } + } + + // Print out call map... + for (map::iterator I = CallMap.begin(); + I != CallMap.end(); ++I) { + cerr << "\nFor call: "; + I->first->dump(); + I->second.finalizeConstruction(); + cerr << " must pass pool pointer for arg #"; + for (unsigned i = 0; i < I->second.ArgInfo.size(); ++i) + cerr << I->second.ArgInfo[i].first << " "; + cerr << "\n"; + } + + // Loop through all of the call nodes, recursively creating the new functions + // that we want to call... This uses a map to prevent infinite recursion and + // to avoid duplicating functions unneccesarily. + // + for (map::iterator I = CallMap.begin(), + E = CallMap.end(); I != E; ++I) { + // Make sure the entries are sorted. + I->second.finalizeConstruction(); + transformFunction(I->second); + } + + + +} + + +// transformFunction - Transform the specified function the specified way. +// It we have already transformed that function that way, don't do anything. +// +void PoolAllocate::transformFunction(TransformFunctionInfo &TFI) { + if (getTransformedFunction(TFI)) return; // Function xformation already done? + - // Insert instructions into the function we are processing to create all of - // the memory pool objects themselves. This also inserts destruction code. - vector PoolDescriptors; - CreatePools(F, Allocs, PoolDescriptors); - return true; } @@ -181,7 +355,7 @@ void PoolAllocate::CreatePools(Function *F, const vector &Allocs, // Add an allocation and a free for each pool... AllocaInst *PoolAlloc = new AllocaInst(PoolTy, 0, "pool"); EntryNodeInsts.push_back(PoolAlloc); - + PoolDescriptors.push_back(PoolAlloc); // Keep track of pool allocas AllocationInst *AI = Allocs[i]->getAllocation(); // Initialize the pool. We need to know how big each allocation is. For