mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-19 04:29:21 +00:00
Files depend on DSA, moved to lib/Analysis/DataStructure
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14326 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
e5d6dab09e
commit
bab75268f0
@ -1,447 +0,0 @@
|
||||
//===- 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
|
@ -1,500 +0,0 @@
|
||||
//===- 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
|
Loading…
Reference in New Issue
Block a user