1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
//=- lib/Analysis/IPA/CallTargets.cpp - Resolve Call Targets --*- C++ -*-=====//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This pass uses DSA to map targets of all calls, and reports on if it
// thinks it knows all targets of a given call.
//
// Loop over all callsites, and lookup the DSNode for that site. Pull the
// Functions from the node as callees.
// This is essentially a utility pass to simplify later passes that only depend
// on call sites and callees to operate (such as a devirtualizer).
//
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/DataStructure/CallTargets.h"
#include "llvm/Module.h"
#include "llvm/Instructions.h"
#include "llvm/Analysis/DataStructure/DataStructure.h"
#include "llvm/Analysis/DataStructure/DSGraph.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Support/Streams.h"
#include "llvm/Constants.h"
#include <ostream>
using namespace llvm;
namespace {
Statistic DirCall("calltarget", "Number of direct calls");
Statistic IndCall("calltarget", "Number of indirect calls");
Statistic CompleteInd("calltarget", "Number of complete indirect calls");
Statistic CompleteEmpty("calltarget", "Number of complete empty calls");
RegisterPass<CallTargetFinder> X("calltarget","Find Call Targets (uses DSA)");
}
void CallTargetFinder::findIndTargets(Module &M)
{
TDDataStructures* T = &getAnalysis<TDDataStructures>();
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
if (!I->isExternal())
for (Function::iterator F = I->begin(), FE = I->end(); F != FE; ++F)
for (BasicBlock::iterator B = F->begin(), BE = F->end(); B != BE; ++B)
if (isa<CallInst>(B) || isa<InvokeInst>(B)) {
CallSite cs = CallSite::get(B);
AllSites.push_back(cs);
if (!cs.getCalledFunction()) {
IndCall++;
DSNode* N = T->getDSGraph(*cs.getCaller())
.getNodeForValue(cs.getCalledValue()).getNode();
N->addFullFunctionList(IndMap[cs]);
if (N->isComplete() && IndMap[cs].size()) {
CompleteSites.insert(cs);
++CompleteInd;
}
if (N->isComplete() && !IndMap[cs].size()) {
++CompleteEmpty;
cerr << "Call site empty: '"
<< cs.getInstruction()->getName()
<< "' In '"
<< cs.getInstruction()->getParent()->getParent()->getName()
<< "'\n";
}
} else {
++DirCall;
IndMap[cs].push_back(cs.getCalledFunction());
CompleteSites.insert(cs);
}
}
}
void CallTargetFinder::print(std::ostream &O, const Module *M) const
{
return;
O << "[* = incomplete] CS: func list\n";
for (std::map<CallSite, std::vector<Function*> >::const_iterator ii =
IndMap.begin(),
ee = IndMap.end(); ii != ee; ++ii) {
if (!ii->first.getCalledFunction()) { //only print indirect
if (!isComplete(ii->first)) {
O << "* ";
CallSite cs = ii->first;
cs.getInstruction()->dump();
O << cs.getInstruction()->getParent()->getParent()->getName() << " "
<< cs.getInstruction()->getName() << " ";
}
O << ii->first.getInstruction() << ":";
for (std::vector<Function*>::const_iterator i = ii->second.begin(),
e = ii->second.end(); i != e; ++i) {
O << " " << (*i)->getName();
}
O << "\n";
}
}
}
bool CallTargetFinder::runOnModule(Module &M) {
findIndTargets(M);
return false;
}
void CallTargetFinder::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
AU.addRequired<TDDataStructures>();
}
std::vector<Function*>::iterator CallTargetFinder::begin(CallSite cs) {
return IndMap[cs].begin();
}
std::vector<Function*>::iterator CallTargetFinder::end(CallSite cs) {
return IndMap[cs].end();
}
bool CallTargetFinder::isComplete(CallSite cs) const {
return CompleteSites.find(cs) != CompleteSites.end();
}
std::list<CallSite>::iterator CallTargetFinder::cs_begin() {
return AllSites.begin();
}
std::list<CallSite>::iterator CallTargetFinder::cs_end() {
return AllSites.end();
}
|
