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;
/// 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.
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) {
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.
///
namespace llvm {
class FunctionPass;
- class MachineFunctionPass;
class PassInfo;
class TargetLowering;
class RegisterCoalescer;
/// MachineFunctionPrinter pass - This pass prints out the machine function to
/// the given stream, as a debugging tool.
- MachineFunctionPass *
- createMachineFunctionPrinterPass(raw_ostream &OS,
- const std::string &Banner ="");
+ FunctionPass *createMachineFunctionPrinterPass(raw_ostream &OS,
+ const std::string &Banner ="");
/// MachineLoopInfo pass - This pass is a loop analysis pass.
///
#define LLVM_PASS_H
#include "llvm/System/DataTypes.h"
-
#include <cassert>
#include <utility>
#include <vector>
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 &,
///
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;
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.
///
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.
///
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;
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) {
//===----------------------------------------------------------------------===//
#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
//
//===----------------------------------------------------------------------===//
// 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
#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
//===----------------------------------------------------------------------===//
#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.
+++ /dev/null
-//===-- 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);
-}
-
-}
PCMPEQB, PCMPEQW, PCMPEQD, PCMPEQQ,
PCMPGTB, PCMPGTW, PCMPGTD, PCMPGTQ,
- // Advanced Encryption Standard (AES) Instructions
- AESIMC, AESENC, AESENCLAST, AESDEC, AESDECLAST,
-
// ADD, SUB, SMUL, UMUL, etc. - Arithmetic operations with FLAGS results.
ADD, SUB, SMUL, UMUL,
INC, DEC, OR, XOR, AND,
#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"
// 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;
}
// 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.
//
// 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.
//
#include "llvm/PassManagers.h"
-#include "llvm/Assembly/PrintModulePass.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#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"
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
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();
}
}
- /// 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);
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);
/// 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
/// 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
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;
}
/// 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
projects / oota-llvm.git / commitdiff