From 11aec6cc7d2f1705d410df6ee25555f2d7101f30 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 1 Oct 2002 22:34:45 +0000 Subject: [PATCH] Check in DataStructure rewrite so far. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3998 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/DSGraphTraits.h | 4 + include/llvm/Analysis/DataStructure.h | 345 +----------------- .../Analysis/DataStructure/DSGraphTraits.h | 4 + .../Analysis/DataStructure/DataStructure.h | 345 +----------------- include/llvm/Analysis/DataStructureGraph.h | 4 + 5 files changed, 44 insertions(+), 658 deletions(-) diff --git a/include/llvm/Analysis/DSGraphTraits.h b/include/llvm/Analysis/DSGraphTraits.h index 4397f621c12..d82e2e5b1b2 100644 --- a/include/llvm/Analysis/DSGraphTraits.h +++ b/include/llvm/Analysis/DSGraphTraits.h @@ -13,6 +13,8 @@ #include "Support/GraphTraits.h" #include "Support/iterator" +#if 0 + class DSNodeIterator : public forward_iterator { friend class DSNode; DSNode * const Node; @@ -67,3 +69,5 @@ inline DSNode::iterator DSNode::begin() { return DSNodeIterator(this); } inline DSNode::iterator DSNode::end() { return DSNodeIterator(this, false); } #endif + +#endif diff --git a/include/llvm/Analysis/DataStructure.h b/include/llvm/Analysis/DataStructure.h index 667250e40fe..4551b16592a 100644 --- a/include/llvm/Analysis/DataStructure.h +++ b/include/llvm/Analysis/DataStructure.h @@ -1,4 +1,4 @@ -//===- DataStructure.h - Build data structure graphs -------------*- C++ -*--=// +//===- DataStructure.h - Build data structure graphs ------------*- C++ -*-===// // // Implement the LLVM data structure analysis library. // @@ -7,350 +7,35 @@ #ifndef LLVM_ANALYSIS_DATA_STRUCTURE_H #define LLVM_ANALYSIS_DATA_STRUCTURE_H +#include "llvm/Analysis/DSGraph.h" #include "llvm/Pass.h" +#if 0 #include "llvm/GlobalValue.h" #include "Support/HashExtras.h" #include "Support/hash_set" +#endif #include -#include class Type; class GlobalValue; -class DSNode; // Each node in the graph -class DSGraph; // A graph for a function +#if 0 class GlobalDSGraph; // A common graph for globals in a program -class DSNodeIterator; // Data structure graph traversal iterator +#endif class LocalDataStructures; // A collection of local graphs for a program class BUDataStructures; // A collection of bu graphs for a program class TDDataStructures; // A collection of td graphs for a program -//===----------------------------------------------------------------------===// -// DSNodeHandle - Implement a "handle" to a data structure node that takes care -// of all of the add/un'refing of the node to prevent the backpointers in the -// graph from getting out of date. -// -class DSNodeHandle { - DSNode *N; -public: - // Allow construction, destruction, and assignment... - DSNodeHandle(DSNode *n = 0) : N(0) { operator=(n); } - DSNodeHandle(const DSNodeHandle &H) : N(0) { operator=(H.N); } - ~DSNodeHandle() { operator=(0); } - DSNodeHandle &operator=(const DSNodeHandle &H) {operator=(H.N); return *this;} - // Assignment of DSNode*, implement all of the add/un'refing (defined later) - inline DSNodeHandle &operator=(DSNode *n); - - // Allow automatic, implicit, conversion to DSNode* - operator DSNode*() { return N; } - operator const DSNode*() const { return N; } - operator const DSNode*() { return N; } - operator bool() const { return N != 0; } - operator bool() { return N != 0; } - - bool operator<(const DSNodeHandle &H) const { // Allow sorting - return N < H.N; - } - bool operator==(const DSNodeHandle &H) const { return N == H.N; } - bool operator!=(const DSNodeHandle &H) const { return N != H.N; } - bool operator==(const DSNode *Node) const { return N == Node; } - bool operator!=(const DSNode *Node) const { return N != Node; } - bool operator==(DSNode *Node) const { return N == Node; } - bool operator!=(DSNode *Node) const { return N != Node; } - - // Avoid having comparisons to null cause errors... - bool operator==(int X) const { - assert(X == 0 && "Bad comparison!"); - return operator==((DSNode*)0); - } - bool operator!=(int X) const { return !operator==(X); } - - // Allow explicit conversion to DSNode... - DSNode *get() { return N; } - const DSNode *get() const { return N; } - - // Allow this to be treated like a pointer... - DSNode *operator->() { return N; } - const DSNode *operator->() const { return N; } -}; - - -//===----------------------------------------------------------------------===// -// DSNode - Data structure node class -// -// This class keeps track of a node's type, and the fields in the data -// structure. -// -// -class DSNode { - const Type *Ty; - std::vector Links; - std::vector Referrers; - - // Globals - The list of global values that are merged into this node. - std::vector Globals; - - void operator=(const DSNode &); // DO NOT IMPLEMENT -public: - enum NodeTy { - ShadowNode = 0, // Nothing is known about this node... - ScalarNode = 1 << 0, // Scalar of the current function contains this value - AllocaNode = 1 << 1, // This node was allocated with alloca - NewNode = 1 << 2, // This node was allocated with malloc - GlobalNode = 1 << 3, // This node was allocated by a global var decl - SubElement = 1 << 4, // This node is a part of some other node - CastNode = 1 << 5, // This node is accessed in unsafe ways - Incomplete = 1 << 6, // This node may not be complete - }; - - // NodeType - A union of the above bits. "Shadow" nodes do not add any flags - // to the nodes in the data structure graph, so it is possible to have nodes - // with a value of 0 for their NodeType. Scalar and Alloca markers go away - // when function graphs are inlined. +// FIXME: move this stuff to a private header +namespace DataStructureAnalysis { + // isPointerType - Return true if this first class type is big enough to hold + // a pointer. // - unsigned char NodeType; - - DSNode(enum NodeTy NT, const Type *T); - DSNode(const DSNode &); - - ~DSNode() { -#ifndef NDEBUG - dropAllReferences(); // Only needed to satisfy assertion checks... -#endif - assert(Referrers.empty() && "Referrers to dead node exist!"); - } - - // Iterator for graph interface... - typedef DSNodeIterator iterator; - inline iterator begin(); // Defined in DataStructureGraph.h - inline iterator end(); - - // Accessors - const Type *getType() const { return Ty; } - - unsigned getNumLinks() const { return Links.size(); } - DSNode *getLink(unsigned i) { - assert(i < getNumLinks() && "Field links access out of range..."); - return Links[i]; - } - const DSNode *getLink(unsigned i) const { - assert(i < getNumLinks() && "Field links access out of range..."); - return Links[i]; - } - - void setLink(unsigned i, DSNode *N) { - assert(i < getNumLinks() && "Field links access out of range..."); - Links[i] = N; - } - - // addGlobal - Add an entry for a global value to the Globals list. This also - // marks the node with the 'G' flag if it does not already have it. - // - void addGlobal(GlobalValue *GV); - const std::vector &getGlobals() const { return Globals; } - std::vector &getGlobals() { return Globals; } - - // addEdgeTo - Add an edge from the current node to the specified node. This - // can cause merging of nodes in the graph. - // - void addEdgeTo(unsigned LinkNo, DSNode *N); - void addEdgeTo(DSNode *N) { - assert(getNumLinks() == 1 && "Must specify a field number to add edge if " - " more than one field exists!"); - addEdgeTo(0, N); - } - - // mergeWith - Merge this node into the specified node, moving all links to - // and from the argument node into the current node. The specified node may - // be a null pointer (in which case, nothing happens). - // - void mergeWith(DSNode *N); - - // addReferrer - Keep the referrer set up to date... - void addReferrer(DSNodeHandle *H) { Referrers.push_back(H); } - void removeReferrer(DSNodeHandle *H); - const std::vector &getReferrers() const { return Referrers; } - - void print(std::ostream &O, const DSGraph *G) const; - void dump() const; - - std::string getCaption(const DSGraph *G) const; - - void dropAllReferences() { - Links.clear(); - } -}; - - -inline DSNodeHandle &DSNodeHandle::operator=(DSNode *n) { - if (N) N->removeReferrer(this); - N = n; - if (N) N->addReferrer(this); - return *this; + bool isPointerType(const Type *Ty); } -// DSGraph - The graph that represents a function. -// -class DSGraph { - friend class GlobalDSGraph; -protected: - Function &Func; - std::vector Nodes; - DSNodeHandle RetNode; // Node that gets returned... - std::map ValueMap; - - // GlobalsGraph -- Reference to the common graph of globally visible objects. - // This includes GlobalValues, New nodes, Cast nodes, and Calls. - // - GlobalDSGraph* GlobalsGraph; - - // FunctionCalls - This vector maintains a single entry for each call - // instruction in the current graph. Each call entry contains DSNodeHandles - // that refer to the arguments that are passed into the function call. The - // first entry in the vector is the scalar that holds the return value for the - // call, the second is the function scalar being invoked, and the rest are - // pointer arguments to the function. - // - std::vector > FunctionCalls; - - // 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 > 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 PendingCallers; - -protected: - // Define the interface only accessable to DataStructure - friend class LocalDataStructures; - friend class BUDataStructures; - friend class TDDataStructures; - DSGraph(Function &F, GlobalDSGraph* GlobalsG); // Compute the local DSGraph - DSGraph(const DSGraph &DSG); // Copy ctor - virtual ~DSGraph(); - - // 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 > &getOrigFunctionCalls() { - return OrigFunctionCalls; - } - - void operator=(const DSGraph &); // DO NOT IMPLEMENT -public: - - Function &getFunction() const { return Func; } - - // getNodes - Get a vector of all the nodes in the graph - // - const std::vector& getNodes() const { return Nodes; } - std::vector& getNodes() { return Nodes; } - - // getValueMap - Get a map that describes what the nodes the scalars in this - // function point to... - // - std::map &getValueMap() { return ValueMap; } - const std::map &getValueMap() const { return ValueMap;} - - std::vector > &getFunctionCalls() { - return FunctionCalls; - } - const std::vector > &getFunctionCalls() const { - return FunctionCalls; - } - - const DSNode *getRetNode() const { return RetNode; } - DSNode *getRetNode() { return RetNode; } - - unsigned getGraphSize() const { - return Nodes.size(); - } - - void print(std::ostream &O) const; - void dump() const; - - // maskNodeTypes - Apply a mask to all of the node types in the graph. This - // is useful for clearing out markers like Scalar or Incomplete. - // - void maskNodeTypes(unsigned char Mask); - void maskIncompleteMarkers() { maskNodeTypes(~DSNode::Incomplete); } - - // markIncompleteNodes - Traverse the graph, identifying nodes that may be - // modified by other functions that have not been resolved yet. This marks - // nodes that are reachable through three sources of "unknownness": - // Global Variables, Function Calls, and Incoming Arguments - // - // For any node that may have unknown components (because something outside - // the scope of current analysis may have modified it), the 'Incomplete' flag - // is added to the NodeType. - // - void markIncompleteNodes(bool markFormalArgs = true); - - // removeTriviallyDeadNodes - After the graph has been constructed, this - // method removes all unreachable nodes that are created because they got - // merged with other nodes in the graph. - // - void removeTriviallyDeadNodes(bool KeepAllGlobals = false); - - // removeDeadNodes - Use a more powerful reachability analysis to eliminate - // subgraphs that are unreachable. This often occurs because the data - // structure doesn't "escape" into it's caller, and thus should be eliminated - // from the caller's graph entirely. This is only appropriate to use when - // inlining graphs. - // - void removeDeadNodes(bool KeepAllGlobals = false, bool KeepCalls = true); - - // 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& getPendingCallers() { - return PendingCallers; - } - - // 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. - // If StripScalars (StripAllocas) is set to true, Scalar (Alloca) markers - // are removed from the graph as the graph is being cloned. - // If CopyCallers is set to true, the PendingCallers list is copied. - // If CopyOrigCalls is set to true, the OrigFunctionCalls list is copied. - // - DSNode *cloneInto(const DSGraph &G, std::map &OldValMap, - std::map& OldNodeMap, - bool StripScalars = false, bool StripAllocas = false, - bool CopyCallers = true, bool CopyOrigCalls = true); - - // cloneGlobalInto - Clone the given global node (or the node for the given - // GlobalValue) from the GlobalsGraph and all its target links (recursively). - // - DSNode* cloneGlobalInto(const DSNode* GNode); - DSNode* cloneGlobalInto(GlobalValue* GV) { - assert(!GV || (((DSGraph*) GlobalsGraph)->ValueMap[GV] != 0)); - return GV? cloneGlobalInto(((DSGraph*) GlobalsGraph)->ValueMap[GV]) : 0; - } - -private: - bool isNodeDead(DSNode *N); -}; - - +#if 0 // GlobalDSGraph - A common graph for all the globals and their outgoing links // to externally visible nodes. This includes GlobalValues, New nodes, // Cast nodes, and Calls. This graph can only be used by one of the @@ -376,7 +61,7 @@ public: void cloneGlobals(DSGraph& Graph, bool CloneCalls = false); void cloneCalls (DSGraph& Graph); }; - +#endif // LocalDataStructures - The analysis that computes the local data structure // graphs for all of the functions in the program. @@ -411,7 +96,7 @@ public: } }; - +#if 0 // BUDataStructures - The analysis that computes the interprocedurally closed // data structure graphs for all of the functions in the program. This pass // only performs a "Bottom Up" propogation (hence the name). @@ -484,3 +169,5 @@ private: std::map &OldNodeMap); }; #endif + +#endif diff --git a/include/llvm/Analysis/DataStructure/DSGraphTraits.h b/include/llvm/Analysis/DataStructure/DSGraphTraits.h index 4397f621c12..d82e2e5b1b2 100644 --- a/include/llvm/Analysis/DataStructure/DSGraphTraits.h +++ b/include/llvm/Analysis/DataStructure/DSGraphTraits.h @@ -13,6 +13,8 @@ #include "Support/GraphTraits.h" #include "Support/iterator" +#if 0 + class DSNodeIterator : public forward_iterator { friend class DSNode; DSNode * const Node; @@ -67,3 +69,5 @@ inline DSNode::iterator DSNode::begin() { return DSNodeIterator(this); } inline DSNode::iterator DSNode::end() { return DSNodeIterator(this, false); } #endif + +#endif diff --git a/include/llvm/Analysis/DataStructure/DataStructure.h b/include/llvm/Analysis/DataStructure/DataStructure.h index 667250e40fe..4551b16592a 100644 --- a/include/llvm/Analysis/DataStructure/DataStructure.h +++ b/include/llvm/Analysis/DataStructure/DataStructure.h @@ -1,4 +1,4 @@ -//===- DataStructure.h - Build data structure graphs -------------*- C++ -*--=// +//===- DataStructure.h - Build data structure graphs ------------*- C++ -*-===// // // Implement the LLVM data structure analysis library. // @@ -7,350 +7,35 @@ #ifndef LLVM_ANALYSIS_DATA_STRUCTURE_H #define LLVM_ANALYSIS_DATA_STRUCTURE_H +#include "llvm/Analysis/DSGraph.h" #include "llvm/Pass.h" +#if 0 #include "llvm/GlobalValue.h" #include "Support/HashExtras.h" #include "Support/hash_set" +#endif #include -#include class Type; class GlobalValue; -class DSNode; // Each node in the graph -class DSGraph; // A graph for a function +#if 0 class GlobalDSGraph; // A common graph for globals in a program -class DSNodeIterator; // Data structure graph traversal iterator +#endif class LocalDataStructures; // A collection of local graphs for a program class BUDataStructures; // A collection of bu graphs for a program class TDDataStructures; // A collection of td graphs for a program -//===----------------------------------------------------------------------===// -// DSNodeHandle - Implement a "handle" to a data structure node that takes care -// of all of the add/un'refing of the node to prevent the backpointers in the -// graph from getting out of date. -// -class DSNodeHandle { - DSNode *N; -public: - // Allow construction, destruction, and assignment... - DSNodeHandle(DSNode *n = 0) : N(0) { operator=(n); } - DSNodeHandle(const DSNodeHandle &H) : N(0) { operator=(H.N); } - ~DSNodeHandle() { operator=(0); } - DSNodeHandle &operator=(const DSNodeHandle &H) {operator=(H.N); return *this;} - // Assignment of DSNode*, implement all of the add/un'refing (defined later) - inline DSNodeHandle &operator=(DSNode *n); - - // Allow automatic, implicit, conversion to DSNode* - operator DSNode*() { return N; } - operator const DSNode*() const { return N; } - operator const DSNode*() { return N; } - operator bool() const { return N != 0; } - operator bool() { return N != 0; } - - bool operator<(const DSNodeHandle &H) const { // Allow sorting - return N < H.N; - } - bool operator==(const DSNodeHandle &H) const { return N == H.N; } - bool operator!=(const DSNodeHandle &H) const { return N != H.N; } - bool operator==(const DSNode *Node) const { return N == Node; } - bool operator!=(const DSNode *Node) const { return N != Node; } - bool operator==(DSNode *Node) const { return N == Node; } - bool operator!=(DSNode *Node) const { return N != Node; } - - // Avoid having comparisons to null cause errors... - bool operator==(int X) const { - assert(X == 0 && "Bad comparison!"); - return operator==((DSNode*)0); - } - bool operator!=(int X) const { return !operator==(X); } - - // Allow explicit conversion to DSNode... - DSNode *get() { return N; } - const DSNode *get() const { return N; } - - // Allow this to be treated like a pointer... - DSNode *operator->() { return N; } - const DSNode *operator->() const { return N; } -}; - - -//===----------------------------------------------------------------------===// -// DSNode - Data structure node class -// -// This class keeps track of a node's type, and the fields in the data -// structure. -// -// -class DSNode { - const Type *Ty; - std::vector Links; - std::vector Referrers; - - // Globals - The list of global values that are merged into this node. - std::vector Globals; - - void operator=(const DSNode &); // DO NOT IMPLEMENT -public: - enum NodeTy { - ShadowNode = 0, // Nothing is known about this node... - ScalarNode = 1 << 0, // Scalar of the current function contains this value - AllocaNode = 1 << 1, // This node was allocated with alloca - NewNode = 1 << 2, // This node was allocated with malloc - GlobalNode = 1 << 3, // This node was allocated by a global var decl - SubElement = 1 << 4, // This node is a part of some other node - CastNode = 1 << 5, // This node is accessed in unsafe ways - Incomplete = 1 << 6, // This node may not be complete - }; - - // NodeType - A union of the above bits. "Shadow" nodes do not add any flags - // to the nodes in the data structure graph, so it is possible to have nodes - // with a value of 0 for their NodeType. Scalar and Alloca markers go away - // when function graphs are inlined. +// FIXME: move this stuff to a private header +namespace DataStructureAnalysis { + // isPointerType - Return true if this first class type is big enough to hold + // a pointer. // - unsigned char NodeType; - - DSNode(enum NodeTy NT, const Type *T); - DSNode(const DSNode &); - - ~DSNode() { -#ifndef NDEBUG - dropAllReferences(); // Only needed to satisfy assertion checks... -#endif - assert(Referrers.empty() && "Referrers to dead node exist!"); - } - - // Iterator for graph interface... - typedef DSNodeIterator iterator; - inline iterator begin(); // Defined in DataStructureGraph.h - inline iterator end(); - - // Accessors - const Type *getType() const { return Ty; } - - unsigned getNumLinks() const { return Links.size(); } - DSNode *getLink(unsigned i) { - assert(i < getNumLinks() && "Field links access out of range..."); - return Links[i]; - } - const DSNode *getLink(unsigned i) const { - assert(i < getNumLinks() && "Field links access out of range..."); - return Links[i]; - } - - void setLink(unsigned i, DSNode *N) { - assert(i < getNumLinks() && "Field links access out of range..."); - Links[i] = N; - } - - // addGlobal - Add an entry for a global value to the Globals list. This also - // marks the node with the 'G' flag if it does not already have it. - // - void addGlobal(GlobalValue *GV); - const std::vector &getGlobals() const { return Globals; } - std::vector &getGlobals() { return Globals; } - - // addEdgeTo - Add an edge from the current node to the specified node. This - // can cause merging of nodes in the graph. - // - void addEdgeTo(unsigned LinkNo, DSNode *N); - void addEdgeTo(DSNode *N) { - assert(getNumLinks() == 1 && "Must specify a field number to add edge if " - " more than one field exists!"); - addEdgeTo(0, N); - } - - // mergeWith - Merge this node into the specified node, moving all links to - // and from the argument node into the current node. The specified node may - // be a null pointer (in which case, nothing happens). - // - void mergeWith(DSNode *N); - - // addReferrer - Keep the referrer set up to date... - void addReferrer(DSNodeHandle *H) { Referrers.push_back(H); } - void removeReferrer(DSNodeHandle *H); - const std::vector &getReferrers() const { return Referrers; } - - void print(std::ostream &O, const DSGraph *G) const; - void dump() const; - - std::string getCaption(const DSGraph *G) const; - - void dropAllReferences() { - Links.clear(); - } -}; - - -inline DSNodeHandle &DSNodeHandle::operator=(DSNode *n) { - if (N) N->removeReferrer(this); - N = n; - if (N) N->addReferrer(this); - return *this; + bool isPointerType(const Type *Ty); } -// DSGraph - The graph that represents a function. -// -class DSGraph { - friend class GlobalDSGraph; -protected: - Function &Func; - std::vector Nodes; - DSNodeHandle RetNode; // Node that gets returned... - std::map ValueMap; - - // GlobalsGraph -- Reference to the common graph of globally visible objects. - // This includes GlobalValues, New nodes, Cast nodes, and Calls. - // - GlobalDSGraph* GlobalsGraph; - - // FunctionCalls - This vector maintains a single entry for each call - // instruction in the current graph. Each call entry contains DSNodeHandles - // that refer to the arguments that are passed into the function call. The - // first entry in the vector is the scalar that holds the return value for the - // call, the second is the function scalar being invoked, and the rest are - // pointer arguments to the function. - // - std::vector > FunctionCalls; - - // 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 > 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 PendingCallers; - -protected: - // Define the interface only accessable to DataStructure - friend class LocalDataStructures; - friend class BUDataStructures; - friend class TDDataStructures; - DSGraph(Function &F, GlobalDSGraph* GlobalsG); // Compute the local DSGraph - DSGraph(const DSGraph &DSG); // Copy ctor - virtual ~DSGraph(); - - // 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 > &getOrigFunctionCalls() { - return OrigFunctionCalls; - } - - void operator=(const DSGraph &); // DO NOT IMPLEMENT -public: - - Function &getFunction() const { return Func; } - - // getNodes - Get a vector of all the nodes in the graph - // - const std::vector& getNodes() const { return Nodes; } - std::vector& getNodes() { return Nodes; } - - // getValueMap - Get a map that describes what the nodes the scalars in this - // function point to... - // - std::map &getValueMap() { return ValueMap; } - const std::map &getValueMap() const { return ValueMap;} - - std::vector > &getFunctionCalls() { - return FunctionCalls; - } - const std::vector > &getFunctionCalls() const { - return FunctionCalls; - } - - const DSNode *getRetNode() const { return RetNode; } - DSNode *getRetNode() { return RetNode; } - - unsigned getGraphSize() const { - return Nodes.size(); - } - - void print(std::ostream &O) const; - void dump() const; - - // maskNodeTypes - Apply a mask to all of the node types in the graph. This - // is useful for clearing out markers like Scalar or Incomplete. - // - void maskNodeTypes(unsigned char Mask); - void maskIncompleteMarkers() { maskNodeTypes(~DSNode::Incomplete); } - - // markIncompleteNodes - Traverse the graph, identifying nodes that may be - // modified by other functions that have not been resolved yet. This marks - // nodes that are reachable through three sources of "unknownness": - // Global Variables, Function Calls, and Incoming Arguments - // - // For any node that may have unknown components (because something outside - // the scope of current analysis may have modified it), the 'Incomplete' flag - // is added to the NodeType. - // - void markIncompleteNodes(bool markFormalArgs = true); - - // removeTriviallyDeadNodes - After the graph has been constructed, this - // method removes all unreachable nodes that are created because they got - // merged with other nodes in the graph. - // - void removeTriviallyDeadNodes(bool KeepAllGlobals = false); - - // removeDeadNodes - Use a more powerful reachability analysis to eliminate - // subgraphs that are unreachable. This often occurs because the data - // structure doesn't "escape" into it's caller, and thus should be eliminated - // from the caller's graph entirely. This is only appropriate to use when - // inlining graphs. - // - void removeDeadNodes(bool KeepAllGlobals = false, bool KeepCalls = true); - - // 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& getPendingCallers() { - return PendingCallers; - } - - // 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. - // If StripScalars (StripAllocas) is set to true, Scalar (Alloca) markers - // are removed from the graph as the graph is being cloned. - // If CopyCallers is set to true, the PendingCallers list is copied. - // If CopyOrigCalls is set to true, the OrigFunctionCalls list is copied. - // - DSNode *cloneInto(const DSGraph &G, std::map &OldValMap, - std::map& OldNodeMap, - bool StripScalars = false, bool StripAllocas = false, - bool CopyCallers = true, bool CopyOrigCalls = true); - - // cloneGlobalInto - Clone the given global node (or the node for the given - // GlobalValue) from the GlobalsGraph and all its target links (recursively). - // - DSNode* cloneGlobalInto(const DSNode* GNode); - DSNode* cloneGlobalInto(GlobalValue* GV) { - assert(!GV || (((DSGraph*) GlobalsGraph)->ValueMap[GV] != 0)); - return GV? cloneGlobalInto(((DSGraph*) GlobalsGraph)->ValueMap[GV]) : 0; - } - -private: - bool isNodeDead(DSNode *N); -}; - - +#if 0 // GlobalDSGraph - A common graph for all the globals and their outgoing links // to externally visible nodes. This includes GlobalValues, New nodes, // Cast nodes, and Calls. This graph can only be used by one of the @@ -376,7 +61,7 @@ public: void cloneGlobals(DSGraph& Graph, bool CloneCalls = false); void cloneCalls (DSGraph& Graph); }; - +#endif // LocalDataStructures - The analysis that computes the local data structure // graphs for all of the functions in the program. @@ -411,7 +96,7 @@ public: } }; - +#if 0 // BUDataStructures - The analysis that computes the interprocedurally closed // data structure graphs for all of the functions in the program. This pass // only performs a "Bottom Up" propogation (hence the name). @@ -484,3 +169,5 @@ private: std::map &OldNodeMap); }; #endif + +#endif diff --git a/include/llvm/Analysis/DataStructureGraph.h b/include/llvm/Analysis/DataStructureGraph.h index 4397f621c12..d82e2e5b1b2 100644 --- a/include/llvm/Analysis/DataStructureGraph.h +++ b/include/llvm/Analysis/DataStructureGraph.h @@ -13,6 +13,8 @@ #include "Support/GraphTraits.h" #include "Support/iterator" +#if 0 + class DSNodeIterator : public forward_iterator { friend class DSNode; DSNode * const Node; @@ -67,3 +69,5 @@ inline DSNode::iterator DSNode::begin() { return DSNodeIterator(this); } inline DSNode::iterator DSNode::end() { return DSNodeIterator(this, false); } #endif + +#endif