RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 19:23:23 +01:00
Code Issues Projects Releases Wiki Activity

* Remove a lot of obsolete #if 0'd code

Browse Source 
* Add a simple getNodeForValue method to access the ValueMap.

llvm-svn: 4211
This commit is contained in:
Chris Lattner 2002-10-17 04:22:16 +00:00
parent 80332e579c
commit bb28060fb4
1 changed files with 5 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
include/llvm/Analysis/DSGraph.h
View File

@ -347,37 +347,6 @@ class DSGraph {
//
std::vector<std::vector<DSNodeHandle> > FunctionCalls;
#if 0
// OrigFunctionCalls - This vector retains a copy of the original function
// calls of the current graph. This is needed to support top-down inlining
// after bottom-up inlining is complete, since the latter deletes call nodes.
//
std::vector<std::vector<DSNodeHandle> > OrigFunctionCalls;
// PendingCallers - This vector records all unresolved callers of the
// current function, i.e., ones whose graphs have not been inlined into
// the current graph. As long as there are unresolved callers, the nodes
// for formal arguments in the current graph cannot be eliminated, and
// nodes in the graph reachable from the formal argument nodes or
// global variable nodes must be considered incomplete.
std::set<Function*> PendingCallers;
#endif
protected:
#if 0
// clone all the call nodes and save the copies in OrigFunctionCalls
void saveOrigFunctionCalls() {
assert(OrigFunctionCalls.size() == 0 && "Do this only once!");
OrigFunctionCalls = FunctionCalls;
}
// get the saved copies of the original function call nodes
std::vector<std::vector<DSNodeHandle> > &getOrigFunctionCalls() {
return OrigFunctionCalls;
}
#endif
void operator=(const DSGraph &); // DO NOT IMPLEMENT
public:
DSGraph() : Func(0) {} // Create a new, empty, DSGraph.
@ -410,6 +379,11 @@ public:
return FunctionCalls;
}
/// getNodeForValue - Given a value that is used or defined in the body of the
/// current function, return the DSNode that it points to.
///
DSNodeHandle &getNodeForValue(Value *V) { return ValueMap[V]; }
const DSNodeHandle &getRetNode() const { return RetNode; }
DSNodeHandle &getRetNode() { return RetNode; }
@ -452,20 +426,6 @@ public:
//
void removeDeadNodes(bool KeepAllGlobals = false, bool KeepCalls = true);
#if 0
// AddCaller - add a known caller node into the graph and mark it pending.
// getCallers - get a vector of the functions that call this one
// getCallersPending - get a matching vector of bools indicating if each
// caller's DSGraph has been resolved into this one.
//
void addCaller(Function &caller) {
PendingCallers.insert(&caller);
}
std::set<Function*> &getPendingCallers() {
return PendingCallers;
}
#endif
// cloneInto - Clone the specified DSGraph into the current graph, returning
// the Return node of the graph. The translated ValueMap for the old function
// is filled into the OldValMap member.