mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 19:23:23 +01:00
2a8b1d4992
units. This was debated back and forth a bunch, but using references is now clearly cleaner. Of all the code written using pointers thus far, in only one place did it really make more sense to have a pointer. In most cases, this just removes immediate dereferencing from the code. I think it is much better to get errors on null IR units earlier, potentially at compile time, than to delay it. Most notably, the legacy pass manager uses references for its routines and so as more and more code works with both, the use of pointers was likely to become really annoying. I noticed this when I ported the domtree analysis over and wrote the entire thing with references only to have it fail to compile. =/ It seemed better to switch now than to delay. We can, of course, revisit this is we learn that references are really problematic in the API. llvm-svn: 225145
128 lines
3.7 KiB
C++
128 lines
3.7 KiB
C++
//===--- IRPrintingPasses.cpp - Module and Function printing passes -------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// PrintModulePass and PrintFunctionPass implementations.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/IR/IRPrintingPasses.h"
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/IR/PassManager.h"
|
|
#include "llvm/Pass.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
using namespace llvm;
|
|
|
|
PrintModulePass::PrintModulePass() : OS(dbgs()) {}
|
|
PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner)
|
|
: OS(OS), Banner(Banner) {}
|
|
|
|
PreservedAnalyses PrintModulePass::run(Module &M) {
|
|
OS << Banner << M;
|
|
return PreservedAnalyses::all();
|
|
}
|
|
|
|
PrintFunctionPass::PrintFunctionPass() : OS(dbgs()) {}
|
|
PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
|
|
: OS(OS), Banner(Banner) {}
|
|
|
|
PreservedAnalyses PrintFunctionPass::run(Function &F) {
|
|
OS << Banner << static_cast<Value &>(F);
|
|
return PreservedAnalyses::all();
|
|
}
|
|
|
|
namespace {
|
|
|
|
class PrintModulePassWrapper : public ModulePass {
|
|
PrintModulePass P;
|
|
|
|
public:
|
|
static char ID;
|
|
PrintModulePassWrapper() : ModulePass(ID) {}
|
|
PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner)
|
|
: ModulePass(ID), P(OS, Banner) {}
|
|
|
|
bool runOnModule(Module &M) override {
|
|
P.run(M);
|
|
return false;
|
|
}
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.setPreservesAll();
|
|
}
|
|
};
|
|
|
|
class PrintFunctionPassWrapper : public FunctionPass {
|
|
PrintFunctionPass P;
|
|
|
|
public:
|
|
static char ID;
|
|
PrintFunctionPassWrapper() : FunctionPass(ID) {}
|
|
PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
|
|
: FunctionPass(ID), P(OS, Banner) {}
|
|
|
|
// This pass just prints a banner followed by the function as it's processed.
|
|
bool runOnFunction(Function &F) override {
|
|
P.run(F);
|
|
return false;
|
|
}
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.setPreservesAll();
|
|
}
|
|
};
|
|
|
|
class PrintBasicBlockPass : public BasicBlockPass {
|
|
raw_ostream &Out;
|
|
std::string Banner;
|
|
|
|
public:
|
|
static char ID;
|
|
PrintBasicBlockPass() : BasicBlockPass(ID), Out(dbgs()) {}
|
|
PrintBasicBlockPass(raw_ostream &Out, const std::string &Banner)
|
|
: BasicBlockPass(ID), Out(Out), Banner(Banner) {}
|
|
|
|
bool runOnBasicBlock(BasicBlock &BB) override {
|
|
Out << Banner << BB;
|
|
return false;
|
|
}
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.setPreservesAll();
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
char PrintModulePassWrapper::ID = 0;
|
|
INITIALIZE_PASS(PrintModulePassWrapper, "print-module",
|
|
"Print module to stderr", false, false)
|
|
char PrintFunctionPassWrapper::ID = 0;
|
|
INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function",
|
|
"Print function to stderr", false, false)
|
|
char PrintBasicBlockPass::ID = 0;
|
|
INITIALIZE_PASS(PrintBasicBlockPass, "print-bb", "Print BB to stderr", false,
|
|
false)
|
|
|
|
ModulePass *llvm::createPrintModulePass(llvm::raw_ostream &OS,
|
|
const std::string &Banner) {
|
|
return new PrintModulePassWrapper(OS, Banner);
|
|
}
|
|
|
|
FunctionPass *llvm::createPrintFunctionPass(llvm::raw_ostream &OS,
|
|
const std::string &Banner) {
|
|
return new PrintFunctionPassWrapper(OS, Banner);
|
|
}
|
|
|
|
BasicBlockPass *llvm::createPrintBasicBlockPass(llvm::raw_ostream &OS,
|
|
const std::string &Banner) {
|
|
return new PrintBasicBlockPass(OS, Banner);
|
|
}
|