diff --git a/lib/Transforms/Instrumentation/ProfilePaths/EdgeCode.cpp b/lib/Transforms/Instrumentation/ProfilePaths/EdgeCode.cpp index e118ea5abde..6fa61d63f92 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/EdgeCode.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/EdgeCode.cpp @@ -16,6 +16,7 @@ #include "llvm/iOperators.h" #include "llvm/iPHINode.h" #include "llvm/Module.h" +#include "llvm/Instruction.h" #include #define INSERT_LOAD_COUNT @@ -25,13 +26,14 @@ using std::vector; static void getTriggerCode(Module *M, BasicBlock *BB, int MethNo, Value *pathNo, - Value *cnt, Instruction *InsertPos){ + Value *cnt){ vector args; //args.push_back(PointerType::get(Type::SByteTy)); args.push_back(Type::IntTy); args.push_back(Type::IntTy); - args.push_back(Type::IntTy); + //args.push_back(Type::IntTy); + args.push_back(PointerType::get(Type::IntTy)); const FunctionType *MTy = FunctionType::get(Type::VoidTy, args, false); Function *trigMeth = M->getOrInsertFunction("trigger", MTy); @@ -43,69 +45,95 @@ static void getTriggerCode(Module *M, BasicBlock *BB, int MethNo, Value *pathNo, trargs.push_back(pathNo); trargs.push_back(cnt); - Instruction *callInst=new CallInst(trigMeth, trargs, "", InsertPos); + Instruction *callInst=new CallInst(trigMeth, trargs, "");//, BB->begin()); + BB->getInstList().push_back(callInst); + //triggerInst = new CallInst(trigMeth, trargs, "");//, InsertPos); } //get the code to be inserted on the edge //This is determined from cond (1-6) -void getEdgeCode::getCode(Instruction *rInst, - Instruction *countInst, - Function *M, - BasicBlock *BB, int numPaths, int MethNo){ +void getEdgeCode::getCode(Instruction *rInst, Instruction *countInst, + Function *M, BasicBlock *BB, + vector &retVec){ - Instruction *InsertPos = BB->getInstList().begin(); + //Instruction *InsertPos = BB->getInstList().begin(); + //now check for cdIn and cdOut + //first put cdOut + if(cdOut!=NULL){ + cdOut->getCode(rInst, countInst, M, BB, retVec); + } + + if(cdIn!=NULL){ + cdIn->getCode(rInst, countInst, M, BB, retVec); + } + //case: r=k code to be inserted switch(cond){ case 1:{ Value *val=ConstantSInt::get(Type::IntTy,inc); #ifdef INSERT_STORE - Instruction *stInst=new StoreInst(val, rInst, InsertPos); + Instruction *stInst=new StoreInst(val, rInst);//, InsertPos); + BB->getInstList().push_back(stInst); #endif break; } //case: r=0 to be inserted - case 2: + case 2:{ #ifdef INSERT_STORE - new StoreInst(ConstantSInt::getNullValue(Type::IntTy), rInst, InsertPos); + Instruction *stInst = new StoreInst(ConstantSInt::getNullValue(Type::IntTy), rInst);//, InsertPos); + BB->getInstList().push_back(stInst); #endif break; + } //r+=k case 3:{ - Instruction *ldInst = new LoadInst(rInst, "ti1", InsertPos); + Instruction *ldInst = new LoadInst(rInst, "ti1");//, InsertPos); + BB->getInstList().push_back(ldInst); Value *val = ConstantSInt::get(Type::IntTy,inc); - Value *addIn = BinaryOperator::create(Instruction::Add, ldInst, val, - "ti2", InsertPos); + Instruction *addIn = BinaryOperator::create(Instruction::Add, ldInst, val, + "ti2");//, InsertPos); + BB->getInstList().push_back(addIn); #ifdef INSERT_STORE - new StoreInst(addIn, rInst, InsertPos); + Instruction *stInst = new StoreInst(addIn, rInst);//, InsertPos); + BB->getInstList().push_back(stInst); #endif break; } //count[inc]++ case 4:{ - assert(inc>=0 && inc<=numPaths && "inc out of bound!"); - Instruction *Idx = new GetElementPtrInst(countInst, vector(1,ConstantSInt::get(Type::LongTy, inc)), - "", InsertPos); + "");//, InsertPos); + BB->getInstList().push_back(Idx); - Instruction *ldInst=new LoadInst(Idx, "ti1", InsertPos); + Instruction *ldInst=new LoadInst(Idx, "ti1");//, InsertPos); + BB->getInstList().push_back(ldInst); Value *val = ConstantSInt::get(Type::IntTy, 1); - Instruction *addIn = - BinaryOperator::create(Instruction::Add, ldInst, val,"ti2", InsertPos); + //Instruction *addIn = + Instruction *newCount = + BinaryOperator::create(Instruction::Add, ldInst, val,"ti2"); + BB->getInstList().push_back(newCount); + #ifdef INSERT_STORE - Instruction *stInst=new StoreInst(addIn, Idx, InsertPos); + //Instruction *stInst=new StoreInst(addIn, Idx, InsertPos); + Instruction *stInst=new StoreInst(newCount, Idx);//, InsertPos); + BB->getInstList().push_back(stInst); #endif + + Value *trAddIndex = ConstantSInt::get(Type::IntTy,inc); + retVec.push_back(newCount); + retVec.push_back(trAddIndex); //insert trigger - getTriggerCode(M->getParent(), BB, MethNo, - ConstantSInt::get(Type::IntTy,inc), addIn, InsertPos); + //getTriggerCode(M->getParent(), BB, MethNo, + // ConstantSInt::get(Type::IntTy,inc), newCount, triggerInst); //end trigger code assert(inc>=0 && "IT MUST BE POSITIVE NOW"); @@ -116,30 +144,42 @@ void getEdgeCode::getCode(Instruction *rInst, case 5:{ //ti1=inc+r - Instruction *ldIndex=new LoadInst(rInst, "ti1", InsertPos); + Instruction *ldIndex=new LoadInst(rInst, "ti1");//, InsertPos); + BB->getInstList().push_back(ldIndex); + Value *val=ConstantSInt::get(Type::IntTy,inc); Instruction *addIndex=BinaryOperator:: - create(Instruction::Add, ldIndex, val,"ti2", InsertPos); + create(Instruction::Add, ldIndex, val,"ti2");//, InsertPos); + BB->getInstList().push_back(addIndex); //now load count[addIndex] Instruction *castInst=new CastInst(addIndex, - Type::LongTy,"ctin", InsertPos); - Instruction *Idx = new GetElementPtrInst(countInst, - vector(1,castInst), "", - InsertPos); + Type::LongTy,"ctin");//, InsertPos); + BB->getInstList().push_back(castInst); + + Instruction *Idx = new GetElementPtrInst(countInst, + vector(1,castInst), "");//, + // InsertPos); + BB->getInstList().push_back(Idx); + + Instruction *ldInst=new LoadInst(Idx, "ti3");//, InsertPos); + BB->getInstList().push_back(ldInst); - Instruction *ldInst=new LoadInst(Idx, "ti3", InsertPos); Value *cons=ConstantSInt::get(Type::IntTy,1); //count[addIndex]++ - Value *addIn = BinaryOperator::create(Instruction::Add, ldInst, - cons,"", InsertPos); + Instruction *newCount = BinaryOperator::create(Instruction::Add, ldInst, + cons,""); + BB->getInstList().push_back(newCount); #ifdef INSERT_STORE - Instruction *stInst = new StoreInst(addIn, Idx, InsertPos); + Instruction *stInst = new StoreInst(newCount, Idx);//, InsertPos); + BB->getInstList().push_back(stInst); #endif + retVec.push_back(newCount); + retVec.push_back(addIndex); //insert trigger - getTriggerCode(M->getParent(), BB, MethNo, addIndex, addIn, InsertPos); + //getTriggerCode(M->getParent(), BB, MethNo, addIndex, newCount, triggerInst); //end trigger code break; @@ -148,39 +188,38 @@ void getEdgeCode::getCode(Instruction *rInst, //case: count[r]+ case 6:{ //ti1=inc+r - Instruction *ldIndex=new LoadInst(rInst, "ti1", InsertPos); - + Instruction *ldIndex=new LoadInst(rInst, "ti1");//, InsertPos); + BB->getInstList().push_back(ldIndex); + //now load count[addIndex] - Instruction *castInst2=new CastInst(ldIndex, Type::LongTy,"ctin",InsertPos); + Instruction *castInst2=new CastInst(ldIndex, Type::LongTy,"ctin"); + BB->getInstList().push_back(castInst2); + Instruction *Idx = new GetElementPtrInst(countInst, - vector(1,castInst2), "", - InsertPos); + vector(1,castInst2), ""); + BB->getInstList().push_back(Idx); - Instruction *ldInst=new LoadInst(Idx, "ti2", InsertPos); + Instruction *ldInst=new LoadInst(Idx, "ti2");//, InsertPos); + BB->getInstList().push_back(ldInst); + Value *cons=ConstantSInt::get(Type::IntTy,1); //count[addIndex]++ - Instruction *addIn=BinaryOperator::create(Instruction::Add, ldInst, - cons,"ti3", InsertPos); + Instruction *newCount = BinaryOperator::create(Instruction::Add, ldInst, + cons,"ti3"); + BB->getInstList().push_back(newCount); #ifdef INSERT_STORE - new StoreInst(addIn, Idx, InsertPos); + Instruction *stInst = new StoreInst(newCount, Idx);//, InsertPos); + BB->getInstList().push_back(stInst); #endif - //insert trigger - getTriggerCode(M->getParent(), BB, MethNo, ldIndex, addIn, InsertPos); - //end trigger code + + retVec.push_back(newCount); + retVec.push_back(ldIndex); break; } } - //now check for cdIn and cdOut - //first put cdOut - if(cdIn!=NULL){ - cdIn->getCode(rInst, countInst, M, BB, numPaths, MethNo); - } - if(cdOut!=NULL){ - cdOut->getCode(rInst, countInst, M, BB, numPaths, MethNo); - } } @@ -196,7 +235,7 @@ void getEdgeCode::getCode(Instruction *rInst, void insertInTopBB(BasicBlock *front, int k, Instruction *rVar, - Instruction *countVar){ + Instruction *countVar, Value *threshold){ //rVar is variable r, //countVar is array Count, and these are allocatted outside @@ -209,26 +248,34 @@ void insertInTopBB(BasicBlock *front, //Initialize Count[...] with 0 - for (int i=0;i(1,ConstantSInt::get(Type::LongTy, i)), - "", here); - new StoreInst(Int0, GEP2, here); - } + //for (int i=0;i(1,ConstantSInt::get(Type::LongTy, i)), + // "", here); + //new StoreInst(Int0, GEP2, here); + //} //store uint 0, uint *%R new StoreInst(Int0, rVar, here); + //insert initialize function for initializing + vector inCountArgs; + inCountArgs.push_back(PointerType::get(Type::IntTy)); + inCountArgs.push_back(Type::IntTy); + + const FunctionType *cFty = FunctionType::get(Type::VoidTy, inCountArgs, + false); + Function *inCountMth = front->getParent()->getParent()->getOrInsertFunction("llvmInitializeCounter", cFty); + assert(inCountMth && "Initialize method could not be inserted!"); + + vector iniArgs; + iniArgs.push_back(countVar); + iniArgs.push_back(ConstantSInt::get(Type::IntTy, k)); + new CallInst(inCountMth, iniArgs, "", here); + + if(front->getParent()->getName() == "main"){ - - //if its a main function, do the following! - //A global variable: %llvm_threshold - //%llvm_threshold = uninitialized global int - GlobalVariable *threshold = new GlobalVariable(Type::IntTy, false, true, 0, - "reopt_threshold"); - - front->getParent()->getParent()->getGlobalList().push_back(threshold); - + //intialize threshold vector initialize_args; initialize_args.push_back(PointerType::get(Type::IntTy)); @@ -240,7 +287,7 @@ void insertInTopBB(BasicBlock *front, vector trargs; trargs.push_back(threshold); - new CallInst(initialMeth, trargs, "", front->begin()); + new CallInst(initialMeth, trargs, "", here); } } @@ -251,7 +298,7 @@ void insertBB(Edge ed, getEdgeCode *edgeCode, Instruction *rInst, Instruction *countInst, - int numPaths, int Methno){ + int numPaths, int Methno, Value *threshold){ BasicBlock* BB1=ed.getFirst()->getElement(); BasicBlock* BB2=ed.getSecond()->getElement(); @@ -267,15 +314,18 @@ void insertBB(Edge ed, TerminatorInst *TI=BB1->getTerminator(); BasicBlock *newBB=new BasicBlock("counter", BB1->getParent()); - //Is terminator a branch instruction? - //then we need to change branch destinations to include new BB + //get code for the new BB + vector retVec; + + edgeCode->getCode(rInst, countInst, BB1->getParent(), newBB, retVec); BranchInst *BI = cast(TI); + //Is terminator a branch instruction? + //then we need to change branch destinations to include new BB + if(BI->isUnconditional()){ BI->setUnconditionalDest(newBB); - Instruction *newBI2=new BranchInst(BB2); - newBB->getInstList().push_back(newBI2); } else{ if(BI->getSuccessor(0)==BB2) @@ -283,15 +333,35 @@ void insertBB(Edge ed, if(BI->getSuccessor(1)==BB2) BI->setSuccessor(1, newBB); + } + BasicBlock *triggerBB = NULL; + if(retVec.size()>0){ + triggerBB = new BasicBlock("trigger", BB1->getParent()); + getTriggerCode(BB1->getParent()->getParent(), triggerBB, Methno, + retVec[1], countInst);//retVec[0]); + + //Instruction *castInst = new CastInst(retVec[0], Type::IntTy, ""); + Instruction *etr = new LoadInst(threshold, "threshold"); + + //std::cerr<<"type1: "<getType()<<" type2: "<getType()<<"\n"; + Instruction *cmpInst = new SetCondInst(Instruction::SetLE, etr, + retVec[0], ""); + Instruction *newBI2 = new BranchInst(triggerBB, BB2, cmpInst); + //newBB->getInstList().push_back(castInst); + newBB->getInstList().push_back(etr); + newBB->getInstList().push_back(cmpInst); + newBB->getInstList().push_back(newBI2); + + //triggerBB->getInstList().push_back(triggerInst); + Instruction *triggerBranch = new BranchInst(BB2); + triggerBB->getInstList().push_back(triggerBranch); + } + else{ Instruction *newBI2=new BranchInst(BB2); newBB->getInstList().push_back(newBI2); } - //get code for the new BB - edgeCode->getCode(rInst, countInst, BB1->getParent(), newBB, numPaths, Methno); - - //get code for the new BB //now iterate over BB2, and set its Phi nodes right for(BasicBlock::iterator BB2Inst = BB2->begin(), BBend = BB2->end(); BB2Inst != BBend; ++BB2Inst){ @@ -300,6 +370,13 @@ void insertBB(Edge ed, int bbIndex=phiInst->getBasicBlockIndex(BB1); assert(bbIndex>=0); phiInst->setIncomingBlock(bbIndex, newBB); + + ///check if trigger!=null, then add value corresponding to it too! + if(retVec.size()>0){ + assert(triggerBB && "BasicBlock with trigger should not be null!"); + Value *vl = phiInst->getIncomingValue((unsigned int)bbIndex); + phiInst->addIncoming(vl, triggerBB); + } } } } diff --git a/lib/Transforms/Instrumentation/ProfilePaths/Graph.h b/lib/Transforms/Instrumentation/ProfilePaths/Graph.h index 1da7bf10613..7fba0162d15 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/Graph.h +++ b/lib/Transforms/Instrumentation/ProfilePaths/Graph.h @@ -417,7 +417,7 @@ public: //get the code to be inserted on the edge //This is determined from cond (1-6) void getCode(Instruction *a, Instruction *b, Function *M, BasicBlock *BB, - int numPaths, int MethNo); + std::vector &retVec); }; @@ -429,7 +429,7 @@ void printEdge(Edge ed); //Do graph processing: to determine minimal edge increments, //appropriate code insertions etc and insert the code at //appropriate locations -void processGraph(Graph &g, Instruction *rInst, Instruction *countInst, std::vector &be, std::vector &stDummy, std::vector &exDummy, int n, int MethNo); +void processGraph(Graph &g, Instruction *rInst, Instruction *countInst, std::vector &be, std::vector &stDummy, std::vector &exDummy, int n, int MethNo, Value *threshold); //print the graph (for debugging) void printGraph(Graph &g); @@ -438,7 +438,7 @@ void printGraph(Graph &g); //void printGraph(const Graph g); //insert a basic block with appropriate code //along a given edge -void insertBB(Edge ed, getEdgeCode *edgeCode, Instruction *rInst, Instruction *countInst, int n, int Methno); +void insertBB(Edge ed, getEdgeCode *edgeCode, Instruction *rInst, Instruction *countInst, int n, int Methno, Value *threshold); //Insert the initialization code in the top BB //this includes initializing r, and count @@ -448,7 +448,7 @@ void insertBB(Edge ed, getEdgeCode *edgeCode, Instruction *rInst, Instruction *c //number of that path //Count is an array, where Count[k] represents //the number of executions of path k -void insertInTopBB(BasicBlock *front, int k, Instruction *rVar, Instruction *countVar); +void insertInTopBB(BasicBlock *front, int k, Instruction *rVar, Instruction *countVar, Value *threshold); //Add dummy edges corresponding to the back edges //If a->b is a backedge diff --git a/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxiliary.cpp b/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxiliary.cpp index 3542a9ece56..76109822d15 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxiliary.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxiliary.cpp @@ -486,7 +486,8 @@ void processGraph(Graph &g, vector& be, vector& stDummy, vector& exDummy, - int numPaths, int MethNo){ + int numPaths, int MethNo, + Value *threshold){ //Given a graph: with exit->root edge, do the following in seq: //1. get back edges @@ -648,7 +649,7 @@ void processGraph(Graph &g, for(map::iterator MI=codeInsertions.begin(), ME=codeInsertions.end(); MI!=ME; ++MI){ Edge ed=MI->first; - insertBB(ed, MI->second, rInst, countInst, numPaths, MethNo); + insertBB(ed, MI->second, rInst, countInst, numPaths, MethNo, threshold); } } diff --git a/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxillary.cpp b/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxillary.cpp index 3542a9ece56..76109822d15 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxillary.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxillary.cpp @@ -486,7 +486,8 @@ void processGraph(Graph &g, vector& be, vector& stDummy, vector& exDummy, - int numPaths, int MethNo){ + int numPaths, int MethNo, + Value *threshold){ //Given a graph: with exit->root edge, do the following in seq: //1. get back edges @@ -648,7 +649,7 @@ void processGraph(Graph &g, for(map::iterator MI=codeInsertions.begin(), ME=codeInsertions.end(); MI!=ME; ++MI){ Edge ed=MI->first; - insertBB(ed, MI->second, rInst, countInst, numPaths, MethNo); + insertBB(ed, MI->second, rInst, countInst, numPaths, MethNo, threshold); } } diff --git a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp index cd341920a55..48d5e85e646 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp @@ -26,11 +26,13 @@ #include "llvm/Transforms/Instrumentation/ProfilePaths.h" #include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h" +#include "llvm/Transforms/Instrumentation/Graph.h" #include "llvm/Support/CFG.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/iMemory.h" -#include "llvm/Transforms/Instrumentation/Graph.h" +#include "llvm/GlobalVariable.h" +#include "llvm/Module.h" #include #include @@ -184,15 +186,29 @@ bool ProfilePaths::runOnFunction(Function &F){ AllocaInst(Type::IntTy, ConstantUInt::get(Type::UIntTy, numPaths), "Count"); + static GlobalVariable *threshold = NULL; + static bool insertedThreshold = false; + + if(!insertedThreshold){ + threshold = new GlobalVariable(Type::IntTy, false, true, 0, + "reopt_threshold"); + + F.getParent()->getGlobalList().push_back(threshold); + insertedThreshold = true; + } + + assert(threshold && "GlobalVariable threshold not defined!"); + // insert initialization code in first (entry) BB // this includes initializing r and count - insertInTopBB(&F.getEntryNode(),numPaths, rVar, countVar); + insertInTopBB(&F.getEntryNode(),numPaths, rVar, countVar, threshold); //now process the graph: get path numbers, //get increments along different paths, //and assign "increments" and "updates" (to r and count) //"optimally". Finally, insert llvm code along various edges - processGraph(g, rVar, countVar, be, stDummy, exDummy, numPaths, mn); + processGraph(g, rVar, countVar, be, stDummy, exDummy, numPaths, mn, + threshold); return true; // Always modifies function }