From 072d3a02241a27473ee245b5aac783501d78161e Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sat, 30 Mar 2002 20:53:14 +0000 Subject: [PATCH] * Catch and ignore (for now) return instructions in tranformed functions * Add more debugging output * Fix problems refering to wrong versions of various graphs * Build the pool descriptor map! * Clear the nodemapping map after building pool descriptor to avoid assert * Transform the NEw function body, not the old one... * Matrix.ll now works! git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2058 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/IPO/OldPoolAllocate.cpp | 89 +++++++++++++++++--------- 1 file changed, 58 insertions(+), 31 deletions(-) diff --git a/lib/Transforms/IPO/OldPoolAllocate.cpp b/lib/Transforms/IPO/OldPoolAllocate.cpp index 426541288b5..7457ae93e1e 100644 --- a/lib/Transforms/IPO/OldPoolAllocate.cpp +++ b/lib/Transforms/IPO/OldPoolAllocate.cpp @@ -376,6 +376,10 @@ public: // Handle PHI Node } + void visitReturnInst(ReturnInst *I) { + // Nothing of interest + } + void visitInstruction(Instruction *I) { cerr << "Unknown instruction to FunctionBodyTransformer:\n"; I->dump(); @@ -425,10 +429,15 @@ void PoolAllocate::transformFunctionBody(Function *F, FunctionDSGraph &IPFGraph, map &ValMap = IPFGraph.getValueMap(); vector Scalars; + cerr << "Building scalar map:\n"; + for (map::iterator I = ValMap.begin(), E = ValMap.end(); I != E; ++I) { const PointerValSet &PVS = I->second; // Set of things pointed to by scalar + cerr << "Scalar Mapping from:"; I->first->dump(); + cerr << "\nScalar Mapping to: "; PVS.print(cerr); + assert(PVS.size() == 1 && "Only handle scalars that point to one thing so far!"); @@ -445,7 +454,7 @@ void PoolAllocate::transformFunctionBody(Function *F, FunctionDSGraph &IPFGraph, - cerr << "In '" << F->getName() + cerr << "\nIn '" << F->getName() << "': Found the following values that point to poolable nodes:\n"; for (unsigned i = 0, e = Scalars.size(); i != e; ++i) @@ -589,7 +598,7 @@ static void addNodeMapping(DSNode *SrcNode, const PointerValSet &PVS, // // The NodeMapping calculated maps from the callers graph to the called graph. // -static void CalculateNodeMapping(TransformFunctionInfo &TFI, +static void CalculateNodeMapping(Function *F, TransformFunctionInfo &TFI, FunctionDSGraph &CallerGraph, FunctionDSGraph &CalledGraph, map &NodeMapping) { @@ -609,7 +618,7 @@ static void CalculateNodeMapping(TransformFunctionInfo &TFI, NodeMapping); } else { // Figure out which node argument # ArgNo points to in the called graph. - Value *Arg = TFI.Func->getArgumentList()[TFI.ArgInfo[i].ArgNo]; + Value *Arg = F->getArgumentList()[TFI.ArgInfo[i].ArgNo]; addNodeMapping(TFI.ArgInfo[i].Node, CalledGraph.getValueMap()[Arg], NodeMapping); } @@ -685,17 +694,17 @@ void PoolAllocate::transformFunction(TransformFunctionInfo &TFI, // data structure graph for the function we are replacing, and figure out how // our graph nodes map to the graph nodes in the dest function. // - FunctionDSGraph &DSGraph = DS->getClosedDSGraph(TFI.Func); + FunctionDSGraph &DSGraph = DS->getClosedDSGraph(NewFunc); // NodeMapping - Multimap from callers graph to called graph. // map NodeMapping; - CalculateNodeMapping(TFI, CallerIPGraph, DSGraph, + CalculateNodeMapping(NewFunc, TFI, CallerIPGraph, DSGraph, NodeMapping); // Print out the node mapping... - cerr << "\nNode mapping for call of " << TFI.Func->getName() << "\n"; + cerr << "\nNode mapping for call of " << NewFunc->getName() << "\n"; for (map::iterator I = NodeMapping.begin(); I != NodeMapping.end(); ++I) { cerr << "Map: "; I->first->print(cerr); @@ -709,39 +718,57 @@ void PoolAllocate::transformFunction(TransformFunctionInfo &TFI, // map PoolDescriptors; - cerr << "FIXME: PoolDescriptors not built!\n"; - -#if 0 - // First add the incoming arguments to the scalar map... - for (unsigned i = 0, e = TFI.ArgInfo.size(); i != e; ++i) - if (TFI.ArgInfo[i].ArgNo == -1) { - - } else { - Value *Arg = TFI.Func->getArgumentList()[TFI.ArgInfo[i].ArgNo]; + cerr << "\nCalculating the pool descriptor map:\n"; - // Find out what nodes the argument points to in the called functions data - // structure graph... - // - PointerValSet &ArgNodes = DSGraph.getValueMap()[Arg]; - - // Add mappings for all of the arguments of this function... - for (unsigned ArgVal = 0, AVE = ArgNodes.size(); ArgVal != AVE; ++ArgVal){ - assert(ArgNodes[ArgVal].Index == 0 && - "Arg that points into an object not handled yet!"); - DSNode *ArgNode = ArgNodes[ArgVal].Node; - Scalars.push_back(ScalarInfo(Arg, ArgNode, PoolDescriptors[ArgNode])); - } - ArgOffset++; + // All of the pool descriptors must be passed in as arguments... + for (unsigned i = 0, e = TFI.ArgInfo.size(); i != e; ++i) { + DSNode *CallerNode = TFI.ArgInfo[i].Node; + Value *CallerPool = TFI.ArgInfo[i].PoolHandle; + + cerr << "Mapped caller node: "; CallerNode->print(cerr); + cerr << "Mapped caller pool: "; CallerPool->dump(); + + // Calculate the argument number that the pool is to the function call... + // The call instruction should not have the pool operands added yet. + unsigned ArgNo = TFI.Call->getNumOperands()-1+i; + cerr << "Should be argument #: " << ArgNo << "[i = " << i << "]\n"; + assert(ArgNo < NewFunc->getArgumentList().size() && + "Call already has pool arguments added??"); + + // Map the pool argument into the called function... + Value *CalleePool = NewFunc->getArgumentList()[ArgNo]; + + // Map the DSNode into the callee's DSGraph + const PointerValSet &CalleeNodes = NodeMapping[CallerNode]; + for (unsigned n = 0, ne = CalleeNodes.size(); n != ne; ++n) { + assert(CalleeNodes[n].Index == 0 && "Indexed node not handled yet!"); + DSNode *CalleeNode = CalleeNodes[n].Node; + + cerr << "*** to callee node: "; CalleeNode->print(cerr); + cerr << "*** to callee pool: "; CalleePool->dump(); + cerr << "\n"; + + assert(CalleeNode && CalleePool && "Invalid nodes!"); + Value *&PV = PoolDescriptors[CalleeNode]; + //assert((PV == 0 || PV == CalleePool) && "Invalid node remapping!"); + PV = CalleePool; // Update the pool descriptor map! } + } + + // We must destroy the node mapping so that we don't have latent references + // into the data structure graph for the new function. Otherwise we get + // assertion failures when transformFunctionBody tries to invalidate the + // graph. + // + NodeMapping.clear(); // Now that we know everything we need about the function, transform the body // now! // - transformFunctionBody(TFI.Func, DSGraph, PoolDescriptors); + transformFunctionBody(NewFunc, DSGraph, PoolDescriptors); cerr << "Function after transformation:\n"; - TFI.Func->dump(); -#endif + NewFunc->dump(); } -- 2.34.1