mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-30 23:42:52 +01:00
376 lines
11 KiB
C++
376 lines
11 KiB
C++
//===-- 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 <string.h>
|
|
#include <stdio.h>
|
|
#include <iostream>
|
|
|
|
#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<const Type*> 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<Function>(triggerMeth);
|
|
vector<Value *> 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<Value *> 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<Value *>
|
|
(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<Value *>
|
|
(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<Value *>(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<Value *>(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<Value *>(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<Value *>(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<Value *> 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<k; i++){
|
|
Instruction *stInstrC=new
|
|
StoreInst(ConstantInt::get(Type::IntTy, 0),
|
|
countVar, std::vector<Value *>
|
|
(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<<BB1->getName()<<"->"<<BB2->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:"<<Methno<<"\n";
|
|
//std::cerr<<"Instruction\n";
|
|
//std::cerr<<*TI;
|
|
BranchInst *BI = cast<BranchInst>(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<PHINode>(&*BB2Inst)){
|
|
int bbIndex=phiInst->getBasicBlockIndex(BB1);
|
|
assert(bbIndex>=0);
|
|
phiInst->setIncomingBlock(bbIndex, newBB);
|
|
}
|
|
}
|
|
}
|
|
|