[llvm-commits] CVS: llvm/lib/Analysis/DataStructure/IPModRef.h IPModRef.cpp MemoryDepAnalysis.cpp
Chris Lattner
lattner at cs.uiuc.edu
Sun Jun 27 19:42:01 PDT 2004
Changes in directory llvm/lib/Analysis/DataStructure:
IPModRef.h added (r1.1)
IPModRef.cpp updated: 1.21 -> 1.22
MemoryDepAnalysis.cpp updated: 1.14 -> 1.15
---
Log message:
Moved IPModRef out of the public include dir
---
Diffs of the changes: (+234 -2)
Index: llvm/lib/Analysis/DataStructure/IPModRef.h
diff -c /dev/null llvm/lib/Analysis/DataStructure/IPModRef.h:1.1
*** /dev/null Sun Jun 27 19:41:33 2004
--- llvm/lib/Analysis/DataStructure/IPModRef.h Sun Jun 27 19:41:23 2004
***************
*** 0 ****
--- 1,232 ----
+ //===- IPModRef.h - Compute IP Mod/Ref information --------------*- 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.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // class IPModRef:
+ //
+ // class IPModRef is an interprocedural analysis pass that computes
+ // flow-insensitive IP Mod and Ref information for every function
+ // (the GMOD and GREF problems) and for every call site (MOD and REF).
+ //
+ // In practice, this needs to do NO real interprocedural work because
+ // all that is needed is done by the data structure analysis.
+ // This uses the top-down DS graph for a function and the bottom-up DS graph
+ // for each callee (including the Mod/Ref flags in the bottom-up graph)
+ // to compute the set of nodes that are Mod and Ref for the function and
+ // for each of its call sites.
+ //
+ //
+ // class FunctionModRefInfo:
+ //
+ // The results of IPModRef are encapsulated in the class FunctionModRefInfo.
+ // The results are stored as bit vectors: bit i represents node i
+ // in the TD DSGraph for the current function. (This node numbering is
+ // implemented by class FunctionModRefInfo.) Each FunctionModRefInfo
+ // includes:
+ // -- 2 bit vectors for the function (GMOD and GREF), and
+ // -- 2 bit vectors for each call site (MOD and REF).
+ //
+ //
+ // IPModRef vs. Alias Analysis for Clients:
+ //
+ // The IPModRef pass does not provide simpler query interfaces for specific
+ // LLVM values, instructions, or pointers because those results should be
+ // obtained through alias analysis (e.g., class DSAliasAnalysis).
+ // class IPModRef is primarily meant for other analysis passes that need to
+ // use Mod/Ref information efficiently for more complicated purposes;
+ // the bit-vector representations make propagation very efficient.
+ //
+ //===----------------------------------------------------------------------===//
+
+ #ifndef LLVM_ANALYSIS_IPMODREF_H
+ #define LLVM_ANALYSIS_IPMODREF_H
+
+ #include "llvm/Pass.h"
+ #include "Support/BitSetVector.h"
+ #include "Support/hash_map"
+
+ namespace llvm {
+
+ class Module;
+ class Function;
+ class CallSite;
+ class Instruction;
+ class CallInst;
+ class InvokeInst;
+ class DSNode;
+ class DSGraph;
+ class DSNodeHandle;
+ class ModRefInfo; // Result of IP Mod/Ref for one entity
+ class FunctionModRefInfo; // ModRefInfo for a func and all calls in it
+ class IPModRef; // Pass that computes IP Mod/Ref info
+
+ //----------------------------------------------------------------------------
+ /// ModRefInfo Class - Representation of Mod/Ref information for a single
+ /// function or callsite. This is represented as a pair of bit vectors, one each
+ /// for Mod and Ref. Each bit vector is indexed by the node id of the DS graph
+ /// node index.
+ ///
+ class ModRefInfo {
+ BitSetVector modNodeSet; // set of modified nodes
+ BitSetVector refNodeSet; // set of referenced nodes
+
+ public:
+ // Methods to construct ModRefInfo objects.
+ ModRefInfo(unsigned int numNodes)
+ : modNodeSet(numNodes),
+ refNodeSet(numNodes) { }
+
+ unsigned getSize() const {
+ assert(modNodeSet.size() == refNodeSet.size() &&
+ "Mod & Ref different size?");
+ return modNodeSet.size();
+ }
+
+ void setNodeIsMod (unsigned nodeId) { modNodeSet[nodeId] = true; }
+ void setNodeIsRef (unsigned nodeId) { refNodeSet[nodeId] = true; }
+
+ // Methods to query the mod/ref info
+ bool nodeIsMod (unsigned nodeId) const { return modNodeSet.test(nodeId); }
+ bool nodeIsRef (unsigned nodeId) const { return refNodeSet.test(nodeId); }
+ bool nodeIsKill(unsigned nodeId) const { return false; }
+
+ const BitSetVector& getModSet() const { return modNodeSet; }
+ BitSetVector& getModSet() { return modNodeSet; }
+
+ const BitSetVector& getRefSet() const { return refNodeSet; }
+ BitSetVector& getRefSet() { return refNodeSet; }
+
+ // Debugging support methods
+ void print(std::ostream &O, const std::string& prefix=std::string("")) const;
+ void dump() const;
+ };
+
+
+ //----------------------------------------------------------------------------
+ /// FunctionModRefInfo Class - Representation of the results of IP Mod/Ref
+ /// analysis for a function and for each of the call sites within the function.
+ /// Each of these are represented as bit vectors of size = the number of nodes
+ /// in the top-dwon DS graph of the function. Nodes are identified by their
+ /// nodeId, in the range [0 .. funcTDGraph.size()-1].
+ ///
+ class FunctionModRefInfo {
+ const Function& F; // The function
+ IPModRef& IPModRefObj; // The IPModRef Object owning this
+ DSGraph* funcTDGraph; // Top-down DS graph for function
+ ModRefInfo funcModRefInfo; // ModRefInfo for the function body
+ std::map<const Instruction*, ModRefInfo*>
+ callSiteModRefInfo; // ModRefInfo for each callsite
+ std::map<const DSNode*, unsigned> NodeIds;
+
+ friend class IPModRef;
+
+ void computeModRef(const Function &func);
+ void computeModRef(CallSite call);
+ DSGraph*
+ ResolveCallSiteModRefInfo(CallSite CS,
+ hash_map<const DSNode*, DSNodeHandle> &NodeMap);
+
+ public:
+ FunctionModRefInfo(const Function& func, IPModRef &IPModRefObj,
+ DSGraph* tdgClone);
+ ~FunctionModRefInfo();
+
+ // Identify the function and its relevant DS graph
+ //
+ const Function& getFunction() const { return F; }
+ const DSGraph& getFuncGraph() const { return *funcTDGraph; }
+
+ // Retrieve Mod/Ref results for a single call site and for the function body
+ //
+ const ModRefInfo* getModRefInfo(const Function& func) const {
+ return &funcModRefInfo;
+ }
+ const ModRefInfo* getModRefInfo(const CallInst& callInst) const {
+ std::map<const Instruction*, ModRefInfo*>::const_iterator I =
+ callSiteModRefInfo.find((Instruction*)&callInst);
+ return (I == callSiteModRefInfo.end()) ? NULL : I->second;
+ }
+ const ModRefInfo* getModRefInfo(const InvokeInst& II) const {
+ std::map<const Instruction*, ModRefInfo*>::const_iterator I =
+ callSiteModRefInfo.find((Instruction*)&II);
+ return (I == callSiteModRefInfo.end()) ? NULL : I->second;
+ }
+
+ // Get the nodeIds used to index all Mod/Ref information for current function
+ //
+ unsigned getNodeId(const DSNode* node) const {
+ std::map<const DSNode*, unsigned>::const_iterator iter = NodeIds.find(node);
+ assert(iter != NodeIds.end() && iter->second < funcModRefInfo.getSize());
+ return iter->second;
+ }
+
+ unsigned getNodeId(const Value* value) const;
+
+ // Debugging support methods
+ void print(std::ostream &O) const;
+ void dump() const;
+ };
+
+
+ //----------------------------------------------------------------------------
+ /// IPModRef Class - An interprocedural pass that computes IP Mod/Ref info for
+ /// functions and for individual call sites.
+ ///
+ /// Given the DSGraph of a function, this class can be queried for
+ /// a ModRefInfo object describing all the nodes in the DSGraph that are
+ /// (a) modified, and (b) referenced during an execution of the function
+ /// from an arbitrary callsite, or during an execution of a single call-site
+ /// within the function.
+ ///
+ class IPModRef : public Pass {
+ std::map<const Function*, FunctionModRefInfo*> funcToModRefInfoMap;
+ Module* M;
+
+ FunctionModRefInfo& getFuncInfo(const Function& func,
+ bool computeIfMissing = false);
+ public:
+ IPModRef() : M(NULL) {}
+ ~IPModRef() {}
+
+ /// run - Driver function to run IP Mod/Ref on a Module.
+ /// This initializes the module reference, and then computes IPModRef
+ /// results immediately if demand-driven analysis was *not* specified.
+ ///
+ virtual bool run(Module &M);
+
+ /// getFunctionModRefInfo - Retrieve the Mod/Ref information for a single
+ /// function
+ ///
+ const FunctionModRefInfo& getFunctionModRefInfo(const Function& func) {
+ return getFuncInfo(func);
+ }
+
+ /// getBUDSGraph - This method returns the BU data structure graph for F
+ /// through the use of the BUDataStructures object.
+ ///
+ const DSGraph &getBUDSGraph(const Function &F);
+
+ // Debugging support methods
+ //
+ void print(std::ostream &O) const;
+ void dump() const;
+
+ /// releaseMemory - Release memory held by this pass when the pass pipeline is
+ /// done
+ ///
+ virtual void releaseMemory();
+
+ /// getAnalysisUsage - This pass requires top-down data structure graphs.
+ /// It modifies nothing.
+ ///
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const;
+ };
+
+ } // End llvm namespace
+
+ #endif
Index: llvm/lib/Analysis/DataStructure/IPModRef.cpp
diff -u llvm/lib/Analysis/DataStructure/IPModRef.cpp:1.21 llvm/lib/Analysis/DataStructure/IPModRef.cpp:1.22
--- llvm/lib/Analysis/DataStructure/IPModRef.cpp:1.21 Sat Feb 7 17:57:26 2004
+++ llvm/lib/Analysis/DataStructure/IPModRef.cpp Sun Jun 27 19:41:23 2004
@@ -11,7 +11,7 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/Analysis/IPModRef.h"
+#include "IPModRef.h"
#include "llvm/Analysis/DataStructure.h"
#include "llvm/Analysis/DSGraph.h"
#include "llvm/Module.h"
Index: llvm/lib/Analysis/DataStructure/MemoryDepAnalysis.cpp
diff -u llvm/lib/Analysis/DataStructure/MemoryDepAnalysis.cpp:1.14 llvm/lib/Analysis/DataStructure/MemoryDepAnalysis.cpp:1.15
--- llvm/lib/Analysis/DataStructure/MemoryDepAnalysis.cpp:1.14 Sun Jun 27 19:27:15 2004
+++ llvm/lib/Analysis/DataStructure/MemoryDepAnalysis.cpp Sun Jun 27 19:41:23 2004
@@ -21,7 +21,7 @@
#include "llvm/Module.h"
#include "llvm/iMemory.h"
#include "llvm/iOther.h"
-#include "llvm/Analysis/IPModRef.h"
+#include "IPModRef.h"
#include "llvm/Analysis/DataStructure.h"
#include "llvm/Analysis/DSGraph.h"
#include "llvm/Support/InstVisitor.h"
More information about the llvm-commits
mailing list