Switch from using CallInst's to represent call sites to using the LLVM
CallSite class. Now we can represent function calls by invoke instructions
too!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8629 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Analysis/DataStructure/BottomUpClosure.cpp b/lib/Analysis/DataStructure/BottomUpClosure.cpp
index dd141f2..f5d435f 100644
--- a/lib/Analysis/DataStructure/BottomUpClosure.cpp
+++ b/lib/Analysis/DataStructure/BottomUpClosure.cpp
@@ -253,7 +253,8 @@
Graph.mergeInGraph(CS, *Callee, Graph, 0);
} else {
- ActualCallees.insert(std::make_pair(&CS.getCallInst(), Callee));
+ ActualCallees.insert(std::make_pair(CS.getCallSite().getInstruction(),
+ Callee));
// Get the data structure graph for the called function.
//
diff --git a/lib/Analysis/DataStructure/DataStructure.cpp b/lib/Analysis/DataStructure/DataStructure.cpp
index 24bed38..0a6fa57 100644
--- a/lib/Analysis/DataStructure/DataStructure.cpp
+++ b/lib/Analysis/DataStructure/DataStructure.cpp
@@ -709,7 +709,7 @@
// Define here to avoid including iOther.h and BasicBlock.h in DSGraph.h
Function &DSCallSite::getCaller() const {
- return *Inst->getParent()->getParent();
+ return *Site.getInstruction()->getParent()->getParent();
}
@@ -1044,7 +1044,7 @@
if (isPointerType(I->getType()))
Args.push_back(getScalarMap().find(I)->second);
- return DSCallSite(*(CallInst*)0, getReturnNodeFor(F), &F, Args);
+ return DSCallSite(CallSite(), getReturnNodeFor(F), &F, Args);
}
diff --git a/lib/Analysis/DataStructure/DataStructureStats.cpp b/lib/Analysis/DataStructure/DataStructureStats.cpp
index 674f689..ffd560b 100644
--- a/lib/Analysis/DataStructure/DataStructureStats.cpp
+++ b/lib/Analysis/DataStructure/DataStructureStats.cpp
@@ -68,7 +68,7 @@
const std::vector<DSCallSite> &callSites = TDGraph->getFunctionCalls();
for (unsigned i = 0, N = callSites.size(); i != N; ++i)
- if (isIndirectCallee(callSites[i].getCallInst().getCalledValue())) {
+ if (isIndirectCallee(callSites[i].getCallSite().getCalledValue())) {
// This is an indirect function call
const std::vector<GlobalValue*> &Callees =
callSites[i].getCalleeNode()->getGlobals();
@@ -76,8 +76,9 @@
totalNumCallees += Callees.size();
++numIndirectCalls;
} else
- std::cerr << "WARNING: No callee in Function " << F.getName()
- << "at call:\n" << callSites[i].getCallInst();
+ std::cerr << "WARNING: No callee in Function '" << F.getName()
+ << "' at call: \n"
+ << *callSites[i].getCallSite().getInstruction();
}
TotalNumCallees += totalNumCallees;
diff --git a/lib/Analysis/DataStructure/IPModRef.cpp b/lib/Analysis/DataStructure/IPModRef.cpp
index a90b5c6..e7366a0 100644
--- a/lib/Analysis/DataStructure/IPModRef.cpp
+++ b/lib/Analysis/DataStructure/IPModRef.cpp
@@ -61,7 +61,7 @@
FunctionModRefInfo::~FunctionModRefInfo()
{
- for(std::map<const CallInst*, ModRefInfo*>::iterator
+ for(std::map<const Instruction*, ModRefInfo*>::iterator
I=callSiteModRefInfo.begin(), E=callSiteModRefInfo.end(); I != E; ++I)
delete(I->second);
@@ -98,7 +98,7 @@
// The call sites are recorded in the TD graph.
const std::vector<DSCallSite>& callSites = funcTDGraph->getFunctionCalls();
for (unsigned i = 0, N = callSites.size(); i < N; ++i)
- computeModRef(callSites[i].getCallInst());
+ computeModRef(callSites[i].getCallSite());
}
@@ -117,25 +117,22 @@
// requested information (because the call site calls an external
// function or we cannot determine the complete set of functions invoked).
//
-DSGraph* FunctionModRefInfo::ResolveCallSiteModRefInfo(CallInst &CI,
+DSGraph* FunctionModRefInfo::ResolveCallSiteModRefInfo(CallSite CS,
hash_map<const DSNode*, DSNodeHandle> &NodeMap)
{
// Step #0: Quick check if we are going to fail anyway: avoid
// all the graph cloning and map copying in steps #1 and #2.
//
- if (const Function *F = CI.getCalledFunction())
- {
- if (F->isExternal())
- return 0; // We cannot compute Mod/Ref info for this callsite...
- }
- else
- {
- // Eventually, should check here if any callee is external.
- // For now we are not handling this case anyway.
- std::cerr << "IP Mod/Ref indirect call not implemented yet: "
- << "Being conservative\n";
+ if (const Function *F = CS.getCalledFunction()) {
+ if (F->isExternal())
return 0; // We cannot compute Mod/Ref info for this callsite...
- }
+ } else {
+ // Eventually, should check here if any callee is external.
+ // For now we are not handling this case anyway.
+ std::cerr << "IP Mod/Ref indirect call not implemented yet: "
+ << "Being conservative\n";
+ return 0; // We cannot compute Mod/Ref info for this callsite...
+ }
// Step #1: Clone the top-down graph...
DSGraph *Result = new DSGraph(*funcTDGraph, NodeMap);
@@ -144,7 +141,7 @@
Result->maskNodeTypes(~(DSNode::Modified | DSNode::Read));
// Step #3: clone the bottom up graphs for the callees into the caller graph
- if (Function *F = CI.getCalledFunction())
+ if (Function *F = CS.getCalledFunction())
{
assert(!F->isExternal());
@@ -152,17 +149,18 @@
// If the call returns a value, make sure to merge the nodes...
DSNodeHandle RetVal;
- if (DS::isPointerType(CI.getType()))
- RetVal = Result->getNodeForValue(&CI);
+ if (DS::isPointerType(CS.getInstruction()->getType()))
+ RetVal = Result->getNodeForValue(CS.getInstruction());
// Populate the arguments list...
std::vector<DSNodeHandle> Args;
- for (unsigned i = 1, e = CI.getNumOperands(); i != e; ++i)
- if (DS::isPointerType(CI.getOperand(i)->getType()))
- Args.push_back(Result->getNodeForValue(CI.getOperand(i)));
+ for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
+ I != E; ++I)
+ if (DS::isPointerType((*I)->getType()))
+ Args.push_back(Result->getNodeForValue(*I));
// Build the call site...
- DSCallSite CS(CI, RetVal, F, Args);
+ DSCallSite CS(CS, RetVal, F, Args);
// Perform the merging now of the graph for the callee, which will
// come with mod/ref bits set...
@@ -187,16 +185,15 @@
// and then inlining the callee's BU graph into the caller's TD graph.
//
void
-FunctionModRefInfo::computeModRef(const CallInst& callInst)
+FunctionModRefInfo::computeModRef(CallSite CS)
{
// Allocate the mod/ref info for the call site. Bits automatically cleared.
ModRefInfo* callModRefInfo = new ModRefInfo(funcTDGraph->getGraphSize());
- callSiteModRefInfo[&callInst] = callModRefInfo;
+ callSiteModRefInfo[CS.getInstruction()] = callModRefInfo;
// Get a copy of the graph for the callee with the callee inlined
hash_map<const DSNode*, DSNodeHandle> NodeMap;
- DSGraph* csgp = ResolveCallSiteModRefInfo(const_cast<CallInst&>(callInst),
- NodeMap);
+ DSGraph* csgp = ResolveCallSiteModRefInfo(CS, NodeMap);
if (!csgp)
{ // Callee's side effects are unknown: mark all nodes Mod and Ref.
// Eventually this should only mark nodes visible to the callee, i.e.,
@@ -323,7 +320,7 @@
// Second: Print Globals and Locals modified at each call site in function
//
- for (std::map<const CallInst*, ModRefInfo*>::const_iterator
+ for (std::map<const Instruction *, ModRefInfo*>::const_iterator
CI = callSiteModRefInfo.begin(), CE = callSiteModRefInfo.end();
CI != CE; ++CI)
{
diff --git a/lib/Analysis/DataStructure/Local.cpp b/lib/Analysis/DataStructure/Local.cpp
index cd81aab..1b08283 100644
--- a/lib/Analysis/DataStructure/Local.cpp
+++ b/lib/Analysis/DataStructure/Local.cpp
@@ -7,14 +7,11 @@
#include "llvm/Analysis/DataStructure.h"
#include "llvm/Analysis/DSGraph.h"
-#include "llvm/iMemory.h"
-#include "llvm/iTerminators.h"
-#include "llvm/iPHINode.h"
-#include "llvm/iOther.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/GlobalVariable.h"
+#include "llvm/Instructions.h"
#include "llvm/Support/InstVisitor.h"
#include "llvm/Target/TargetData.h"
#include "Support/CommandLine.h"
@@ -96,11 +93,13 @@
void visitLoadInst(LoadInst &LI);
void visitStoreInst(StoreInst &SI);
void visitCallInst(CallInst &CI);
+ void visitInvokeInst(InvokeInst &II);
void visitSetCondInst(SetCondInst &SCI) {} // SetEQ & friends are ignored
void visitFreeInst(FreeInst &FI);
void visitCastInst(CastInst &CI);
void visitInstruction(Instruction &I);
+ void visitCallSite(CallSite CS);
private:
// Helper functions used to implement the visitation functions...
@@ -405,29 +404,38 @@
}
void GraphBuilder::visitCallInst(CallInst &CI) {
+ visitCallSite(&CI);
+}
+
+void GraphBuilder::visitInvokeInst(InvokeInst &II) {
+ visitCallSite(&II);
+}
+
+void GraphBuilder::visitCallSite(CallSite CS) {
// Set up the return value...
DSNodeHandle RetVal;
- if (isPointerType(CI.getType()))
- RetVal = getValueDest(CI);
+ Instruction *I = CS.getInstruction();
+ if (isPointerType(I->getType()))
+ RetVal = getValueDest(*I);
DSNode *Callee = 0;
- if (DisableDirectCallOpt || !isa<Function>(CI.getOperand(0)))
- Callee = getValueDest(*CI.getOperand(0)).getNode();
+ if (DisableDirectCallOpt || !isa<Function>(CS.getCalledValue()))
+ Callee = getValueDest(*CS.getCalledValue()).getNode();
std::vector<DSNodeHandle> Args;
- Args.reserve(CI.getNumOperands()-1);
+ Args.reserve(CS.arg_end()-CS.arg_begin());
// Calculate the arguments vector...
- for (unsigned i = 1, e = CI.getNumOperands(); i != e; ++i)
- if (isPointerType(CI.getOperand(i)->getType()))
- Args.push_back(getValueDest(*CI.getOperand(i)));
+ for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); I != E; ++I)
+ if (isPointerType((*I)->getType()))
+ Args.push_back(getValueDest(**I));
// Add a new function call entry...
if (Callee)
- FunctionCalls.push_back(DSCallSite(CI, RetVal, Callee, Args));
+ FunctionCalls.push_back(DSCallSite(CS, RetVal, Callee, Args));
else
- FunctionCalls.push_back(DSCallSite(CI, RetVal,
- cast<Function>(CI.getOperand(0)), Args));
+ FunctionCalls.push_back(DSCallSite(CS, RetVal, CS.getCalledFunction(),
+ Args));
}
void GraphBuilder::visitFreeInst(FreeInst &FI) {
diff --git a/lib/Analysis/DataStructure/TopDownClosure.cpp b/lib/Analysis/DataStructure/TopDownClosure.cpp
index 92a03ee..13535e3 100644
--- a/lib/Analysis/DataStructure/TopDownClosure.cpp
+++ b/lib/Analysis/DataStructure/TopDownClosure.cpp
@@ -96,9 +96,10 @@
const std::vector<DSCallSite> &FunctionCalls = G.getFunctionCalls();
for (unsigned i = 0, e = FunctionCalls.size(); i != e; ++i) {
+ Instruction *CallI = FunctionCalls[i].getCallSite().getInstruction();
std::pair<BUDataStructures::ActualCalleesTy::const_iterator,
BUDataStructures::ActualCalleesTy::const_iterator>
- IP = ActualCallees.equal_range(&FunctionCalls[i].getCallInst());
+ IP = ActualCallees.equal_range(CallI);
for (BUDataStructures::ActualCalleesTy::const_iterator I = IP.first;
I != IP.second; ++I)
@@ -191,10 +192,11 @@
// Clone and merge the reachable subgraph from the call into callee's graph.
//
for (unsigned i = 0, e = FunctionCalls.size(); i != e; ++i) {
+ Instruction *CallI = FunctionCalls[i].getCallSite().getInstruction();
// For each function in the invoked function list at this call site...
std::pair<BUDataStructures::ActualCalleesTy::const_iterator,
BUDataStructures::ActualCalleesTy::const_iterator>
- IP = ActualCallees.equal_range(&FunctionCalls[i].getCallInst());
+ IP = ActualCallees.equal_range(CallI);
// Multiple callees may have the same graph, so try to inline and merge
// only once for each <callSite,calleeGraph> pair, not once for each