// if (USE_ALIAS_SETS)

// AU.addRequired<AliasSets> ();

AU.setPreservesAll();

// AliasSets* AS = NULL;

// if (USE_ALIAS_SETS)

// AS = &(getAnalysis<AliasSets> ());

//Making dependency graph

depGraph = new llvm::Graph();

//Insert instructions in the graph

for (Function::iterator BBit = F.begin(), BBend = F.end(); BBit != BBend; ++BBit) {

for (BasicBlock::iterator Iit = BBit->begin(), Iend = BBit->end(); Iit

!= Iend; ++Iit) {

depGraph->addInst_new(Iit);

}

}

//We don't modify anything, so we must return false

return false;

// if (USE_ALIAS_SETS)

// AU.addRequired<AliasSets> ();

AU.addRequired<CallGraphWrapperPass> ();

AU.addRequired<CallGraphWrapper> ();

//AU.addRequiredTransitive<AliasAnalysis>();

AU.addRequired<MemoryDependenceAnalysis>();

AU.addRequired<PostDominatorTree>();

//AU.addRequired<MemDepPrinter>();

AU.addRequired<InputDep> ();

//if(USE_DSA1)

AU.addRequired<BUDataStructures> ();

AU.setPreservesAll();

//Get results from all the previous analysis:

CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();

InputDep &IV = getAnalysis<InputDep> ();

inputDepValues = IV.getInputDepValues();

CallGraphWrapper &cgWrapper = getAnalysis<CallGraphWrapper> ();

callPaths = cgWrapper.getCallPaths();

IndMap = cgWrapper.getIndirectMap();

//Initalize all the config params.

configData = IV.getConfigInfo();

useCallStrings = configData.useCallString;

//Read the relevant tainted fields supplied to the code to make it field sensitive.

//TODO :NT: once the struct is found in parsing--update the struct and field Types

ReadRelevantFields();

//if(USE_DSA1) //need to do this irrespective of the flag, null initialize not allowed.

BUDataStructures &BU_ds = getAnalysis<BUDataStructures>();

//Making dependency graph

depGraph = new Graph();

TopDownGraph = new Graph();

FullGraph = new Graph();

//depGraph->toDot("base","../../AliasSetGraph.dot");

//Get the relevant functions on the call path.. approach before the call strings approach.

//Check if the option provided..

//getcallPathFunctions();

//Initialize DSA pointsto graph for each function.

InitializePointtoGraphs(M, BU_ds);

//Process Global variables... it handles the globals when they are used, no need to add seperately unless source.

// ProcessGlobals(M,TopDownGraph);

//Generate the flow graph for all the funcitons:

for (Module::iterator Fit = M.begin(), Fend = M.end(); Fit != Fend; ++Fit) {

Function *F = Fit;

if (F && !F->isDeclaration()) {

Graph* Fdep = new Graph();

// if(code) errs()<<"\n\n Processing function fdep graph.. for "<<F->getName();

// Process_Functions(F,Fdep,SensitivityDepth);

if(code) errs()<<"\n Processing function topdown graph.. for "<<F->getName()<<"\n";

Process_Functions(F,TopDownGraph,SensitivityDepth);

FuncDepGraphs[F] = Fdep;

std::string tmp = F->getName();

// replace(tmp.begin(), tmp.end(), '\\', '_');

std::string Filename = "../../demo1_" + tmp + ".dot";

//string fileName = "../../"+F->getName()+"_graph.dot";

// errs()<<"\n Processing Function ******************* "<<F->getName();

// Fdep->toDot(F->getName(),Filename);

}

}

//Process each call site in sequence..

Graph * moduleGraph = new Graph();

errs()<<"\n Process the call inst in each function..";

for (Module::iterator Fit = M.begin(), Fend = M.end(); Fit != Fend; ++Fit) {

//Check if function in callstrings, parse to connect callsites to targets that are in callstrings.

if(configData.useCallString && !(callPaths.size()==0) && isFunctiononCallString(Fit))

{

// errs()<<"\ncalstring funct.. "<<Fit->getName();

ProcessCSinFunc(Fit,true,TopDownGraph);

}

else

{

//errs()<<"\n Call process.. "<<Fit->getName();

ProcessCSinFunc(Fit,false,TopDownGraph);

}

}

