mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-15 20:29:48 +00:00
46b30b8252
Make use of the newly introduced inst_range to clean up two loops. Clean up a third one while at it. Differential Revision: http://reviews.llvm.org/D7455 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@228596 91177308-0d34-0410-b5e6-96231b3b80d8
169 lines
5.2 KiB
C++
169 lines
5.2 KiB
C++
//===- MemDepPrinter.cpp - Printer for MemoryDependenceAnalysis -----------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Analysis/Passes.h"
|
|
#include "llvm/ADT/SetVector.h"
|
|
#include "llvm/Analysis/MemoryDependenceAnalysis.h"
|
|
#include "llvm/IR/CallSite.h"
|
|
#include "llvm/IR/InstIterator.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
struct MemDepPrinter : public FunctionPass {
|
|
const Function *F;
|
|
|
|
enum DepType {
|
|
Clobber = 0,
|
|
Def,
|
|
NonFuncLocal,
|
|
Unknown
|
|
};
|
|
|
|
static const char *const DepTypeStr[];
|
|
|
|
typedef PointerIntPair<const Instruction *, 2, DepType> InstTypePair;
|
|
typedef std::pair<InstTypePair, const BasicBlock *> Dep;
|
|
typedef SmallSetVector<Dep, 4> DepSet;
|
|
typedef DenseMap<const Instruction *, DepSet> DepSetMap;
|
|
DepSetMap Deps;
|
|
|
|
static char ID; // Pass identifcation, replacement for typeid
|
|
MemDepPrinter() : FunctionPass(ID) {
|
|
initializeMemDepPrinterPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
bool runOnFunction(Function &F) override;
|
|
|
|
void print(raw_ostream &OS, const Module * = nullptr) const override;
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.addRequiredTransitive<AliasAnalysis>();
|
|
AU.addRequiredTransitive<MemoryDependenceAnalysis>();
|
|
AU.setPreservesAll();
|
|
}
|
|
|
|
void releaseMemory() override {
|
|
Deps.clear();
|
|
F = nullptr;
|
|
}
|
|
|
|
private:
|
|
static InstTypePair getInstTypePair(MemDepResult dep) {
|
|
if (dep.isClobber())
|
|
return InstTypePair(dep.getInst(), Clobber);
|
|
if (dep.isDef())
|
|
return InstTypePair(dep.getInst(), Def);
|
|
if (dep.isNonFuncLocal())
|
|
return InstTypePair(dep.getInst(), NonFuncLocal);
|
|
assert(dep.isUnknown() && "unexpected dependence type");
|
|
return InstTypePair(dep.getInst(), Unknown);
|
|
}
|
|
static InstTypePair getInstTypePair(const Instruction* inst, DepType type) {
|
|
return InstTypePair(inst, type);
|
|
}
|
|
};
|
|
}
|
|
|
|
char MemDepPrinter::ID = 0;
|
|
INITIALIZE_PASS_BEGIN(MemDepPrinter, "print-memdeps",
|
|
"Print MemDeps of function", false, true)
|
|
INITIALIZE_PASS_DEPENDENCY(MemoryDependenceAnalysis)
|
|
INITIALIZE_PASS_END(MemDepPrinter, "print-memdeps",
|
|
"Print MemDeps of function", false, true)
|
|
|
|
FunctionPass *llvm::createMemDepPrinter() {
|
|
return new MemDepPrinter();
|
|
}
|
|
|
|
const char *const MemDepPrinter::DepTypeStr[]
|
|
= {"Clobber", "Def", "NonFuncLocal", "Unknown"};
|
|
|
|
bool MemDepPrinter::runOnFunction(Function &F) {
|
|
this->F = &F;
|
|
MemoryDependenceAnalysis &MDA = getAnalysis<MemoryDependenceAnalysis>();
|
|
|
|
// All this code uses non-const interfaces because MemDep is not
|
|
// const-friendly, though nothing is actually modified.
|
|
for (auto &I: inst_range(F)) {
|
|
Instruction *Inst = &I;
|
|
|
|
if (!Inst->mayReadFromMemory() && !Inst->mayWriteToMemory())
|
|
continue;
|
|
|
|
MemDepResult Res = MDA.getDependency(Inst);
|
|
if (!Res.isNonLocal()) {
|
|
Deps[Inst].insert(std::make_pair(getInstTypePair(Res),
|
|
static_cast<BasicBlock *>(nullptr)));
|
|
} else if (CallSite CS = cast<Value>(Inst)) {
|
|
const MemoryDependenceAnalysis::NonLocalDepInfo &NLDI =
|
|
MDA.getNonLocalCallDependency(CS);
|
|
|
|
DepSet &InstDeps = Deps[Inst];
|
|
for (MemoryDependenceAnalysis::NonLocalDepInfo::const_iterator
|
|
I = NLDI.begin(), E = NLDI.end(); I != E; ++I) {
|
|
const MemDepResult &Res = I->getResult();
|
|
InstDeps.insert(std::make_pair(getInstTypePair(Res), I->getBB()));
|
|
}
|
|
} else {
|
|
SmallVector<NonLocalDepResult, 4> NLDI;
|
|
assert( (isa<LoadInst>(Inst) || isa<StoreInst>(Inst) ||
|
|
isa<VAArgInst>(Inst)) && "Unknown memory instruction!");
|
|
MDA.getNonLocalPointerDependency(Inst, NLDI);
|
|
|
|
DepSet &InstDeps = Deps[Inst];
|
|
for (SmallVectorImpl<NonLocalDepResult>::const_iterator
|
|
I = NLDI.begin(), E = NLDI.end(); I != E; ++I) {
|
|
const MemDepResult &Res = I->getResult();
|
|
InstDeps.insert(std::make_pair(getInstTypePair(Res), I->getBB()));
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void MemDepPrinter::print(raw_ostream &OS, const Module *M) const {
|
|
for (auto &I: inst_range(*F)) {
|
|
const Instruction *Inst = &I;
|
|
|
|
DepSetMap::const_iterator DI = Deps.find(Inst);
|
|
if (DI == Deps.end())
|
|
continue;
|
|
|
|
const DepSet &InstDeps = DI->second;
|
|
|
|
for (auto &I: InstDeps) {
|
|
const Instruction *DepInst = I.first.getPointer();
|
|
DepType type = I.first.getInt();
|
|
const BasicBlock *DepBB = I.second;
|
|
|
|
OS << " ";
|
|
OS << DepTypeStr[type];
|
|
if (DepBB) {
|
|
OS << " in block ";
|
|
DepBB->printAsOperand(OS, /*PrintType=*/false, M);
|
|
}
|
|
if (DepInst) {
|
|
OS << " from: ";
|
|
DepInst->print(OS);
|
|
}
|
|
OS << "\n";
|
|
}
|
|
|
|
Inst->print(OS);
|
|
OS << "\n\n";
|
|
}
|
|
}
|