1 //===- DataStructure.h - Build data structure graphs -------------*- C++ -*--=//
3 // Implement the LLVM data structure analysis library.
5 //===----------------------------------------------------------------------===//
7 #ifndef LLVM_ANALYSIS_DATA_STRUCTURE_H
8 #define LLVM_ANALYSIS_DATA_STRUCTURE_H
10 #include "llvm/Pass.h"
13 // Hack around broken gdb! stack traces from system assert don't work, but do
17 do { if (!(x)) { std::cerr << "assertion failure!: " #x "\n"; \
18 int *P = 0; *P = 17; }} while (0)
22 class DSNode; // Each node in the graph
23 class DSGraph; // A graph for a function
24 class DSNodeIterator; // Data structure graph traversal iterator
25 class LocalDataStructures; // A collection of local graphs for a program
26 class BUDataStructures; // A collection of bu graphs for a program
27 class TDDataStructures; // A collection of td graphs for a program
29 //===----------------------------------------------------------------------===//
30 // DSNodeHandle - Implement a "handle" to a data structure node that takes care
31 // of all of the add/un'refing of the node to prevent the backpointers in the
32 // graph from getting out of date.
37 // Allow construction, destruction, and assignment...
38 DSNodeHandle(DSNode *n = 0) : N(0) { operator=(n); }
39 DSNodeHandle(const DSNodeHandle &H) : N(0) { operator=(H.N); }
40 ~DSNodeHandle() { operator=(0); }
41 DSNodeHandle &operator=(const DSNodeHandle &H) {operator=(H.N); return *this;}
43 // Assignment of DSNode*, implement all of the add/un'refing (defined later)
44 inline DSNodeHandle &operator=(DSNode *n);
46 // Allow automatic, implicit, conversion to DSNode*
47 operator DSNode*() { return N; }
48 operator const DSNode*() const { return N; }
49 operator bool() const { return N != 0; }
50 operator bool() { return N != 0; }
52 bool operator<(const DSNodeHandle &H) const { // Allow sorting
55 bool operator==(const DSNodeHandle &H) const { return N == H.N; }
56 bool operator!=(const DSNodeHandle &H) const { return N != H.N; }
57 bool operator==(const DSNode *Node) const { return N == Node; }
58 bool operator!=(const DSNode *Node) const { return N != Node; }
60 // Allow explicit conversion to DSNode...
61 DSNode *get() { return N; }
62 const DSNode *get() const { return N; }
64 // Allow this to be treated like a pointer...
65 DSNode *operator->() { return N; }
66 const DSNode *operator->() const { return N; }
70 //===----------------------------------------------------------------------===//
71 // DSNode - Data structure node class
73 // This class keeps track of a node's type, and the fields in the data
79 std::vector<DSNodeHandle> Links;
80 std::vector<DSNodeHandle*> Referrers;
82 // Globals - The list of global values that are merged into this node.
83 std::vector<GlobalValue*> Globals;
85 void operator=(const DSNode &); // DO NOT IMPLEMENT
88 ShadowNode = 0 << 0, // Nothing is known about this node...
89 ScalarNode = 1 << 0, // Scalar of the current function contains this value
90 AllocaNode = 1 << 1, // This node was allocated with alloca
91 NewNode = 1 << 2, // This node was allocated with malloc
92 GlobalNode = 1 << 3, // This node was allocated by a global var decl
93 SubElement = 1 << 4, // This node is a part of some other node
94 CastNode = 1 << 5, // This node is accessed in unsafe ways
95 Incomplete = 1 << 6, // This node may not be complete
98 // NodeType - A union of the above bits. "Shadow" nodes do not add any flags
99 // to the nodes in the data structure graph, so it is possible to have nodes
100 // with a value of 0 for their NodeType. Scalar and Alloca markers go away
101 // when function graphs are inlined.
103 unsigned char NodeType;
105 DSNode(enum NodeTy NT, const Type *T);
106 DSNode(const DSNode &);
110 dropAllReferences(); // Only needed to satisfy assertion checks...
112 assert(Referrers.empty() && "Referrers to dead node exist!");
115 // Iterator for graph interface...
116 typedef DSNodeIterator iterator;
117 inline iterator begin(); // Defined in DataStructureGraph.h
118 inline iterator end();
121 const Type *getType() const { return Ty; }
123 unsigned getNumLinks() const { return Links.size(); }
124 DSNode *getLink(unsigned i) {
125 assert(i < getNumLinks() && "Field links access out of range...");
128 const DSNode *getLink(unsigned i) const {
129 assert(i < getNumLinks() && "Field links access out of range...");
133 void setLink(unsigned i, DSNode *N) {
134 assert(i < getNumLinks() && "Field links access out of range...");
138 // addGlobal - Add an entry for a global value to the Globals list. This also
139 // marks the node with the 'G' flag if it does not already have it.
141 void addGlobal(GlobalValue *GV);
142 const std::vector<GlobalValue*> &getGlobals() const { return Globals; }
143 std::vector<GlobalValue*> &getGlobals() { return Globals; }
145 // addEdgeTo - Add an edge from the current node to the specified node. This
146 // can cause merging of nodes in the graph.
148 void addEdgeTo(unsigned LinkNo, DSNode *N);
149 void addEdgeTo(DSNode *N) {
150 assert(getNumLinks() == 1 && "Must specify a field number to add edge if "
151 " more than one field exists!");
155 // mergeWith - Merge this node into the specified node, moving all links to
156 // and from the argument node into the current node. The specified node may
157 // be a null pointer (in which case, nothing happens).
159 void mergeWith(DSNode *N);
161 // addReferrer - Keep the referrer set up to date...
162 void addReferrer(DSNodeHandle *H) { Referrers.push_back(H); }
163 void removeReferrer(DSNodeHandle *H);
164 const std::vector<DSNodeHandle*> &getReferrers() const { return Referrers; }
166 void print(std::ostream &O, const DSGraph *G) const;
169 std::string getCaption(const DSGraph *G) const;
171 void dropAllReferences() {
177 inline DSNodeHandle &DSNodeHandle::operator=(DSNode *n) {
178 if (N) N->removeReferrer(this);
180 if (N) N->addReferrer(this);
185 // DSGraph - The graph that represents a function.
189 std::vector<DSNode*> Nodes;
190 DSNodeHandle RetNode; // Node that gets returned...
191 std::map<Value*, DSNodeHandle> ValueMap;
193 // FunctionCalls - This vector maintains a single entry for each call
194 // instruction in the current graph. Each call entry contains DSNodeHandles
195 // that refer to the arguments that are passed into the function call. The
196 // first entry in the vector is the scalar that holds the return value for the
197 // call, the second is the function scalar being invoked, and the rest are
198 // pointer arguments to the function.
200 // OrigFunctionCalls - This vector retains a copy of the original function
201 // calls of the current graph. This is needed to support top-down inlining
202 // after bottom-up inlining is complete, since the latter deletes call nodes.
204 std::vector<std::vector<DSNodeHandle> > FunctionCalls;
205 std::vector<std::vector<DSNodeHandle> > OrigFunctionCalls;
207 // PendingCallers - This vector records all unresolved callers of the
208 // current function, i.e., ones whose graphs have not been inlined into
209 // the current graph. As long as there are unresolved callers, the nodes
210 // for formal arguments in the current graph cannot be eliminated, and
211 // nodes in the graph reachable from the formal argument nodes or
212 // global variable nodes must be considered incomplete.
213 std::vector<Function*> PendingCallers;
216 // Define the interface only accessable to DataStructure
217 friend class LocalDataStructures;
218 friend class BUDataStructures;
219 friend class TDDataStructures;
220 DSGraph(Function &F); // Compute the local DSGraph
221 DSGraph(const DSGraph &DSG); // Copy ctor
224 // clone all the call nodes and save the copies in OrigFunctionCalls
225 void saveOrigFunctionCalls() {
226 assert(OrigFunctionCalls.size() == 0 && "Do this only once!");
227 OrigFunctionCalls.reserve(FunctionCalls.size());
228 for (unsigned i = 0, ei = FunctionCalls.size(); i != ei; ++i) {
229 OrigFunctionCalls.push_back(std::vector<DSNodeHandle>());
230 OrigFunctionCalls[i].reserve(FunctionCalls[i].size());
231 for (unsigned j = 0, ej = FunctionCalls[i].size(); j != ej; ++j)
232 OrigFunctionCalls[i].push_back(FunctionCalls[i][j]);
236 // get the saved copies of the original function call nodes
237 std::vector<std::vector<DSNodeHandle> >& getOrigFunctionCalls() {
238 return OrigFunctionCalls;
241 void operator=(const DSGraph &); // DO NOT IMPLEMENT
244 Function &getFunction() const { return Func; }
246 // getValueMap - Get a map that describes what the nodes the scalars in this
247 // function point to...
249 std::map<Value*, DSNodeHandle> &getValueMap() { return ValueMap; }
250 const std::map<Value*, DSNodeHandle> &getValueMap() const { return ValueMap;}
252 std::vector<std::vector<DSNodeHandle> > &getFunctionCalls() {
253 return FunctionCalls;
256 const DSNode *getRetNode() const { return RetNode; }
258 unsigned getGraphSize() const {
262 void print(std::ostream &O) const;
265 // maskNodeTypes - Apply a mask to all of the node types in the graph. This
266 // is useful for clearing out markers like Scalar or Incomplete.
268 void maskNodeTypes(unsigned char Mask);
269 void maskIncompleteMarkers() { maskNodeTypes(~DSNode::Incomplete); }
271 // markIncompleteNodes - Traverse the graph, identifying nodes that may be
272 // modified by other functions that have not been resolved yet. This marks
273 // nodes that are reachable through three sources of "unknownness":
274 // Global Variables, Function Calls, and Incoming Arguments
276 // For any node that may have unknown components (because something outside
277 // the scope of current analysis may have modified it), the 'Incomplete' flag
278 // is added to the NodeType.
280 void markIncompleteNodes();
282 // removeDeadNodes - After the graph has been constructed, this method removes
283 // all unreachable nodes that are created because they got merged with other
284 // nodes in the graph.
286 void removeDeadNodes();
288 // AddCaller - add a known caller node into the graph and mark it pending.
289 // getCallers - get a vector of the functions that call this one
290 // getCallersPending - get a matching vector of bools indicating if each
291 // caller's DSGraph has been resolved into this one.
293 void addCaller(Function& caller) {
294 PendingCallers.push_back(&caller);
296 std::vector<Function*>& getPendingCallers() {
297 return PendingCallers;
300 // cloneInto - Clone the specified DSGraph into the current graph, returning
301 // the Return node of the graph. The translated ValueMap for the old function
302 // is filled into the OldValMap member. If StripLocals is set to true, Scalar
303 // and Alloca markers are removed from the graph, as the graph is being cloned
304 // into a calling function's graph.
306 DSNode *cloneInto(const DSGraph &G, std::map<Value*, DSNodeHandle> &OldValMap,
307 std::map<const DSNode*, DSNode*>& OldNodeMap,
308 bool StripLocals = true);
310 bool isNodeDead(DSNode *N);
315 // LocalDataStructures - The analysis that computes the local data structure
316 // graphs for all of the functions in the program.
318 // FIXME: This should be a Function pass that can be USED by a Pass, and would
319 // be automatically preserved. Until we can do that, this is a Pass.
321 class LocalDataStructures : public Pass {
322 // DSInfo, one graph for each function
323 std::map<Function*, DSGraph*> DSInfo;
325 static AnalysisID ID; // DataStructure Analysis ID
327 LocalDataStructures(AnalysisID id) { assert(id == ID); }
328 ~LocalDataStructures() { releaseMemory(); }
330 virtual const char *getPassName() const {
331 return "Local Data Structure Analysis";
334 virtual bool run(Module &M);
336 // getDSGraph - Return the data structure graph for the specified function.
337 DSGraph &getDSGraph(Function &F) const {
338 std::map<Function*, DSGraph*>::const_iterator I = DSInfo.find(&F);
339 assert(I != DSInfo.end() && "Function not in module!");
343 // print - Print out the analysis results...
344 void print(std::ostream &O, Module *M) const;
346 // If the pass pipeline is done with this pass, we can release our memory...
347 virtual void releaseMemory();
349 // getAnalysisUsage - This obviously provides a data structure graph.
350 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
351 AU.setPreservesAll();
357 // BUDataStructures - The analysis that computes the interprocedurally closed
358 // data structure graphs for all of the functions in the program. This pass
359 // only performs a "Bottom Up" propogation (hence the name).
361 class BUDataStructures : public Pass {
362 // DSInfo, one graph for each function
363 std::map<Function*, DSGraph*> DSInfo;
365 static AnalysisID ID; // BUDataStructure Analysis ID
367 BUDataStructures(AnalysisID id) { assert(id == ID); }
368 ~BUDataStructures() { releaseMemory(); }
370 virtual const char *getPassName() const {
371 return "Bottom-Up Data Structure Analysis Closure";
374 virtual bool run(Module &M);
376 // getDSGraph - Return the data structure graph for the specified function.
377 DSGraph &getDSGraph(Function &F) const {
378 std::map<Function*, DSGraph*>::const_iterator I = DSInfo.find(&F);
379 assert(I != DSInfo.end() && "Function not in module!");
383 // print - Print out the analysis results...
384 void print(std::ostream &O, Module *M) const;
386 // If the pass pipeline is done with this pass, we can release our memory...
387 virtual void releaseMemory();
389 // getAnalysisUsage - This obviously provides a data structure graph.
390 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
391 AU.setPreservesAll();
393 AU.addRequired(LocalDataStructures::ID);
396 DSGraph &calculateGraph(Function &F);
400 // TDDataStructures - Analysis that computes new data structure graphs
401 // for each function using the closed graphs for the callers computed
402 // by the bottom-up pass.
404 class TDDataStructures : public Pass {
405 // DSInfo, one graph for each function
406 std::map<Function*, DSGraph*> DSInfo;
408 static AnalysisID ID; // TDDataStructure Analysis ID
410 TDDataStructures(AnalysisID id) { assert(id == ID); }
411 ~TDDataStructures() { releaseMemory(); }
413 virtual const char *getPassName() const {
414 return "Top-downData Structure Analysis Closure";
417 virtual bool run(Module &M);
419 // getDSGraph - Return the data structure graph for the specified function.
420 DSGraph &getDSGraph(Function &F) const {
421 std::map<Function*, DSGraph*>::const_iterator I = DSInfo.find(&F);
422 assert(I != DSInfo.end() && "Function not in module!");
426 // print - Print out the analysis results...
427 void print(std::ostream &O, Module *M) const;
429 // If the pass pipeline is done with this pass, we can release our memory...
430 virtual void releaseMemory();
432 // getAnalysisUsage - This obviously provides a data structure graph.
433 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
434 AU.setPreservesAll();
436 AU.addRequired(BUDataStructures::ID);
439 DSGraph &calculateGraph(Function &F);
440 void pushGraphIntoCallee(DSGraph &callerGraph, DSGraph &calleeGraph,
441 std::map<Value*, DSNodeHandle> &OldValMap,
442 std::map<const DSNode*, DSNode*> &OldNodeMap);