//Assiging to depgraph for taint --- temporarily

depGraph = TopDownGraph;

std::string Filename = "../../noConstTopDownGraph.dot";

errs()<<"\n Writing dot for **************** ..TopDownGraph";

// TopDownGraph->toDot("TopDown",Filename);

//We don't modify anything, so we must return false

return false;

{

bool isProcessed = false;

for(vector<instructionCallSite*>::iterator csIt = ProcessedCallsites.begin(); csIt != ProcessedCallsites.end();++csIt)

{

if((*csIt)->callInst == CI && (*csIt)->function == calledFunc)

{

isProcessed = true;

continue;

}

}

return isProcessed;

{

Function * caller = CI->getParent()->getParent();

if (Callee->isVarArg() || !Callee->hasNUsesOrMore(1)) {

return;

}

FuncParamInfo* paramInfo = modGraph->functionParamMap[Callee];

if(paramInfo)

{

CallSite cs(CI);

GraphNode* callSiteNode = modGraph->findInstNode(CI);

if(!callSiteNode)

callSiteNode = modGraph->addNode(CI,ntInst);

//Add control edge to function entry node:

if(GraphNode * entryNode = paramInfo->entryNode){

if(AddControlEdges)

callSiteNode->connect(entryNode,etCall);

}

//iterate over the args and find the nodes in caller func...

//connect act in to formal in... formal out to act in from callsite..

//return nodes to the call stmt.

// Data structure which contains the matches between formal and real parameters

// First: formal parameter

// Second: real parameter

SmallVector<std::pair<GraphNode*, GraphNode*>, 4> FormalIns(Callee->arg_size());

SmallVector<std::pair<GraphNode*, GraphNode*>, 4> FormalOuts(Callee->arg_size());

// Fetch the function arguments (formal parameters) into the data structure

Function::arg_iterator argptr;

Function::arg_iterator e;

unsigned i;

//Create the PHI nodes for the formal parameters

for (i = 0, argptr = Callee->arg_begin(), e = Callee->arg_end(); argptr != e; ++i, ++argptr) {

// OpNode* argPHI = new OpNode(Instruction::PHI);

Value *argValue = argptr;

//GraphNode* formArg = NULL;

GraphNode* formArg = paramInfo->FormalInMap[argValue];

//

if(!formArg)

formArg = modGraph->findInstNode(argValue); //,-1,Callee);

if(!formArg)

if(Instruction *inst = dyn_cast<Instruction>(argValue))

formArg = modGraph->addNode(inst,ntFormalIn);

//

FormalIns[i].second = formArg;

// errs()<<"\n Formal args : "<<formArg->getLabel();

//Collect corresponding formal out params..

GraphNode* formArgout = paramInfo->FormalOutMap[argValue];

//

if(!formArgout)

formArgout = modGraph->findInstNode(argValue); //,-1,Callee);

if(!formArgout)

if(Instruction *inst = dyn_cast<Instruction>(argValue))

formArgout = modGraph->addNode(inst,ntFormalIn);

FormalOuts[i].first = formArgout;

}

// Check if the function returns a supported value type. If not, no return value matching is done

bool noReturn = Callee->getReturnType()->isVoidTy();

// Creates the data structure which receives the return values of the function, if there is any

SmallPtrSet<llvm::Value*, 8> ReturnValues;

if (!noReturn) {

// Iterate over the basic blocks to fetch all possible return values

for (Function::iterator bb = Callee->begin(), bbend = Callee->end(); bb != bbend; ++bb) {

// Get the terminator instruction of the basic block and check if it's

// a return instruction: if it's not, continue to next basic block

Instruction *terminator = bb->getTerminator();

ReturnInst *RI = dyn_cast<ReturnInst> (terminator);

if (!RI)

continue;

// Get the return value and insert in the data structure

ReturnValues.insert(RI->getReturnValue());

}

}

//Get all correspoding graph nodes for rturns and connect it to the callsite node..

for(SmallPtrSet<Value*,8>::iterator retVals = ReturnValues.begin(); retVals != ReturnValues.end();++retVals)

{

Value * retval = *retVals;

if(GraphNode* retNode = paramInfo->RetValMap[retval]){

//errs()<<"\n retnode : "<<retNode->getLabel()<<" to -- call site "<<callSiteNode->getLabel();

retNode->connect(callSiteNode,etData);

}

else{

if(Instruction *inst = dyn_cast<Instruction>(retval)){

if(GraphNode * retNode = modGraph->findInstNode(inst)){

//errs()<<"\n inst node retnode : "<<retNode->getLabel()<<" to -- call site "<<callSiteNode->getLabel();

retNode->connect(callSiteNode,etData);

}

}

}

}

//Get actual param nodes.

CallSite::arg_iterator AI;

CallSite::arg_iterator EI;

for (i = 0, AI = cs.arg_begin(), EI = cs.arg_end(); AI != EI; ++i, ++AI) {

if(Instruction * argin = dyn_cast<Instruction>(*AI)){

if(GraphNode* argNode = modGraph->findInstNode(argin)){

FormalIns[i].first = argNode;

FormalOuts[i].second = argNode;

}

}

// Parameters[i].second = F_Graph->addInst(*AI,-1,Callee);

}

for (i = 0; i < FormalIns.size(); ++i) {

if(FormalIns[i].first && FormalIns[i].second){

FormalIns[i].first->connect(FormalIns[i].second,etParam);

}

// modGraph->addEdge(Parameters[i].second, Parameters[i].first);

// if(debug) errs()<<"\nAdding Edge between "<< Parameters[i].second->getLabel()<<" -- "<<Parameters[i].first->getLabel();

}

//Connecting the formal outs to actual vars from the call site..to capture the sideeffects.

for (i = 0; i < FormalOuts.size(); ++i) {

if(FormalOuts[i].first && FormalOuts[i].second){

FormalOuts[i].first->connect(FormalOuts[i].second,etParam);

}

// modGraph->addEdge(Parameters[i].second, Parameters[i].first);

// if(debug) errs()<<"\nAdding Edge between "<< Parameters[i].second->getLabel()<<" -- "<<Parameters[i].first->getLabel();

}

}

{

for (Function::iterator BBit = F->begin(), BBend = F->end(); BBit

!= BBend; ++BBit) {

for (BasicBlock::iterator Iit = BBit->begin(), Iend = BBit->end(); Iit

!= Iend; ++Iit) {

if(isa<CallInst>(Iit)) // handle the call inst.

{

CallInst *CI = dyn_cast<CallInst>(Iit);

CallSite cs(Iit);

Function * calledFunc = CI->getCalledFunction();

//errs()<<"\n Check called func and callstring...";

if(calledFunc && (!callString || (callString && isFunctiononCallString(F))))

{

//errs()<<"\n check if processed...CalledFunc : "<<calledFunc->getName();

//Process only if not processed....

if(isCallProcessed(CI,calledFunc))

continue;

//Check if library/external function

//errs()<<"\n Called func cs, not processed....";

if(calledFunc->isDeclaration())

{

if(calledFunc->getName().equals("llvm.dbg.declare"))

continue;

//ToDO: Process the library functions..

HandleLibraryFunctions(CI,F);

}

else

{

//Handle the call connect here...

ConnectCallerCallee(CI,calledFunc,modGraph);

}

//errs()<<"\n push back processed cs..)";

instructionCallSite* processedcall = new instructionCallSite();

processedcall->callInst = CI;

processedcall->function = calledFunc;

ProcessedCallsites.push_back(processedcall);

//errs()<<"\n done push back processed cs..";

} //end of if function to be procesed..

//ToDo: Check for indirect calls.. calledFunc will be empty..

if(!calledFunc)

{

Type *ty = cs.getCalledValue()->getType();

if(ty->isPointerTy())

{

if(ty->getPointerElementType()->isFunctionTy())

{

vector<Function*> targetFunctions = IndMap[cs];

for(vector<Function*>::iterator tfunc = targetFunctions.begin();tfunc != targetFunctions.end();++tfunc)

{

Function * targetF = (*tfunc);

//Check if the called function is defined and is in call string

if(targetF && (!callString || (callString && isFunctiononCallString(targetF))))

{

//check if callsite with the given target processed.

if(isCallProcessed(CI,targetF))

continue;

//Handle the call connect here...

ConnectCallerCallee(CI,targetF,modGraph);

}

else if(!targetF)

{

//ToDo: handle indirect call to external function....

}

instructionCallSite* processedcall = new instructionCallSite();

processedcall->callInst = CI;

processedcall->function = targetF;

ProcessedCallsites.push_back(processedcall);

}

}

}

}

} //end if of isa<callisnt>

} //end for bb iterator

}

{

//at a call site which needs to be processed...

//get the actual params for the function.. .. check the function map params..

for (Function::arg_iterator Arg = F->arg_begin(), aEnd = F->arg_end(); Arg != aEnd; Arg++) {

// Arg->dump();

//

}

//Create the graph add edges in the graph for the given function..!!

Process_Functions(F,TopDownGraph,SensitivityDepth);

{

for (Module::global_iterator GVI = M.global_begin(), E = M.global_end();

GVI != E; ) {

GlobalVariable *GV = GVI++;

// Global variables without names cannot be referenced outside this module.

if (!GV->hasName() && !GV->isDeclaration() && !GV->hasLocalLinkage())

GV->setLinkage(GlobalValue::InternalLinkage);

//Process the GV to add node in topdowngraph.

Value * GV_Val = GV;

//GV->dump();

//get val make node.. what all nodes to make and what all to eliminate.. nodes with no use delete..

// can run globalopt before...

if(!GV->use_empty())

{

// errs()<<"\n Adding global value: ";

// GV->dump();

TopDownGraph->addGlobalVal(GV);

}

}

{

//Processing the Function, generate the data flow graph.

Process_Functions(F,TopDownGraph,SensitivityDepth);

//Iterating over the function blocks to look for next call sites and process the targets.

for (Function::iterator BBit = F->begin(), BBend = F->end(); BBit

!= BBend; ++BBit) {

for (BasicBlock::iterator Iit = BBit->begin(), Iend = BBit->end(); Iit

!= Iend; ++Iit) {

//TODO: also handle if && !isa<InvokeInst>(U) check how is it different.

Instruction *Inst = &*Iit;

if(CallInst * CI = dyn_cast<CallInst>(Inst))

{

CallSite cs(CI);

Function * calledFunc = CI->getCalledFunction();

if(calledFunc && !calledFunc->isDeclaration())

{

// errs()<<"\nPROPAGATE: Call Site with called func and not delaration.. !!";

// CI->dump();

//Update the callSite structs;

CallSiteMap* cs_data = new CallSiteMap();

cs_data->cs = &cs;

cs_data->CalledFunc = calledFunc;

int processFreq = isCallSiteProcessed(cs_data);

if(processFreq == 0 || processFreq <= ProcessCallSiteFrequency)

{

Process_CallSite(Inst,calledFunc);

Graph * CallF_Graph = FuncDepGraphs[calledFunc];

// map params and merge graph..

}

} //if called func

// errs()<<"\n";

if(calledFunc && calledFunc->isDeclaration())

{

// errs()<<"\nPROPAGATE: Call Site with called func and IS delaration.. !!";

// CI->dump();

HandleLibraryFunctions(CI,F);

}

//TODO: else if indirect call then process for all target calls.

if(!calledFunc)

{

// errs()<<"\nPROPAGATE: in !calledFunc i.e no Func Body";

// CI->dump();

Type *ty = cs.getCalledValue()->getType();

if(ty->isPointerTy())

{

// errs()<<"\nPROPAGATE: Call Site with no Func Body and is pointer type.. indirect call";

// CI->dump();

if(ty->getPointerElementType()->isFunctionTy())

{

//Check if we have the targets identified for this..

vector<Function*> targetFunctions = IndMap[cs];

// errs()<<"\nPROPAGATE: Function pointer type !! : "<<targetFunctions.size();

// CI->dump();

for(vector<Function*>::iterator funit = targetFunctions.begin(); funit != targetFunctions.end();++funit)

{

CallSiteMap* cs_data = new CallSiteMap();

cs_data->cs = &cs;

cs_data->CalledFunc = (*funit);

int processFreq = isCallSiteProcessed(cs_data);

if(processFreq == 0 || processFreq <= ProcessCallSiteFrequency)

{

Process_CallSite(Inst,(*funit));

}

}

}

}

if((ty->isPointerTy() && IndMap[cs].size()==0 ))

{

//Library call case:: -- where the if(!calledfunc && (isdeclaration || (if pointer..then pointer targets==0) ))

// Hnalde lib call-- default way and then add more specifications.

// errs()<<"\n\n Handling LIBRARY CALL for: ";

// CI->dump();

HandleLibraryFunctions(CI,F);

}

} //end of indirect function check.

} //if call inst

}

}

{

//Default case : Adding edge from the callsite params to return variable. done by default

//handle special library functions here..

//Handle specific cases:

{

int freq = 0;

for(set<CallSiteMap*>::iterator csIT = CallSitesProcessed.begin(), csITEnd = CallSitesProcessed.end(); csIT != csITEnd; ++csIT)

{

if((csm->cs == (*csIT)->cs) && (csm->CalledFunc == (*csIT)->CalledFunc))

{

return (*csIT)->frequency;

}

}

return freq;

{

// queue<BasicBlock*>::iterator it = find(queueBlock.begin(),queueBlock.end(),bb);

if (setBlock.find(bb) == setBlock.end())

{

queueBlock.push(bb);

setBlock.insert(queueBlock.back()); // or "s.emplace(q.back());"

}

{

//initlialize global points to graph.

globalPointsToGraph = BU_ds.getGlobalsGraph();

//initialize functions points to graphs.

for (Module::iterator F = M.begin(), endF = M.end(); F != endF; ++F) {

if (F && !F->isDeclaration())

{

DSGraph *PointstoGraph = BU_ds.getDSGraph(*F);

funcPointsToMap[F] = PointstoGraph;

//Writes the Points to graph in dot files..

// std::string ErrorInfo;

// std::string fileName = "DSGraphInfo.txt";

// raw_fd_ostream File(fileName.c_str(), ErrorInfo,sys::fs::F_None);

// if (!ErrorInfo.empty()) {

// errs() << "Error opening file " << fileName

// << " for writing! Error Info: " << ErrorInfo << " \n";

// return;

// }

// std::string funcNames = PointstoGraph->getFunctionNames();

// PointstoGraph->writeGraphToFile(File,"../../TestFiles/"+funcNames);

}

}

{

callStringFunctions.push_back(F);

// currentCallString = currentCallString +","+F->getName();

currentCallString.append(",");

currentCallString.append(F->getName());

set< vector<Function*> > callStringFunc = ProcessedCallStringFunctions[F];

set<string> callStrings = ProcessedCallStrings[F];

errs()<<"\n\n Current Path:"<<currentCallString;

for(set<string>::iterator callst = callStrings.begin(); callst != callStrings.end(); ++callst)

{

string callstring = (*callst);

errs()<<"\n call string for function : "<<callstring;

// if(strcmp(currentCallString.c_str(),callstring.c_str()) == 0)

if(currentCallString.compare(callstring) == 0)

{

errs()<<"\n Path already processsed" << currentCallString;

return true;

}

}

callStrings.insert(currentCallString);

ProcessedCallStrings[F] = callStrings;

callStringFunc.insert(callStringFunctions);

ProcessedCallStringFunctions[F] = callStringFunc;

return false;

{

//Check if call path already processed if yes, dont process and return, else process with the appropriate context.

// if(debug)

errs()<<"\n Processing funtion recursive.. "<< F->getName() <<" ";

MDA = &getAnalysis<MemoryDependenceAnalysis>((*F));

//Make individual graphs for each functions..

// Graph* F_Graph = new Graph();

// FuncGraphMap[F] = F_Graph;

F_Graph->graph_type = gtFunctionData;

//Initialize the function paraminfo even if no parameters

FuncParamInfo* funcParam;

funcParam = F_Graph->functionParamMap[F];

if(!funcParam)

funcParam = new FuncParamInfo();

//Reset F_graph's store node map.

F_Graph->StoreNodeMap.clear();

//Add nodes for function parameters.. Actuals will be added at call statements.

// errs()<<"\n Generating Formal in and out nodes...";

for (Function::arg_iterator Arg = F->arg_begin(), aEnd = F->arg_end(); Arg != aEnd; Arg++) {

// Arg->dump();

GraphNode * pinNode = F_Graph->addParamNode(Arg ,F,ntFormalIn);

// errs()<<"\n Param added form in-- "<<pinNode->getLabel()<<pinNode->getId();

GraphNode * poutNode = F_Graph->addParamNode(Arg ,F,ntFormalOut);

// errs()<<"\n Param added form out-- "<<poutNode->getLabel()<<poutNode->getId();

}

// errs()<<"\n After Generating actual in and out nodes...";

//Add the ret val node..

//F provides return type..not the return value directly.. for each block check if return, ad node and push back in retmap.

//Get first block to process:

set<BasicBlock*> affected_BB;

queue<BasicBlock*> WorkList;

std::set<BasicBlock*> setBlock;

//Add all the instruction nodes for the function..

addNodes(F,F_Graph);

//Get the entry block in the function.

Function::iterator bbit = F->begin();

if(bbit)

{

WorkList.push(bbit);

// errs()<<"Processing the block now :"<<bbit->getName()<< " ";

while(!WorkList.empty())

{

BasicBlock *BBproc = WorkList.front();

WorkList.pop();

//Trial.. also try and remove the element from set as well.. will get only recursive elements..

// setBlock.erase(BBproc); dont process loop blocks again..

//TODO: reprocess the loop blocks only if context changes

//Process the popped block

affected_BB.clear();

affected_BB = Process_Block(BBproc, F_Graph);

//Iterate over the affected blocks and add them in worklist.

for(set<BasicBlock*>::iterator afB = affected_BB.begin(); afB != affected_BB.end();++afB)

{

WorkList.push(*afB);

//TODO: need some base condition to stop adding the affected blocks recursively., update: handle at proc block

}

//Iterate over the successors of the block and add them in the worklist.

TerminatorInst *TermInt = BBproc->getTerminator();

int SuccNum = TermInt->getNumSuccessors();

for(int i =0;i<SuccNum;i++)

{

BasicBlock *BBnext = TermInt->getSuccessor(i);

// WorkList.push(BBnext);

AddUniqueQueueItem(setBlock,WorkList,BBnext);

// errs()<<"\n\n Adding Block.. "<< BBnext->getName()<<" worklist Size "<<WorkList.size();

// errs()<<" = "<<setBlock.size();

}

}

}

//Mark Graph generated for the function

FunctionGraphGen[F] = 1;

//AddControl DEp edges for the Function...

if(AddControlEdges)

addControlDependencies(F,F_Graph);

///Bakward processing pass to process all loads..

{

//Add an entry node for the Function.

GraphNode *entryNode = F_Graph->addEntryNode(F);

//Add entry node in funcparam info for further reference.

FuncParamInfo* funcParam;

funcParam = F_Graph->functionParamMap[F];

if(!funcParam)

funcParam = new FuncParamInfo();

funcParam->entryNode = entryNode;

F_Graph->functionParamMap[F] = funcParam;

PostDominatorTree &PDT = getAnalysis<PostDominatorTree>(*F);

// // BasicBlock * BB = ;

DomTreeNode *node = PDT[&F->getEntryBlock()];

//F_Graph->nodes.insert(entryNode);

while (node && node->getBlock())

{

/*

addControlDep(entryNode, node->getBlock(), F_Graph,etControl);

node = node->getIDom();

}

std::vector<std::pair<BasicBlock *, BasicBlock *> > EdgeSet;

for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I)

{

///Zhiyuan comment: find adjacent BasicBlock pairs in CFG, but the predecessor does not dominate successor.

for (succ_iterator SI = succ_begin(I), SE = succ_end(I); SI != SE; ++SI)

{

assert(I && *SI);

if (!PDT.dominates(*SI, I)) {

// errs() << I->getName() << "\n";

// errs() << "I: " << I << "\n";

// errs() << "*SI: " << (*SI)->getName() << "\n";

// errs() << "Added to (A, B) edge set.\n";

EdgeSet.push_back(std::make_pair(I, *SI));

}

}

}

typedef std::vector<std::pair<BasicBlock *, BasicBlock *> >::iterator EdgeItr;

///Zhiyuan comment: find nearest common ancestor in Post Dominator Tree for the BasicBlock pair.

for (EdgeItr I = EdgeSet.begin(), E = EdgeSet.end(); I != E; ++I)

{

std::pair<BasicBlock *, BasicBlock *> Edge = *I;

BasicBlock *L = PDT.findNearestCommonDominator(Edge.first, Edge.second);

// int type = getDependenceType(Edge.first, Edge.second);

// BasicBlockWrapper *A = BasicBlockWrapper::bbMap[Edge.first];

// capture loop dependence

if (L == Edge.first) {

errs() << "\t find A == L: " << L->getName() << "\n";

addControlDep(Edge.first, L, F_Graph,etControl);

// errs() << "DepType: " << type << "\n";

}

DomTreeNode *domNode = PDT[Edge.second];

while (domNode->getBlock() != L)

{

addControlDep(Edge.first, domNode->getBlock(),F_Graph, etControl);

domNode = domNode->getIDom();

}

}

return;

{

for (llvm::BasicBlock::iterator ii = to->begin(), ie = to->end(); ii != ie; ++ii) {

if (llvm::Instruction* Ins = llvm::dyn_cast<llvm::Instruction>(ii) ) {

if (llvm::DebugFlag) {

llvm::errs() << "[i_cdg debug] dependence from type (" << from->getLabel() << ") to instruction (" << *Ins << ")\n";

}

if(GraphNode *iw = F_Graph->findInstNode(Ins))

from->connect(iw,eType);

}

}

{

Instruction *Ins = from->getTerminator();

assert(Ins);

if(GraphNode *iw = F_Graph->findInstNode(Ins))

{

//self loop

if (from == to) {

if (llvm::DebugFlag) {

llvm::errs() << "[i_cdg debug] loop dependence from (" << *from << ") to (" << *to << ")\n";

llvm::errs() << "Terminator: " << *Ins << "\n";

}

/// Zhiyuan: Bug Fix 04/23/2015: in a "while condition" basic block, all the instructions

/// before the br inst including the branch inst control depend on the br inst.

for (llvm::BasicBlock::iterator ii = from->begin(), ie = from->end(); ii != ie; ++ii) {

if(GraphNode *iwFrom = F_Graph->findInstNode(ii))

{

iwFrom->connect(iw,eType);

//CDG->addDependency(iwFrom, iw, type);

}

}

} else {

if (llvm::DebugFlag) {

llvm::errs() << "[i_cdg debug] dependence from (" << *from << ") to (" << *to << ")\n";

llvm::errs() << "Terminator: " << *Ins << "\n";

}

for (llvm::BasicBlock::iterator ii = to->begin(), ie = to->end(); ii != ie; ++ii) {

if(GraphNode *iwTo = F_Graph->findInstNode(ii))

{

iw->connect(iwTo,eType);

}

}

}

}

{

for (llvm::Function::iterator bi = F->begin(), be = F->end(); bi != be; ++bi)

{

llvm::BasicBlock &BB = *bi;

for (llvm::BasicBlock::iterator ii = BB.begin(), ie = BB.end(); ii != ie; ++ii)

{

if(isa<CallInst>(&*ii)) // handle the call inst.

{

CallInst *CI = dyn_cast<CallInst>(&*ii);

CallSite cs(&*ii);