+++ /dev/null
-//===- IPModRef.cpp - 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.
-//
-//===----------------------------------------------------------------------===//
-//
-// See high-level comments in include/llvm/Analysis/IPModRef.h
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Analysis/IPModRef.h"
-#include "llvm/Analysis/DataStructure.h"
-#include "llvm/Analysis/DSGraph.h"
-#include "llvm/Module.h"
-#include "llvm/Function.h"
-#include "llvm/iMemory.h"
-#include "llvm/iOther.h"
-#include "Support/Statistic.h"
-#include "Support/STLExtras.h"
-#include "Support/StringExtras.h"
-#include <vector>
-
-namespace llvm {
-
-//----------------------------------------------------------------------------
-// Private constants and data
-//----------------------------------------------------------------------------
-
-static RegisterAnalysis<IPModRef>
-Z("ipmodref", "Interprocedural mod/ref analysis");
-
-
-//----------------------------------------------------------------------------
-// class ModRefInfo
-//----------------------------------------------------------------------------
-
-void ModRefInfo::print(std::ostream &O,
- const std::string& sprefix) const
-{
- O << sprefix << "Modified nodes = " << modNodeSet;
- O << sprefix << "Referenced nodes = " << refNodeSet;
-}
-
-void ModRefInfo::dump() const
-{
- print(std::cerr);
-}
-
-//----------------------------------------------------------------------------
-// class FunctionModRefInfo
-//----------------------------------------------------------------------------
-
-
-// This constructor computes a node numbering for the TD graph.
-//
-FunctionModRefInfo::FunctionModRefInfo(const Function& func,
- IPModRef& ipmro,
- DSGraph* tdgClone)
- : F(func), IPModRefObj(ipmro),
- funcTDGraph(tdgClone),
- funcModRefInfo(tdgClone->getGraphSize())
-{
- unsigned i = 0;
- for (DSGraph::node_iterator NI = funcTDGraph->node_begin(),
- E = funcTDGraph->node_end(); NI != E; ++NI)
- NodeIds[*NI] = i++;
-}
-
-
-FunctionModRefInfo::~FunctionModRefInfo()
-{
- for(std::map<const Instruction*, ModRefInfo*>::iterator
- I=callSiteModRefInfo.begin(), E=callSiteModRefInfo.end(); I != E; ++I)
- delete(I->second);
-
- // Empty map just to make problems easier to track down
- callSiteModRefInfo.clear();
-
- delete funcTDGraph;
-}
-
-unsigned FunctionModRefInfo::getNodeId(const Value* value) const {
- return getNodeId(funcTDGraph->getNodeForValue(const_cast<Value*>(value))
- .getNode());
-}
-
-
-
-// Compute Mod/Ref bit vectors for the entire function.
-// These are simply copies of the Read/Write flags from the nodes of
-// the top-down DS graph.
-//
-void FunctionModRefInfo::computeModRef(const Function &func)
-{
- // Mark all nodes in the graph that are marked MOD as being mod
- // and all those marked REF as being ref.
- unsigned i = 0;
- for (DSGraph::node_iterator NI = funcTDGraph->node_begin(),
- E = funcTDGraph->node_end(); NI != E; ++NI, ++i) {
- if ((*NI)->isModified()) funcModRefInfo.setNodeIsMod(i);
- if ((*NI)->isRead()) funcModRefInfo.setNodeIsRef(i);
- }
-
- // Compute the Mod/Ref info for all call sites within the function.
- // The call sites are recorded in the TD graph.
- const std::vector<DSCallSite>& callSites = funcTDGraph->getFunctionCalls();
- for (unsigned i = 0, N = callSites.size(); i < N; ++i)
- computeModRef(callSites[i].getCallSite());
-}
-
-
-// ResolveCallSiteModRefInfo - This method performs the following actions:
-//
-// 1. It clones the top-down graph for the current function
-// 2. It clears all of the mod/ref bits in the cloned graph
-// 3. It then merges the bottom-up graph(s) for the specified call-site into
-// the clone (bringing new mod/ref bits).
-// 4. It returns the clone, and a mapping of nodes from the original TDGraph to
-// the cloned graph with Mod/Ref info for the callsite.
-//
-// NOTE: Because this clones a dsgraph and returns it, the caller is responsible
-// for deleting the returned graph!
-// NOTE: This method may return a null pointer if it is unable to determine the
-// requested information (because the call site calls an external
-// function or we cannot determine the complete set of functions invoked).
-//
-DSGraph* FunctionModRefInfo::ResolveCallSiteModRefInfo(CallSite CS,
- hash_map<const DSNode*, DSNodeHandle> &NodeMap)
-{
- // Step #0: Quick check if we are going to fail anyway: avoid
- // all the graph cloning and map copying in steps #1 and #2.
- //
- if (const Function *F = CS.getCalledFunction()) {
- if (F->isExternal())
- return 0; // We cannot compute Mod/Ref info for this callsite...
- } else {
- // Eventually, should check here if any callee is external.
- // For now we are not handling this case anyway.
- std::cerr << "IP Mod/Ref indirect call not implemented yet: "
- << "Being conservative\n";
- return 0; // We cannot compute Mod/Ref info for this callsite...
- }
-
- // Step #1: Clone the top-down graph...
- DSGraph *Result = new DSGraph(*funcTDGraph, NodeMap);
-
- // Step #2: Clear Mod/Ref information...
- Result->maskNodeTypes(~(DSNode::Modified | DSNode::Read));
-
- // Step #3: clone the bottom up graphs for the callees into the caller graph
- if (Function *F = CS.getCalledFunction())
- {
- assert(!F->isExternal());
-
- // Build up a DSCallSite for our invocation point here...
-
- // If the call returns a value, make sure to merge the nodes...
- DSNodeHandle RetVal;
- if (DS::isPointerType(CS.getInstruction()->getType()))
- RetVal = Result->getNodeForValue(CS.getInstruction());
-
- // Populate the arguments list...
- std::vector<DSNodeHandle> Args;
- for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
- I != E; ++I)
- if (DS::isPointerType((*I)->getType()))
- Args.push_back(Result->getNodeForValue(*I));
-
- // Build the call site...
- DSCallSite NCS(CS, RetVal, F, Args);
-
- // Perform the merging now of the graph for the callee, which will
- // come with mod/ref bits set...
- Result->mergeInGraph(NCS, *F, IPModRefObj.getBUDSGraph(*F),
- DSGraph::StripAllocaBit
- | DSGraph::DontCloneCallNodes
- | DSGraph::DontCloneAuxCallNodes);
- }
- else
- assert(0 && "See error message");
-
- // Remove dead nodes aggressively to match the caller's original graph.
- Result->removeDeadNodes(DSGraph::KeepUnreachableGlobals);
-
- // Step #4: Return the clone + the mapping (by ref)
- return Result;
-}
-
-// Compute Mod/Ref bit vectors for a single call site.
-// These are copies of the Read/Write flags from the nodes of
-// the graph produced by clearing all flags in the caller's TD graph
-// and then inlining the callee's BU graph into the caller's TD graph.
-//
-void
-FunctionModRefInfo::computeModRef(CallSite CS)
-{
- // Allocate the mod/ref info for the call site. Bits automatically cleared.
- ModRefInfo* callModRefInfo = new ModRefInfo(funcTDGraph->getGraphSize());
- callSiteModRefInfo[CS.getInstruction()] = callModRefInfo;
-
- // Get a copy of the graph for the callee with the callee inlined
- hash_map<const DSNode*, DSNodeHandle> NodeMap;
- DSGraph* csgp = ResolveCallSiteModRefInfo(CS, NodeMap);
- if (!csgp)
- { // Callee's side effects are unknown: mark all nodes Mod and Ref.
- // Eventually this should only mark nodes visible to the callee, i.e.,
- // exclude stack variables not reachable from any outgoing argument
- // or any global.
- callModRefInfo->getModSet().set();
- callModRefInfo->getRefSet().set();
- return;
- }
-
- // For all nodes in the graph, extract the mod/ref information
- for (DSGraph::node_iterator NI = funcTDGraph->node_begin(),
- E = funcTDGraph->node_end(); NI != E; ++NI) {
- DSNode* csgNode = NodeMap[*NI].getNode();
- assert(csgNode && "Inlined and original graphs do not correspond!");
- if (csgNode->isModified())
- callModRefInfo->setNodeIsMod(getNodeId(*NI));
- if (csgNode->isRead())
- callModRefInfo->setNodeIsRef(getNodeId(*NI));
- }
-
- // Drop nodemap before we delete the graph...
- NodeMap.clear();
- delete csgp;
-}
-
-
-class DSGraphPrintHelper {
- const DSGraph& tdGraph;
- std::vector<std::vector<const Value*> > knownValues; // identifiable objects
-
-public:
- /*ctor*/ DSGraphPrintHelper(const FunctionModRefInfo& fmrInfo)
- : tdGraph(fmrInfo.getFuncGraph())
- {
- knownValues.resize(tdGraph.getGraphSize());
-
- // For every identifiable value, save Value pointer in knownValues[i]
- for (hash_map<Value*, DSNodeHandle>::const_iterator
- I = tdGraph.getScalarMap().begin(),
- E = tdGraph.getScalarMap().end(); I != E; ++I)
- if (isa<GlobalValue>(I->first) ||
- isa<Argument>(I->first) ||
- isa<LoadInst>(I->first) ||
- isa<AllocaInst>(I->first) ||
- isa<MallocInst>(I->first))
- {
- unsigned nodeId = fmrInfo.getNodeId(I->second.getNode());
- knownValues[nodeId].push_back(I->first);
- }
- }
-
- void printValuesInBitVec(std::ostream &O, const BitSetVector& bv) const
- {
- assert(bv.size() == knownValues.size());
-
- if (bv.none())
- { // No bits are set: just say so and return
- O << "\tNONE.\n";
- return;
- }
-
- if (bv.all())
- { // All bits are set: just say so and return
- O << "\tALL GRAPH NODES.\n";
- return;
- }
-
- for (unsigned i=0, N=bv.size(); i < N; ++i)
- if (bv.test(i))
- {
- O << "\tNode# " << i << " : ";
- if (! knownValues[i].empty())
- for (unsigned j=0, NV=knownValues[i].size(); j < NV; j++)
- {
- const Value* V = knownValues[i][j];
-
- if (isa<GlobalValue>(V)) O << "(Global) ";
- else if (isa<Argument>(V)) O << "(Target of FormalParm) ";
- else if (isa<LoadInst>(V)) O << "(Target of LoadInst ) ";
- else if (isa<AllocaInst>(V)) O << "(Target of AllocaInst) ";
- else if (isa<MallocInst>(V)) O << "(Target of MallocInst) ";
-
- if (V->hasName()) O << V->getName();
- else if (isa<Instruction>(V)) O << *V;
- else O << "(Value*) 0x" << (void*) V;
-
- O << std::string((j < NV-1)? "; " : "\n");
- }
-#if 0
- else
- tdGraph.getNodes()[i]->print(O, /*graph*/ NULL);
-#endif
- }
- }
-};
-
-
-// Print the results of the pass.
-// Currently this just prints bit-vectors and is not very readable.
-//
-void FunctionModRefInfo::print(std::ostream &O) const
-{
- DSGraphPrintHelper DPH(*this);
-
- O << "========== Mod/ref information for function "
- << F.getName() << "========== \n\n";
-
- // First: Print Globals and Locals modified anywhere in the function.
- //
- O << " -----Mod/Ref in the body of function " << F.getName()<< ":\n";
-
- O << " --Objects modified in the function body:\n";
- DPH.printValuesInBitVec(O, funcModRefInfo.getModSet());
-
- O << " --Objects referenced in the function body:\n";
- DPH.printValuesInBitVec(O, funcModRefInfo.getRefSet());
-
- O << " --Mod and Ref vectors for the nodes listed above:\n";
- funcModRefInfo.print(O, "\t");
-
- O << "\n";
-
- // Second: Print Globals and Locals modified at each call site in function
- //
- for (std::map<const Instruction *, ModRefInfo*>::const_iterator
- CI = callSiteModRefInfo.begin(), CE = callSiteModRefInfo.end();
- CI != CE; ++CI)
- {
- O << " ----Mod/Ref information for call site\n" << CI->first;
-
- O << " --Objects modified at call site:\n";
- DPH.printValuesInBitVec(O, CI->second->getModSet());
-
- O << " --Objects referenced at call site:\n";
- DPH.printValuesInBitVec(O, CI->second->getRefSet());
-
- O << " --Mod and Ref vectors for the nodes listed above:\n";
- CI->second->print(O, "\t");
-
- O << "\n";
- }
-
- O << "\n";
-}
-
-void FunctionModRefInfo::dump() const
-{
- print(std::cerr);
-}
-
-
-//----------------------------------------------------------------------------
-// class IPModRef: An interprocedural pass that computes IP Mod/Ref info.
-//----------------------------------------------------------------------------
-
-// Free the FunctionModRefInfo objects cached in funcToModRefInfoMap.
-//
-void IPModRef::releaseMemory()
-{
- for(std::map<const Function*, FunctionModRefInfo*>::iterator
- I=funcToModRefInfoMap.begin(), E=funcToModRefInfoMap.end(); I != E; ++I)
- delete(I->second);
-
- // Clear map so memory is not re-released if we are called again
- funcToModRefInfoMap.clear();
-}
-
-// Run the "interprocedural" pass on each function. This needs to do
-// NO real interprocedural work because all that has been done the
-// data structure analysis.
-//
-bool IPModRef::run(Module &theModule)
-{
- M = &theModule;
-
- for (Module::const_iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI)
- if (! FI->isExternal())
- getFuncInfo(*FI, /*computeIfMissing*/ true);
- return true;
-}
-
-
-FunctionModRefInfo& IPModRef::getFuncInfo(const Function& func,
- bool computeIfMissing)
-{
- FunctionModRefInfo*& funcInfo = funcToModRefInfoMap[&func];
- assert (funcInfo != NULL || computeIfMissing);
- if (funcInfo == NULL)
- { // Create a new FunctionModRefInfo object.
- // Clone the top-down graph and remove any dead nodes first, because
- // otherwise original and merged graphs will not match.
- // The memory for this graph clone will be freed by FunctionModRefInfo.
- DSGraph* funcTDGraph =
- new DSGraph(getAnalysis<TDDataStructures>().getDSGraph(func));
- funcTDGraph->removeDeadNodes(DSGraph::KeepUnreachableGlobals);
-
- funcInfo = new FunctionModRefInfo(func, *this, funcTDGraph); //auto-insert
- funcInfo->computeModRef(func); // computes the mod/ref info
- }
- return *funcInfo;
-}
-
-/// getBUDSGraph - This method returns the BU data structure graph for F through
-/// the use of the BUDataStructures object.
-///
-const DSGraph &IPModRef::getBUDSGraph(const Function &F) {
- return getAnalysis<BUDataStructures>().getDSGraph(F);
-}
-
-
-// getAnalysisUsage - This pass requires top-down data structure graphs.
-// It modifies nothing.
-//
-void IPModRef::getAnalysisUsage(AnalysisUsage &AU) const {
- AU.setPreservesAll();
- AU.addRequired<LocalDataStructures>();
- AU.addRequired<BUDataStructures>();
- AU.addRequired<TDDataStructures>();
-}
-
-
-void IPModRef::print(std::ostream &O) const
-{
- O << "\nRESULTS OF INTERPROCEDURAL MOD/REF ANALYSIS:\n\n";
-
- for (std::map<const Function*, FunctionModRefInfo*>::const_iterator
- mapI = funcToModRefInfoMap.begin(), mapE = funcToModRefInfoMap.end();
- mapI != mapE; ++mapI)
- mapI->second->print(O);
-
- O << "\n";
-}
-
-
-void IPModRef::dump() const
-{
- print(std::cerr);
-}
-
-} // End llvm namespace
+++ /dev/null
-//===- MemoryDepAnalysis.cpp - Compute dep graph for memory ops -----------===//
-//
-// 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 file implements a pass (MemoryDepAnalysis) that computes memory-based
-// data dependences between instructions for each function in a module.
-// Memory-based dependences occur due to load and store operations, but
-// also the side-effects of call instructions.
-//
-// The result of this pass is a DependenceGraph for each function
-// representing the memory-based data dependences between instructions.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Analysis/MemoryDepAnalysis.h"
-#include "llvm/Module.h"
-#include "llvm/iMemory.h"
-#include "llvm/iOther.h"
-#include "llvm/Analysis/IPModRef.h"
-#include "llvm/Analysis/DataStructure.h"
-#include "llvm/Analysis/DSGraph.h"
-#include "llvm/Support/InstVisitor.h"
-#include "llvm/Support/CFG.h"
-#include "Support/SCCIterator.h"
-#include "Support/Statistic.h"
-#include "Support/STLExtras.h"
-#include "Support/hash_map"
-#include "Support/hash_set"
-
-namespace llvm {
-
-///--------------------------------------------------------------------------
-/// struct ModRefTable:
-///
-/// A data structure that tracks ModRefInfo for instructions:
-/// -- modRefMap is a map of Instruction* -> ModRefInfo for the instr.
-/// -- definers is a vector of instructions that define any node
-/// -- users is a vector of instructions that reference any node
-/// -- numUsersBeforeDef is a vector indicating that the number of users
-/// seen before definers[i] is numUsersBeforeDef[i].
-///
-/// numUsersBeforeDef[] effectively tells us the exact interleaving of
-/// definers and users within the ModRefTable.
-/// This is only maintained when constructing the table for one SCC, and
-/// not copied over from one table to another since it is no longer useful.
-///--------------------------------------------------------------------------
-
-struct ModRefTable {
- typedef hash_map<Instruction*, ModRefInfo> ModRefMap;
- typedef ModRefMap::const_iterator const_map_iterator;
- typedef ModRefMap:: iterator map_iterator;
- typedef std::vector<Instruction*>::const_iterator const_ref_iterator;
- typedef std::vector<Instruction*>:: iterator ref_iterator;
-
- ModRefMap modRefMap;
- std::vector<Instruction*> definers;
- std::vector<Instruction*> users;
- std::vector<unsigned> numUsersBeforeDef;
-
- // Iterators to enumerate all the defining instructions
- const_ref_iterator defsBegin() const { return definers.begin(); }
- ref_iterator defsBegin() { return definers.begin(); }
- const_ref_iterator defsEnd() const { return definers.end(); }
- ref_iterator defsEnd() { return definers.end(); }
-
- // Iterators to enumerate all the user instructions
- const_ref_iterator usersBegin() const { return users.begin(); }
- ref_iterator usersBegin() { return users.begin(); }
- const_ref_iterator usersEnd() const { return users.end(); }
- ref_iterator usersEnd() { return users.end(); }
-
- // Iterator identifying the last user that was seen *before* a
- // specified def. In particular, all users in the half-closed range
- // [ usersBegin(), usersBeforeDef_End(defPtr) )
- // were seen *before* the specified def. All users in the half-closed range
- // [ usersBeforeDef_End(defPtr), usersEnd() )
- // were seen *after* the specified def.
- //
- ref_iterator usersBeforeDef_End(const_ref_iterator defPtr) {
- unsigned defIndex = (unsigned) (defPtr - defsBegin());
- assert(defIndex < numUsersBeforeDef.size());
- assert(usersBegin() + numUsersBeforeDef[defIndex] <= usersEnd());
- return usersBegin() + numUsersBeforeDef[defIndex];
- }
- const_ref_iterator usersBeforeDef_End(const_ref_iterator defPtr) const {
- return const_cast<ModRefTable*>(this)->usersBeforeDef_End(defPtr);
- }
-
- //
- // Modifier methods
- //
- void AddDef(Instruction* D) {
- definers.push_back(D);
- numUsersBeforeDef.push_back(users.size());
- }
- void AddUse(Instruction* U) {
- users.push_back(U);
- }
- void Insert(const ModRefTable& fromTable) {
- modRefMap.insert(fromTable.modRefMap.begin(), fromTable.modRefMap.end());
- definers.insert(definers.end(),
- fromTable.definers.begin(), fromTable.definers.end());
- users.insert(users.end(),
- fromTable.users.begin(), fromTable.users.end());
- numUsersBeforeDef.clear(); /* fromTable.numUsersBeforeDef is ignored */
- }
-};
-
-
-///--------------------------------------------------------------------------
-/// class ModRefInfoBuilder:
-///
-/// A simple InstVisitor<> class that retrieves the Mod/Ref info for
-/// Load/Store/Call instructions and inserts this information in
-/// a ModRefTable. It also records all instructions that Mod any node
-/// and all that use any node.
-///--------------------------------------------------------------------------
-
-class ModRefInfoBuilder : public InstVisitor<ModRefInfoBuilder> {
- const DSGraph& funcGraph;
- const FunctionModRefInfo& funcModRef;
- struct ModRefTable& modRefTable;
-
- ModRefInfoBuilder(); // DO NOT IMPLEMENT
- ModRefInfoBuilder(const ModRefInfoBuilder&); // DO NOT IMPLEMENT
- void operator=(const ModRefInfoBuilder&); // DO NOT IMPLEMENT
-
-public:
- ModRefInfoBuilder(const DSGraph& _funcGraph,
- const FunctionModRefInfo& _funcModRef,
- ModRefTable& _modRefTable)
- : funcGraph(_funcGraph), funcModRef(_funcModRef), modRefTable(_modRefTable)
- {
- }
-
- // At a call instruction, retrieve the ModRefInfo using IPModRef results.
- // Add the call to the defs list if it modifies any nodes and to the uses
- // list if it refs any nodes.
- //
- void visitCallInst(CallInst& callInst) {
- ModRefInfo safeModRef(funcGraph.getGraphSize());
- const ModRefInfo* callModRef = funcModRef.getModRefInfo(callInst);
- if (callModRef == NULL) {
- // call to external/unknown function: mark all nodes as Mod and Ref
- safeModRef.getModSet().set();
- safeModRef.getRefSet().set();
- callModRef = &safeModRef;
- }
-
- modRefTable.modRefMap.insert(std::make_pair(&callInst,
- ModRefInfo(*callModRef)));
- if (callModRef->getModSet().any())
- modRefTable.AddDef(&callInst);
- if (callModRef->getRefSet().any())
- modRefTable.AddUse(&callInst);
- }
-
- // At a store instruction, add to the mod set the single node pointed to
- // by the pointer argument of the store. Interestingly, if there is no
- // such node, that would be a null pointer reference!
- void visitStoreInst(StoreInst& storeInst) {
- const DSNodeHandle& ptrNode =
- funcGraph.getNodeForValue(storeInst.getPointerOperand());
- if (const DSNode* target = ptrNode.getNode()) {
- unsigned nodeId = funcModRef.getNodeId(target);
- ModRefInfo& minfo =
- modRefTable.modRefMap.insert(
- std::make_pair(&storeInst,
- ModRefInfo(funcGraph.getGraphSize()))).first->second;
- minfo.setNodeIsMod(nodeId);
- modRefTable.AddDef(&storeInst);
- } else
- std::cerr << "Warning: Uninitialized pointer reference!\n";
- }
-
- // At a load instruction, add to the ref set the single node pointed to
- // by the pointer argument of the load. Interestingly, if there is no
- // such node, that would be a null pointer reference!
- void visitLoadInst(LoadInst& loadInst) {
- const DSNodeHandle& ptrNode =
- funcGraph.getNodeForValue(loadInst.getPointerOperand());
- if (const DSNode* target = ptrNode.getNode()) {
- unsigned nodeId = funcModRef.getNodeId(target);
- ModRefInfo& minfo =
- modRefTable.modRefMap.insert(
- std::make_pair(&loadInst,
- ModRefInfo(funcGraph.getGraphSize()))).first->second;
- minfo.setNodeIsRef(nodeId);
- modRefTable.AddUse(&loadInst);
- } else
- std::cerr << "Warning: Uninitialized pointer reference!\n";
- }
-};
-
-
-//----------------------------------------------------------------------------
-// class MemoryDepAnalysis: A dep. graph for load/store/call instructions
-//----------------------------------------------------------------------------
-
-
-/// getAnalysisUsage - This does not modify anything. It uses the Top-Down DS
-/// Graph and IPModRef.
-///
-void MemoryDepAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
- AU.setPreservesAll();
- AU.addRequired<TDDataStructures>();
- AU.addRequired<IPModRef>();
-}
-
-
-/// Basic dependence gathering algorithm, using scc_iterator on CFG:
-///
-/// for every SCC S in the CFG in PostOrder on the SCC DAG
-/// {
-/// for every basic block BB in S in *postorder*
-/// for every instruction I in BB in reverse
-/// Add (I, ModRef[I]) to ModRefCurrent
-/// if (Mod[I] != NULL)
-/// Add I to DefSetCurrent: { I \in S : Mod[I] != NULL }
-/// if (Ref[I] != NULL)
-/// Add I to UseSetCurrent: { I : Ref[I] != NULL }
-///
-/// for every def D in DefSetCurrent
-///
-/// // NOTE: D comes after itself iff S contains a loop
-/// if (HasLoop(S) && D & D)
-/// Add output-dep: D -> D2
-///
-/// for every def D2 *after* D in DefSetCurrent
-/// // NOTE: D2 comes before D in execution order
-/// if (D & D2)
-/// Add output-dep: D2 -> D
-/// if (HasLoop(S))
-/// Add output-dep: D -> D2
-///
-/// for every use U in UseSetCurrent that was seen *before* D
-/// // NOTE: U comes after D in execution order
-/// if (U & D)
-/// if (U != D || HasLoop(S))
-/// Add true-dep: D -> U
-/// if (HasLoop(S))
-/// Add anti-dep: U -> D
-///
-/// for every use U in UseSetCurrent that was seen *after* D
-/// // NOTE: U comes before D in execution order
-/// if (U & D)
-/// if (U != D || HasLoop(S))
-/// Add anti-dep: U -> D
-/// if (HasLoop(S))
-/// Add true-dep: D -> U
-///
-/// for every def Dnext in DefSetAfter
-/// // NOTE: Dnext comes after D in execution order
-/// if (Dnext & D)
-/// Add output-dep: D -> Dnext
-///
-/// for every use Unext in UseSetAfter
-/// // NOTE: Unext comes after D in execution order
-/// if (Unext & D)
-/// Add true-dep: D -> Unext
-///
-/// for every use U in UseSetCurrent
-/// for every def Dnext in DefSetAfter
-/// // NOTE: Dnext comes after U in execution order
-/// if (Dnext & D)
-/// Add anti-dep: U -> Dnext
-///
-/// Add ModRefCurrent to ModRefAfter: { (I, ModRef[I] ) }
-/// Add DefSetCurrent to DefSetAfter: { I : Mod[I] != NULL }
-/// Add UseSetCurrent to UseSetAfter: { I : Ref[I] != NULL }
-/// }
-///
-///
-void MemoryDepAnalysis::ProcessSCC(std::vector<BasicBlock*> &S,
- ModRefTable& ModRefAfter, bool hasLoop) {
- ModRefTable ModRefCurrent;
- ModRefTable::ModRefMap& mapCurrent = ModRefCurrent.modRefMap;
- ModRefTable::ModRefMap& mapAfter = ModRefAfter.modRefMap;
-
- // Builder class fills out a ModRefTable one instruction at a time.
- // To use it, we just invoke it's visit function for each basic block:
- //
- // for each basic block BB in the SCC in *postorder*
- // for each instruction I in BB in *reverse*
- // ModRefInfoBuilder::visit(I)
- // : Add (I, ModRef[I]) to ModRefCurrent.modRefMap
- // : Add I to ModRefCurrent.definers if it defines any node
- // : Add I to ModRefCurrent.users if it uses any node
- //
- ModRefInfoBuilder builder(*funcGraph, *funcModRef, ModRefCurrent);
- for (std::vector<BasicBlock*>::iterator BI = S.begin(), BE = S.end();
- BI != BE; ++BI)
- // Note: BBs in the SCC<> created by scc_iterator are in postorder.
- for (BasicBlock::reverse_iterator II=(*BI)->rbegin(), IE=(*BI)->rend();
- II != IE; ++II)
- builder.visit(*II);
-
- /// for every def D in DefSetCurrent
- ///
- for (ModRefTable::ref_iterator II=ModRefCurrent.defsBegin(),
- IE=ModRefCurrent.defsEnd(); II != IE; ++II)
- {
- /// // NOTE: D comes after itself iff S contains a loop
- /// if (HasLoop(S))
- /// Add output-dep: D -> D2
- if (hasLoop)
- funcDepGraph->AddSimpleDependence(**II, **II, OutputDependence);
-
- /// for every def D2 *after* D in DefSetCurrent
- /// // NOTE: D2 comes before D in execution order
- /// if (D2 & D)
- /// Add output-dep: D2 -> D
- /// if (HasLoop(S))
- /// Add output-dep: D -> D2
- for (ModRefTable::ref_iterator JI=II+1; JI != IE; ++JI)
- if (!Disjoint(mapCurrent.find(*II)->second.getModSet(),
- mapCurrent.find(*JI)->second.getModSet()))
- {
- funcDepGraph->AddSimpleDependence(**JI, **II, OutputDependence);
- if (hasLoop)
- funcDepGraph->AddSimpleDependence(**II, **JI, OutputDependence);
- }
-
- /// for every use U in UseSetCurrent that was seen *before* D
- /// // NOTE: U comes after D in execution order
- /// if (U & D)
- /// if (U != D || HasLoop(S))
- /// Add true-dep: U -> D
- /// if (HasLoop(S))
- /// Add anti-dep: D -> U
- ModRefTable::ref_iterator JI=ModRefCurrent.usersBegin();
- ModRefTable::ref_iterator JE = ModRefCurrent.usersBeforeDef_End(II);
- for ( ; JI != JE; ++JI)
- if (!Disjoint(mapCurrent.find(*II)->second.getModSet(),
- mapCurrent.find(*JI)->second.getRefSet()))
- {
- if (*II != *JI || hasLoop)
- funcDepGraph->AddSimpleDependence(**II, **JI, TrueDependence);
- if (hasLoop)
- funcDepGraph->AddSimpleDependence(**JI, **II, AntiDependence);
- }
-
- /// for every use U in UseSetCurrent that was seen *after* D
- /// // NOTE: U comes before D in execution order
- /// if (U & D)
- /// if (U != D || HasLoop(S))
- /// Add anti-dep: U -> D
- /// if (HasLoop(S))
- /// Add true-dep: D -> U
- for (/*continue JI*/ JE = ModRefCurrent.usersEnd(); JI != JE; ++JI)
- if (!Disjoint(mapCurrent.find(*II)->second.getModSet(),
- mapCurrent.find(*JI)->second.getRefSet()))
- {
- if (*II != *JI || hasLoop)
- funcDepGraph->AddSimpleDependence(**JI, **II, AntiDependence);
- if (hasLoop)
- funcDepGraph->AddSimpleDependence(**II, **JI, TrueDependence);
- }
-
- /// for every def Dnext in DefSetPrev
- /// // NOTE: Dnext comes after D in execution order
- /// if (Dnext & D)
- /// Add output-dep: D -> Dnext
- for (ModRefTable::ref_iterator JI=ModRefAfter.defsBegin(),
- JE=ModRefAfter.defsEnd(); JI != JE; ++JI)
- if (!Disjoint(mapCurrent.find(*II)->second.getModSet(),
- mapAfter.find(*JI)->second.getModSet()))
- funcDepGraph->AddSimpleDependence(**II, **JI, OutputDependence);
-
- /// for every use Unext in UseSetAfter
- /// // NOTE: Unext comes after D in execution order
- /// if (Unext & D)
- /// Add true-dep: D -> Unext
- for (ModRefTable::ref_iterator JI=ModRefAfter.usersBegin(),
- JE=ModRefAfter.usersEnd(); JI != JE; ++JI)
- if (!Disjoint(mapCurrent.find(*II)->second.getModSet(),
- mapAfter.find(*JI)->second.getRefSet()))
- funcDepGraph->AddSimpleDependence(**II, **JI, TrueDependence);
- }
-
- ///
- /// for every use U in UseSetCurrent
- /// for every def Dnext in DefSetAfter
- /// // NOTE: Dnext comes after U in execution order
- /// if (Dnext & D)
- /// Add anti-dep: U -> Dnext
- for (ModRefTable::ref_iterator II=ModRefCurrent.usersBegin(),
- IE=ModRefCurrent.usersEnd(); II != IE; ++II)
- for (ModRefTable::ref_iterator JI=ModRefAfter.defsBegin(),
- JE=ModRefAfter.defsEnd(); JI != JE; ++JI)
- if (!Disjoint(mapCurrent.find(*II)->second.getRefSet(),
- mapAfter.find(*JI)->second.getModSet()))
- funcDepGraph->AddSimpleDependence(**II, **JI, AntiDependence);
-
- /// Add ModRefCurrent to ModRefAfter: { (I, ModRef[I] ) }
- /// Add DefSetCurrent to DefSetAfter: { I : Mod[I] != NULL }
- /// Add UseSetCurrent to UseSetAfter: { I : Ref[I] != NULL }
- ModRefAfter.Insert(ModRefCurrent);
-}
-
-
-/// Debugging support methods
-///
-void MemoryDepAnalysis::print(std::ostream &O) const
-{
- // TEMPORARY LOOP
- for (hash_map<Function*, DependenceGraph*>::const_iterator
- I = funcMap.begin(), E = funcMap.end(); I != E; ++I)
- {
- Function* func = I->first;
- DependenceGraph* depGraph = I->second;
-
- O << "\n================================================================\n";
- O << "DEPENDENCE GRAPH FOR MEMORY OPERATIONS IN FUNCTION " << func->getName();
- O << "\n================================================================\n\n";
- depGraph->print(*func, O);
-
- }
-}
-
-
-///
-/// Run the pass on a function
-///
-bool MemoryDepAnalysis::runOnFunction(Function &F) {
- assert(!F.isExternal());
-
- // Get the FunctionModRefInfo holding IPModRef results for this function.
- // Use the TD graph recorded within the FunctionModRefInfo object, which
- // may not be the same as the original TD graph computed by DS analysis.
- //
- funcModRef = &getAnalysis<IPModRef>().getFunctionModRefInfo(F);
- funcGraph = &funcModRef->getFuncGraph();
-
- // TEMPORARY: ptr to depGraph (later just becomes "this").
- assert(!funcMap.count(&F) && "Analyzing function twice?");
- funcDepGraph = funcMap[&F] = new DependenceGraph();
-
- ModRefTable ModRefAfter;
-
- for (scc_iterator<Function*> I = scc_begin(&F), E = scc_end(&F); I != E; ++I)
- ProcessSCC(*I, ModRefAfter, I.hasLoop());
-
- return true;
-}
-
-
-//-------------------------------------------------------------------------
-// TEMPORARY FUNCTIONS TO MAKE THIS A MODULE PASS ---
-// These functions will go away once this class becomes a FunctionPass.
-//
-
-// Driver function to compute dependence graphs for every function.
-// This is temporary and will go away once this is a FunctionPass.
-//
-bool MemoryDepAnalysis::run(Module& M)
-{
- for (Module::iterator FI = M.begin(), FE = M.end(); FI != FE; ++FI)
- if (! FI->isExternal())
- runOnFunction(*FI); // automatically inserts each depGraph into funcMap
- return true;
-}
-
-// Release all the dependence graphs in the map.
-void MemoryDepAnalysis::releaseMemory()
-{
- for (hash_map<Function*, DependenceGraph*>::const_iterator
- I = funcMap.begin(), E = funcMap.end(); I != E; ++I)
- delete I->second;
- funcMap.clear();
-
- // Clear pointers because the pass constructor will not be invoked again.
- funcDepGraph = NULL;
- funcGraph = NULL;
- funcModRef = NULL;
-}
-
-MemoryDepAnalysis::~MemoryDepAnalysis()
-{
- releaseMemory();
-}
-
-//----END TEMPORARY FUNCTIONS----------------------------------------------
-
-
-void MemoryDepAnalysis::dump() const
-{
- this->print(std::cerr);
-}
-
-static RegisterAnalysis<MemoryDepAnalysis>
-Z("memdep", "Memory Dependence Analysis");
-
-
-} // End llvm namespace
projects / oota-llvm.git / commitdiff