//===-- EdgeCode.cpp - generate LLVM instrumentation code --------*- C++ -*--=// //It implements the class EdgeCode: which provides //support for inserting "appropriate" instrumentation at //designated points in the graph // //It also has methods to insert initialization code in //top block of cfg //===----------------------------------------------------------------------===// #include "llvm/Transforms/Instrumentation/Graph.h" #include "llvm/BasicBlock.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/iMemory.h" #include "llvm/iTerminators.h" #include "llvm/iOther.h" #include "llvm/iOperators.h" #include "llvm/iPHINode.h" #include "llvm/Module.h" #include "llvm/SymbolTable.h" #include "llvm/GlobalVariable.h" #include "llvm/Constants.h" #include "llvm/BasicBlock.h" #include "llvm/Function.h" #include #include #include #define INSERT_LOAD_COUNT #define INSERT_STORE using std::vector; void getTriggerCode(Module *M, BasicBlock *BB, int MethNo, Value *pathNo, Value *cnt){ static int i=-1; i++; char gstr[100]; sprintf(gstr,"globalVar%d",i); std::string globalVarName=gstr; SymbolTable *ST = M->getSymbolTable(); vector args; //args.push_back(PointerType::get(Type::SByteTy)); args.push_back(Type::IntTy); args.push_back(Type::IntTy); args.push_back(Type::IntTy); const FunctionType *MTy = FunctionType::get(Type::VoidTy, args, false); // Function *triggerMeth = M->getOrInsertFunction("trigger", MTy); Function *trigMeth = M->getOrInsertFunction("trigger", MTy); assert(trigMeth && "trigger method could not be inserted!"); //if (Value *triggerMeth = ST->lookup(PointerType::get(MTy), "trigger")) { //Function *trigMeth = cast(triggerMeth); vector trargs; //pred_iterator piter=BB->pred_begin(); //std::string predName = "uu";//BB->getName(); //Constant *bbName=ConstantArray::get(predName);//BB->getName()); //GlobalVariable *gbl=new GlobalVariable(ArrayType::get(Type::SByteTy, // predName.size()+1), // true, true, bbName, gstr); //M->getGlobalList().push_back(gbl); vector elargs; elargs.push_back(ConstantUInt::get(Type::UIntTy, 0)); elargs.push_back(ConstantUInt::get(Type::UIntTy, 0)); // commented out bb name frm which its called //Instruction *getElmntInst=new GetElementPtrInst(gbl,elargs,"elmntInst"); //trargs.push_back(ConstantArray::get(BB->getName())); //trargs.push_back(getElmntInst); //trargs.push_back(bbName); trargs.push_back(ConstantSInt::get(Type::IntTy,MethNo)); //trargs.push_back(ConstantSInt::get(Type::IntTy,-1));//erase this trargs.push_back(pathNo); trargs.push_back(cnt); Instruction *callInst=new CallInst(trigMeth,trargs); BasicBlock::InstListType& instList=BB->getInstList(); BasicBlock::iterator here=instList.begin(); //here = ++instList.insert(here, getElmntInst); instList.insert(here,callInst); } //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){ BasicBlock::InstListType& instList=BB->getInstList(); BasicBlock::iterator here=instList.begin(); //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); here = ++instList.insert(here,stInst); #endif break; } //case: r=0 to be inserted case 2:{ Value *val=ConstantSInt::get(Type::IntTy,0); #ifdef INSERT_STORE Instruction *stInst=new StoreInst(val, rInst); here = ++instList.insert(here,stInst); #endif break; } //r+=k case 3:{ Instruction *ldInst=new LoadInst(rInst, "ti1"); Value *val=ConstantSInt::get(Type::IntTy,inc); Instruction *addIn=BinaryOperator:: create(Instruction::Add, ldInst, val,"ti2"); #ifdef INSERT_STORE Instruction *stInst=new StoreInst(addIn, rInst); #endif here = ++instList.insert(here,ldInst); here = ++instList.insert(here,addIn); #ifdef INSERT_STORE here = ++instList.insert(here,stInst); #endif break; } //count[inc]++ case 4:{ assert(inc>=0 && inc<=numPaths && "inc out of bound!"); Instruction *ldInst=new LoadInst(countInst,vector (1,ConstantUInt::get(Type::UIntTy, inc)), "ti1"); Value *val=ConstantSInt::get(Type::IntTy,1); Instruction *addIn=BinaryOperator:: create(Instruction::Add, ldInst, val,"ti2"); //insert trigger getTriggerCode(M->getParent(), BB, MethNo, ConstantSInt::get(Type::IntTy,inc), addIn); here=instList.begin(); //end trigger code assert(inc>=0 && "IT MUST BE POSITIVE NOW"); #ifdef INSERT_STORE Instruction *stInst=new StoreInst(addIn, countInst, vector (1, ConstantUInt::get(Type::UIntTy,inc))); #endif here = ++instList.insert(here,ldInst); here = ++instList.insert(here,addIn); #ifdef INSERT_STORE here = ++instList.insert(here,stInst); #endif break; } //case: count[r+inc]++ case 5:{ //ti1=inc+r Instruction *ldIndex=new LoadInst(rInst, "ti1"); Value *val=ConstantSInt::get(Type::IntTy,inc); Instruction *addIndex=BinaryOperator:: create(Instruction::Add, ldIndex, val,"ti2"); //erase following 1 line //Value *valtemp=ConstantSInt::get(Type::IntTy,999); //now load count[addIndex] Instruction *castInst=new CastInst(addIndex, Type::UIntTy,"ctin"); Instruction *ldInst=new LoadInst(countInst, vector(1,castInst), "ti3"); Value *cons=ConstantSInt::get(Type::IntTy,1); //count[addIndex]++ Instruction *addIn=BinaryOperator:: create(Instruction::Add, ldInst, cons,"ti4"); //insert trigger getTriggerCode(M->getParent(), BB, MethNo, addIndex, addIn); here=instList.begin(); //end trigger code #ifdef INSERT_STORE ///* Instruction *stInst=new StoreInst(addIn, countInst, vector(1,castInst)); //*/ #endif here = ++instList.insert(here,ldIndex); here = ++instList.insert(here,addIndex); here = ++instList.insert(here,castInst); here = ++instList.insert(here,ldInst); here = ++instList.insert(here,addIn); #ifdef INSERT_STORE here = ++instList.insert(here,stInst); #endif break; } //case: count[r]+ case 6:{ //ti1=inc+r Instruction *ldIndex=new LoadInst(rInst, "ti1"); //now load count[addIndex] Instruction *castInst2=new CastInst(ldIndex, Type::UIntTy,"ctin"); Instruction *ldInst=new LoadInst(countInst, vector(1,castInst2), "ti2"); Value *cons=ConstantSInt::get(Type::IntTy,1); //count[addIndex]++ Instruction *addIn=BinaryOperator:: create(Instruction::Add, ldInst, cons,"ti3"); //insert trigger getTriggerCode(M->getParent(), BB, MethNo, ldIndex, addIn); here=instList.begin(); //end trigger code #ifdef INSERT_STORE Instruction *stInst=new StoreInst(addIn, countInst, vector(1,castInst2)); #endif here = ++instList.insert(here,ldIndex); here = ++instList.insert(here,castInst2); here = instList.insert(here,ldInst); here = instList.insert(here,addIn); #ifdef INSERT_STORE here = instList.insert(here,stInst); #endif 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); } } //Insert the initialization code in the top BB //this includes initializing r, and count //r is like an accumulator, that //keeps on adding increments as we traverse along a path //and at the end of the path, r contains the path //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){ //rVar is variable r, //countVar is array Count, and these are allocatted outside //store uint 0, uint *%R, uint 0 vector idx; idx.push_back(ConstantUInt::get(Type::UIntTy, 0)); Instruction *stInstr=new StoreInst(ConstantInt::get(Type::IntTy, 0), rVar, idx); //now push all instructions in front of the BB BasicBlock::InstListType& instList=front->getInstList(); BasicBlock::iterator here=instList.begin(); here=++front->getInstList().insert(here, rVar); here=++front->getInstList().insert(here,countVar); //Initialize Count[...] with 0 for(int i=0;i (1,ConstantUInt::get(Type::UIntTy, i))); here=++front->getInstList().insert(here,stInstrC); } here = ++front->getInstList().insert(here,stInstr); } //insert a basic block with appropriate code //along a given edge void insertBB(Edge ed, getEdgeCode *edgeCode, Instruction *rInst, Instruction *countInst, int numPaths, int Methno){ static int i=-1; i++; BasicBlock* BB1=ed.getFirst()->getElement(); BasicBlock* BB2=ed.getSecond()->getElement(); #ifdef DEBUG_PATH_PROFILES //debugging info cerr<<"Edges with codes ######################\n"; cerr<getName()<<"->"<getName()<<"\n"; cerr<<"########################\n"; #endif char counterstr[100]; sprintf(counterstr,"counter%d",i); std::string ctr=counterstr; //We need to insert a BB between BB1 and BB2 TerminatorInst *TI=BB1->getTerminator(); BasicBlock *newBB=new BasicBlock(ctr, BB1->getParent()); //get code for the new BB edgeCode->getCode(rInst, countInst, BB1->getParent(), newBB, numPaths, Methno); //Is terminator a branch instruction? //then we need to change branch destinations to include new BB //std::cerr<<"before cast!\n"; //std::cerr<<"Method no in Edgecode:"<(TI); if(BI->isUnconditional()){ BI->setUnconditionalDest(newBB); Instruction *newBI2=new BranchInst(BB2); newBB->getInstList().push_back(newBI2); } else{ if(BI->getSuccessor(0)==BB2) BI->setSuccessor(0, newBB); if(BI->getSuccessor(1)==BB2) BI->setSuccessor(1, newBB); Instruction *newBI2=new BranchInst(BB2); newBB->getInstList().push_back(newBI2); } //std::cerr<<"After casting\n"; //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){ if(PHINode *phiInst=dyn_cast(&*BB2Inst)){ int bbIndex=phiInst->getBasicBlockIndex(BB1); assert(bbIndex>=0); phiInst->setIncomingBlock(bbIndex, newBB); } } }