mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 18:29:46 +00:00
Revert 100204. It broke a bunch of tests and apparently changed what passes are run during codegen.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100207 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
d0327f80ec
commit
cf5862d8ac
@ -31,10 +31,6 @@ public:
|
||||
explicit LoopPass(intptr_t pid) : Pass(PT_Loop, pid) {}
|
||||
explicit LoopPass(void *pid) : Pass(PT_Loop, pid) {}
|
||||
|
||||
/// getPrinterPass - Get a pass to print the function corresponding
|
||||
/// to a Loop.
|
||||
Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const;
|
||||
|
||||
// runOnLoop - This method should be implemented by the subclass to perform
|
||||
// whatever action is necessary for the specified Loop.
|
||||
virtual bool runOnLoop(Loop *L, LPPassManager &LPM) = 0;
|
||||
|
@ -27,9 +27,7 @@ namespace llvm {
|
||||
|
||||
/// createPrintModulePass - Create and return a pass that writes the
|
||||
/// module to the specified raw_ostream.
|
||||
ModulePass *createPrintModulePass(raw_ostream *OS,
|
||||
bool DeleteStream=false,
|
||||
const std::string &Banner = "");
|
||||
ModulePass *createPrintModulePass(raw_ostream *OS, bool DeleteStream=false);
|
||||
|
||||
/// createPrintFunctionPass - Create and return a pass that prints
|
||||
/// functions to the specified raw_ostream as they are processed.
|
||||
|
@ -35,10 +35,6 @@ struct CallGraphSCCPass : public Pass {
|
||||
explicit CallGraphSCCPass(intptr_t pid) : Pass(PT_CallGraphSCC, pid) {}
|
||||
explicit CallGraphSCCPass(void *pid) : Pass(PT_CallGraphSCC, pid) {}
|
||||
|
||||
/// createPrinterPass - Get a pass that prints the Module
|
||||
/// corresponding to a CallGraph.
|
||||
Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const;
|
||||
|
||||
/// doInitialization - This method is called before the SCC's of the program
|
||||
/// has been processed, allowing the pass to do initialization as necessary.
|
||||
virtual bool doInitialization(CallGraph &CG) {
|
||||
|
@ -34,9 +34,6 @@ protected:
|
||||
explicit MachineFunctionPass(intptr_t ID) : FunctionPass(ID) {}
|
||||
explicit MachineFunctionPass(void *ID) : FunctionPass(ID) {}
|
||||
|
||||
/// createPrinterPass - Get a machine function printer pass.
|
||||
Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const;
|
||||
|
||||
/// runOnMachineFunction - This method must be overloaded to perform the
|
||||
/// desired machine code transformation or analysis.
|
||||
///
|
||||
|
@ -21,7 +21,6 @@
|
||||
namespace llvm {
|
||||
|
||||
class FunctionPass;
|
||||
class MachineFunctionPass;
|
||||
class PassInfo;
|
||||
class TargetLowering;
|
||||
class RegisterCoalescer;
|
||||
@ -37,8 +36,7 @@ namespace llvm {
|
||||
|
||||
/// MachineFunctionPrinter pass - This pass prints out the machine function to
|
||||
/// the given stream, as a debugging tool.
|
||||
MachineFunctionPass *
|
||||
createMachineFunctionPrinterPass(raw_ostream &OS,
|
||||
FunctionPass *createMachineFunctionPrinterPass(raw_ostream &OS,
|
||||
const std::string &Banner ="");
|
||||
|
||||
/// MachineLoopInfo pass - This pass is a loop analysis pass.
|
||||
|
@ -30,9 +30,7 @@
|
||||
#define LLVM_PASS_H
|
||||
|
||||
#include "llvm/System/DataTypes.h"
|
||||
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
@ -122,11 +120,6 @@ public:
|
||||
virtual void print(raw_ostream &O, const Module *M) const;
|
||||
void dump() const; // dump - Print to stderr.
|
||||
|
||||
/// createPrinterPass - Get a Pass appropriate to print the IR this
|
||||
/// pass operates one (Module, Function or MachineFunction).
|
||||
virtual Pass *createPrinterPass(raw_ostream &O,
|
||||
const std::string &Banner) const = 0;
|
||||
|
||||
/// Each pass is responsible for assigning a pass manager to itself.
|
||||
/// PMS is the stack of available pass manager.
|
||||
virtual void assignPassManager(PMStack &,
|
||||
@ -240,9 +233,6 @@ public:
|
||||
///
|
||||
class ModulePass : public Pass {
|
||||
public:
|
||||
/// createPrinterPass - Get a module printer pass.
|
||||
Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const;
|
||||
|
||||
/// runOnModule - Virtual method overriden by subclasses to process the module
|
||||
/// being operated on.
|
||||
virtual bool runOnModule(Module &M) = 0;
|
||||
@ -303,9 +293,6 @@ public:
|
||||
explicit FunctionPass(intptr_t pid) : Pass(PT_Function, pid) {}
|
||||
explicit FunctionPass(const void *pid) : Pass(PT_Function, pid) {}
|
||||
|
||||
/// createPrinterPass - Get a function printer pass.
|
||||
Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const;
|
||||
|
||||
/// doInitialization - Virtual method overridden by subclasses to do
|
||||
/// any necessary per-module initialization.
|
||||
///
|
||||
@ -356,9 +343,6 @@ public:
|
||||
explicit BasicBlockPass(intptr_t pid) : Pass(PT_BasicBlock, pid) {}
|
||||
explicit BasicBlockPass(const void *pid) : Pass(PT_BasicBlock, pid) {}
|
||||
|
||||
/// createPrinterPass - Get a function printer pass.
|
||||
Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const;
|
||||
|
||||
/// doInitialization - Virtual method overridden by subclasses to do
|
||||
/// any necessary per-module initialization.
|
||||
///
|
||||
|
@ -87,40 +87,10 @@ private:
|
||||
bool IsCheckingMode);
|
||||
};
|
||||
|
||||
/// PrintCallGraphPass - Print a Module corresponding to a call graph.
|
||||
///
|
||||
class PrintCallGraphPass : public CallGraphSCCPass {
|
||||
private:
|
||||
std::string Banner;
|
||||
raw_ostream &Out; // raw_ostream to print on.
|
||||
|
||||
public:
|
||||
static char ID;
|
||||
PrintCallGraphPass() : CallGraphSCCPass(&ID), Out(dbgs()) {}
|
||||
PrintCallGraphPass(const std::string &B, raw_ostream &o)
|
||||
: CallGraphSCCPass(&ID), Banner(B), Out(o) {}
|
||||
|
||||
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
AU.setPreservesAll();
|
||||
}
|
||||
|
||||
bool runOnSCC(std::vector<CallGraphNode *> &SCC) {
|
||||
Out << Banner;
|
||||
for (std::vector<CallGraphNode *>::iterator n = SCC.begin(), ne = SCC.end();
|
||||
n != ne;
|
||||
++n) {
|
||||
(*n)->getFunction()->print(Out);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
} // end anonymous namespace.
|
||||
|
||||
char CGPassManager::ID = 0;
|
||||
|
||||
char PrintCallGraphPass::ID = 0;
|
||||
|
||||
bool CGPassManager::RunPassOnSCC(Pass *P, std::vector<CallGraphNode*> &CurSCC,
|
||||
CallGraph &CG, bool &CallGraphUpToDate) {
|
||||
bool Changed = false;
|
||||
@ -426,11 +396,6 @@ bool CGPassManager::doFinalization(CallGraph &CG) {
|
||||
return Changed;
|
||||
}
|
||||
|
||||
Pass *CallGraphSCCPass::createPrinterPass(raw_ostream &O,
|
||||
const std::string &Banner) const {
|
||||
return new PrintCallGraphPass(Banner, O);
|
||||
}
|
||||
|
||||
/// Assign pass manager to manage this pass.
|
||||
void CallGraphSCCPass::assignPassManager(PMStack &PMS,
|
||||
PassManagerType PreferredType) {
|
||||
|
@ -14,44 +14,9 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Analysis/LoopPass.h"
|
||||
#include "llvm/Assembly/PrintModulePass.h"
|
||||
#include "llvm/Support/Debug.h"
|
||||
#include "llvm/Support/Timer.h"
|
||||
using namespace llvm;
|
||||
|
||||
namespace {
|
||||
|
||||
/// PrintLoopPass - Print a Function corresponding to a Loop.
|
||||
///
|
||||
class PrintLoopPass : public LoopPass {
|
||||
private:
|
||||
std::string Banner;
|
||||
raw_ostream &Out; // raw_ostream to print on.
|
||||
|
||||
public:
|
||||
static char ID;
|
||||
PrintLoopPass() : LoopPass(&ID), Out(dbgs()) {}
|
||||
PrintLoopPass(const std::string &B, raw_ostream &o)
|
||||
: LoopPass(&ID), Banner(B), Out(o) {}
|
||||
|
||||
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
AU.setPreservesAll();
|
||||
}
|
||||
|
||||
bool runOnLoop(Loop *L, LPPassManager &) {
|
||||
Out << Banner;
|
||||
for (Loop::block_iterator b = L->block_begin(), be = L->block_end();
|
||||
b != be;
|
||||
++b) {
|
||||
(*b)->print(Out);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
char PrintLoopPass::ID = 0;
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// LPPassManager
|
||||
//
|
||||
@ -341,11 +306,6 @@ void LPPassManager::dumpPassStructure(unsigned Offset) {
|
||||
//===----------------------------------------------------------------------===//
|
||||
// LoopPass
|
||||
|
||||
Pass *LoopPass::createPrinterPass(raw_ostream &O,
|
||||
const std::string &Banner) const {
|
||||
return new PrintLoopPass(Banner, O);
|
||||
}
|
||||
|
||||
// Check if this pass is suitable for the current LPPassManager, if
|
||||
// available. This pass P is not suitable for a LPPassManager if P
|
||||
// is not preserving higher level analysis info used by other
|
||||
|
@ -39,6 +39,40 @@
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
using namespace llvm;
|
||||
|
||||
namespace {
|
||||
struct Printer : public MachineFunctionPass {
|
||||
static char ID;
|
||||
|
||||
raw_ostream &OS;
|
||||
const std::string Banner;
|
||||
|
||||
Printer(raw_ostream &os, const std::string &banner)
|
||||
: MachineFunctionPass(&ID), OS(os), Banner(banner) {}
|
||||
|
||||
const char *getPassName() const { return "MachineFunction Printer"; }
|
||||
|
||||
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
AU.setPreservesAll();
|
||||
MachineFunctionPass::getAnalysisUsage(AU);
|
||||
}
|
||||
|
||||
bool runOnMachineFunction(MachineFunction &MF) {
|
||||
OS << "# " << Banner << ":\n";
|
||||
MF.print(OS);
|
||||
return false;
|
||||
}
|
||||
};
|
||||
char Printer::ID = 0;
|
||||
}
|
||||
|
||||
/// Returns a newly-created MachineFunction Printer pass. The default banner is
|
||||
/// empty.
|
||||
///
|
||||
FunctionPass *llvm::createMachineFunctionPrinterPass(raw_ostream &OS,
|
||||
const std::string &Banner){
|
||||
return new Printer(OS, Banner);
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// MachineFunction implementation
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
@ -15,14 +15,8 @@
|
||||
#include "llvm/Analysis/AliasAnalysis.h"
|
||||
#include "llvm/CodeGen/MachineFunctionAnalysis.h"
|
||||
#include "llvm/CodeGen/MachineFunctionPass.h"
|
||||
#include "llvm/CodeGen/Passes.h"
|
||||
using namespace llvm;
|
||||
|
||||
Pass *MachineFunctionPass::createPrinterPass(raw_ostream &O,
|
||||
const std::string &Banner) const {
|
||||
return createMachineFunctionPrinterPass(O, Banner);
|
||||
}
|
||||
|
||||
bool MachineFunctionPass::runOnFunction(Function &F) {
|
||||
// Do not codegen any 'available_externally' functions at all, they have
|
||||
// definitions outside the translation unit.
|
||||
|
@ -1,60 +0,0 @@
|
||||
//===-- MachineFunctionPrinterPass.cpp ------------------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// MachineFunctionPrinterPass implementation.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/CodeGen/Passes.h"
|
||||
#include "llvm/CodeGen/MachineFunctionPass.h"
|
||||
#include "llvm/CodeGen/MachineFunction.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
|
||||
using namespace llvm;
|
||||
|
||||
namespace {
|
||||
/// MachineFunctionPrinterPass - This is a pass to dump the IR of a
|
||||
/// MachineFunction.
|
||||
///
|
||||
struct MachineFunctionPrinterPass : public MachineFunctionPass {
|
||||
static char ID;
|
||||
|
||||
raw_ostream &OS;
|
||||
const std::string Banner;
|
||||
|
||||
MachineFunctionPrinterPass(raw_ostream &os, const std::string &banner)
|
||||
: MachineFunctionPass(&ID), OS(os), Banner(banner) {}
|
||||
|
||||
const char *getPassName() const { return "MachineFunction Printer"; }
|
||||
|
||||
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
AU.setPreservesAll();
|
||||
MachineFunctionPass::getAnalysisUsage(AU);
|
||||
}
|
||||
|
||||
bool runOnMachineFunction(MachineFunction &MF) {
|
||||
OS << "# " << Banner << ":\n";
|
||||
MF.print(OS);
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
char MachineFunctionPrinterPass::ID = 0;
|
||||
}
|
||||
|
||||
namespace llvm {
|
||||
/// Returns a newly-created MachineFunction Printer pass. The
|
||||
/// default banner is empty.
|
||||
///
|
||||
MachineFunctionPass *createMachineFunctionPrinterPass(raw_ostream &OS,
|
||||
const std::string &Banner){
|
||||
return new MachineFunctionPrinterPass(OS, Banner);
|
||||
}
|
||||
|
||||
}
|
@ -18,7 +18,6 @@
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/ADT/StringMap.h"
|
||||
#include "llvm/Assembly/PrintModulePass.h"
|
||||
#include "llvm/Support/Debug.h"
|
||||
#include "llvm/Support/ManagedStatic.h"
|
||||
#include "llvm/Support/PassNameParser.h"
|
||||
@ -43,11 +42,6 @@ Pass::~Pass() {
|
||||
// Force out-of-line virtual method.
|
||||
ModulePass::~ModulePass() { }
|
||||
|
||||
Pass *ModulePass::createPrinterPass(raw_ostream &O,
|
||||
const std::string &Banner) const {
|
||||
return createPrintModulePass(&O, false, Banner);
|
||||
}
|
||||
|
||||
PassManagerType ModulePass::getPotentialPassManagerType() const {
|
||||
return PMT_ModulePassManager;
|
||||
}
|
||||
@ -119,11 +113,6 @@ void ImmutablePass::initializePass() {
|
||||
// FunctionPass Implementation
|
||||
//
|
||||
|
||||
Pass *FunctionPass::createPrinterPass(raw_ostream &O,
|
||||
const std::string &Banner) const {
|
||||
return createPrintFunctionPass(Banner, &O);
|
||||
}
|
||||
|
||||
// run - On a module, we run this pass by initializing, runOnFunction'ing once
|
||||
// for every function in the module, then by finalizing.
|
||||
//
|
||||
@ -166,13 +155,6 @@ PassManagerType FunctionPass::getPotentialPassManagerType() const {
|
||||
// BasicBlockPass Implementation
|
||||
//
|
||||
|
||||
Pass *BasicBlockPass::createPrinterPass(raw_ostream &O,
|
||||
const std::string &Banner) const {
|
||||
|
||||
llvm_unreachable("BasicBlockPass printing unsupported.");
|
||||
return 0;
|
||||
}
|
||||
|
||||
// To run this pass on a function, we simply call runOnBasicBlock once for each
|
||||
// function.
|
||||
//
|
||||
|
@ -13,7 +13,6 @@
|
||||
|
||||
|
||||
#include "llvm/PassManagers.h"
|
||||
#include "llvm/Assembly/PrintModulePass.h"
|
||||
#include "llvm/Assembly/Writer.h"
|
||||
#include "llvm/Support/CommandLine.h"
|
||||
#include "llvm/Support/Debug.h"
|
||||
@ -21,7 +20,6 @@
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/ManagedStatic.h"
|
||||
#include "llvm/Support/PassNameParser.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include "llvm/System/Mutex.h"
|
||||
#include "llvm/System/Threading.h"
|
||||
@ -57,57 +55,6 @@ PassDebugging("debug-pass", cl::Hidden,
|
||||
clEnumVal(Executions, "print pass name before it is executed"),
|
||||
clEnumVal(Details , "print pass details when it is executed"),
|
||||
clEnumValEnd));
|
||||
|
||||
typedef llvm::cl::list<const llvm::PassInfo *, bool, PassNameParser>
|
||||
PassOptionList;
|
||||
|
||||
// Print IR out before/after specified passes.
|
||||
static PassOptionList
|
||||
PrintBefore("print-before",
|
||||
llvm::cl::desc("Print IR before specified passes"));
|
||||
|
||||
static PassOptionList
|
||||
PrintAfter("print-after",
|
||||
llvm::cl::desc("Print IR after specified passes"));
|
||||
|
||||
static cl::opt<bool>
|
||||
PrintBeforeAll("print-before-all",
|
||||
llvm::cl::desc("Print IR before each pass"),
|
||||
cl::init(false));
|
||||
static cl::opt<bool>
|
||||
PrintAfterAll("print-after-all",
|
||||
llvm::cl::desc("Print IR after each pass"),
|
||||
cl::init(false));
|
||||
|
||||
/// This is a helper to determine whether to print IR before or
|
||||
/// after a pass.
|
||||
|
||||
static bool ShouldPrintBeforeOrAfterPass(Pass *P,
|
||||
PassOptionList &PassesToPrint) {
|
||||
for (unsigned i = 0, ie = PassesToPrint.size(); i < ie; ++i) {
|
||||
const llvm::PassInfo *PassInf = PassesToPrint[i];
|
||||
if (PassInf && P->getPassInfo())
|
||||
if (PassInf->getPassArgument() ==
|
||||
P->getPassInfo()->getPassArgument()) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/// This is a utility to check whether a pass should have IR dumped
|
||||
/// before it.
|
||||
static bool ShouldPrintBeforePass(Pass *P) {
|
||||
return PrintBeforeAll || ShouldPrintBeforeOrAfterPass(P, PrintBefore);
|
||||
}
|
||||
|
||||
/// This is a utility to check whether a pass should have IR dumped
|
||||
/// after it.
|
||||
static bool ShouldPrintAfterPass(Pass *P) {
|
||||
return PrintAfterAll || ShouldPrintBeforeOrAfterPass(P, PrintAfter);
|
||||
}
|
||||
|
||||
} // End of llvm namespace
|
||||
|
||||
/// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions
|
||||
@ -235,11 +182,6 @@ public:
|
||||
schedulePass(P);
|
||||
}
|
||||
|
||||
/// createPrinterPass - Get a function printer pass.
|
||||
Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const {
|
||||
return createPrintFunctionPass(Banner, &O);
|
||||
}
|
||||
|
||||
// Prepare for running an on the fly pass, freeing memory if needed
|
||||
// from a previous run.
|
||||
void releaseMemoryOnTheFly();
|
||||
@ -310,11 +252,6 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
/// createPrinterPass - Get a module printer pass.
|
||||
Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const {
|
||||
return createPrintModulePass(&O, false, Banner);
|
||||
}
|
||||
|
||||
/// run - Execute all of the passes scheduled for execution. Keep track of
|
||||
/// whether any of the passes modifies the module, and if so, return true.
|
||||
bool runOnModule(Module &M);
|
||||
@ -394,11 +331,6 @@ public:
|
||||
schedulePass(P);
|
||||
}
|
||||
|
||||
/// createPrinterPass - Get a module printer pass.
|
||||
Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const {
|
||||
return createPrintModulePass(&O, false, Banner);
|
||||
}
|
||||
|
||||
/// run - Execute all of the passes scheduled for execution. Keep track of
|
||||
/// whether any of the passes modifies the module, and if so, return true.
|
||||
bool run(Module &M);
|
||||
@ -1276,14 +1208,7 @@ FunctionPassManager::~FunctionPassManager() {
|
||||
/// there is no need to delete the pass. (TODO delete passes.)
|
||||
/// This implies that all passes MUST be allocated with 'new'.
|
||||
void FunctionPassManager::add(Pass *P) {
|
||||
if (ShouldPrintBeforePass(P))
|
||||
add(P->createPrinterPass(dbgs(), std::string("*** IR Dump Before ")
|
||||
+ P->getPassName() + " ***"));
|
||||
FPM->add(P);
|
||||
|
||||
if (ShouldPrintAfterPass(P))
|
||||
add(P->createPrinterPass(dbgs(), std::string("*** IR Dump After ")
|
||||
+ P->getPassName() + " ***"));
|
||||
}
|
||||
|
||||
/// run - Execute all of the passes scheduled for execution. Keep
|
||||
@ -1594,15 +1519,7 @@ PassManager::~PassManager() {
|
||||
/// will be destroyed as well, so there is no need to delete the pass. This
|
||||
/// implies that all passes MUST be allocated with 'new'.
|
||||
void PassManager::add(Pass *P) {
|
||||
if (ShouldPrintBeforePass(P))
|
||||
add(P->createPrinterPass(dbgs(), std::string("*** IR Dump Before ")
|
||||
+ P->getPassName() + " ***"));
|
||||
|
||||
PM->add(P);
|
||||
|
||||
if (ShouldPrintAfterPass(P))
|
||||
add(P->createPrinterPass(dbgs(), std::string("*** IR Dump After ")
|
||||
+ P->getPassName() + " ***"));
|
||||
}
|
||||
|
||||
/// run - Execute all of the passes scheduled for execution. Keep track of
|
||||
|
@ -23,22 +23,21 @@ using namespace llvm;
|
||||
namespace {
|
||||
|
||||
class PrintModulePass : public ModulePass {
|
||||
std::string Banner;
|
||||
raw_ostream *Out; // raw_ostream to print on
|
||||
bool DeleteStream; // Delete the ostream in our dtor?
|
||||
public:
|
||||
static char ID;
|
||||
PrintModulePass() : ModulePass(&ID), Out(&dbgs()),
|
||||
DeleteStream(false) {}
|
||||
PrintModulePass(const std::string &B, raw_ostream *o, bool DS)
|
||||
: ModulePass(&ID), Banner(B), Out(o), DeleteStream(DS) {}
|
||||
PrintModulePass(raw_ostream *o, bool DS)
|
||||
: ModulePass(&ID), Out(o), DeleteStream(DS) {}
|
||||
|
||||
~PrintModulePass() {
|
||||
if (DeleteStream) delete Out;
|
||||
}
|
||||
|
||||
bool runOnModule(Module &M) {
|
||||
(*Out) << Banner << M;
|
||||
(*Out) << M;
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -86,9 +85,8 @@ Y("print-function","Print function to stderr");
|
||||
/// createPrintModulePass - Create and return a pass that writes the
|
||||
/// module to the specified raw_ostream.
|
||||
ModulePass *llvm::createPrintModulePass(llvm::raw_ostream *OS,
|
||||
bool DeleteStream,
|
||||
const std::string &Banner) {
|
||||
return new PrintModulePass(Banner, OS, DeleteStream);
|
||||
bool DeleteStream) {
|
||||
return new PrintModulePass(OS, DeleteStream);
|
||||
}
|
||||
|
||||
/// createPrintFunctionPass - Create and return a pass that prints
|
||||
|
Loading…
Reference in New Issue
Block a user