mirror of
https://github.com/RPCS3/llvm.git
synced 2024-12-28 15:33:16 +00:00
a59525786d
This implements the legacy passes in terms of the new ones. It adds basic testing using explicit runs of the passes. Next up will be wiring the basic output mechanism of opt up when the new pass manager is engaged unless bitcode writing is requested. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199049 91177308-0d34-0410-b5e6-96231b3b80d8
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) {
|
|
P.run(&M);
|
|
return false;
|
|
}
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
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) {
|
|
P.run(&F);
|
|
return false;
|
|
}
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
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) {
|
|
Out << Banner << BB;
|
|
return false;
|
|
}
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
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);
|
|
}
|