#ifndef LLVM_OPT_LEVELCHANGE_H
#define LLVM_OPT_LEVELCHANGE_H
-#include "llvm/Transforms/Pass.h"
+#include "llvm/Pass.h"
#include "llvm/Module.h"
#include "llvm/Method.h"
--- /dev/null
+//===- llvm/Pass.h - Base class for XForm Passes -----------------*- C++ -*--=//
+//
+// This file defines a base class that indicates that a specified class is a
+// transformation pass implementation.
+//
+// Pass's are designed this way so that it is possible to apply N passes to a
+// module, by first doing N Pass specific initializations for the module, then
+// looping over all of the methods in the module, doing method specific work
+// N times for each method. Like this:
+//
+// for_each(Passes.begin(), Passes.end(), doPassInitialization(Module));
+// for_each(Method *M <- Module->begin(), Module->end())
+// for_each(Passes.begin(), Passes.end(), doPerMethodWork(M));
+//
+// The other way to do things is like this:
+// for_each(Pass *P <- Passes.begin(), Passes.end()) {
+// Passes->doPassInitialization(Module)
+// for_each(Module->begin(), Module->end(), P->doPerMethodWork);
+// }
+//
+// But this can cause thrashing and poor cache performance, so we don't do it
+// that way.
+//
+// Because a transformation does not see all methods consecutively, it should
+// be careful about the state that it maintains... another pass may modify a
+// method between two invocatations of doPerMethodWork.
+//
+// Also, implementations of doMethodWork should not remove any methods from the
+// module.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_PASS_H
+#define LLVM_PASS_H
+
+#include "llvm/Module.h"
+#include "llvm/Method.h"
+
+//===----------------------------------------------------------------------===//
+// Pass interface - Implemented by all 'passes'.
+//
+struct Pass {
+ //===--------------------------------------------------------------------===//
+ // The externally useful entry points
+ //
+
+ // runAllPasses - Run a bunch of passes on the specified module, efficiently.
+ static bool runAllPasses(Module *M, vector<Pass*> &Passes) {
+ bool MadeChanges = false;
+ // Run all of the pass initializers
+ for (unsigned i = 0; i < Passes.size(); ++i)
+ MadeChanges |= Passes[i]->doPassInitialization(M);
+
+ // Loop over all of the methods, applying all of the passes to them
+ for (unsigned m = 0; m < M->size(); ++m)
+ for (unsigned i = 0; i < Passes.size(); ++i)
+ MadeChanges |= Passes[i]->doPerMethodWork(*(M->begin()+m));
+
+ // Run all of the pass finalizers...
+ for (unsigned i = 0; i < Passes.size(); ++i)
+ MadeChanges |= Passes[i]->doPassFinalization(M);
+ return MadeChanges;
+ }
+
+ // runAllPassesAndFree - Run a bunch of passes on the specified module,
+ // efficiently. When done, delete all of the passes.
+ //
+ static bool runAllPassesAndFree(Module *M, vector<Pass*> &Passes) {
+ // First run all of the passes
+ bool MadeChanges = runAllPasses(M, Passes);
+
+ // Free all of the passes.
+ for (unsigned i = 0; i < Passes.size(); ++i)
+ delete Passes[i];
+ return MadeChanges;
+ }
+
+
+ // run(Module*) - Run this pass on a module and all of the methods contained
+ // within it. Returns true if any of the contained passes returned true.
+ //
+ bool run(Module *M) {
+ bool MadeChanges = doPassInitialization(M);
+
+ // Loop over methods in the module. doPerMethodWork could add a method to
+ // the Module, so we have to keep checking for end of method list condition.
+ //
+ for (unsigned m = 0; m < M->size(); ++m)
+ MadeChanges |= doPerMethodWork(*(M->begin()+m));
+ return MadeChanges | doPassFinalization(M);
+ }
+
+ // run(Method*) - Run this pass on a module and one specific method. Returns
+ // false on success.
+ //
+ bool run(Method *M) {
+ return doPassInitialization(M->getParent()) | doPerMethodWork(M) |
+ doPassFinalization(M->getParent());
+ }
+
+
+ //===--------------------------------------------------------------------===//
+ // Functions to be implemented by subclasses
+ //
+
+ // Destructor - Virtual so we can be subclassed
+ inline virtual ~Pass() {}
+
+ // doPassInitialization - Virtual method overridden by subclasses to do
+ // any neccesary per-module initialization.
+ //
+ virtual bool doPassInitialization(Module *M) { return false; }
+
+ // doPerMethodWork - Virtual method overriden by subclasses to do the
+ // per-method processing of the pass.
+ //
+ virtual bool doPerMethodWork(Method *M) { return false; }
+
+ // doPassFinalization - Virtual method overriden by subclasses to do any post
+ // processing needed after all passes have run.
+ //
+ virtual bool doPassFinalization(Module *M) { return false; }
+};
+
+#endif
+
#ifndef LLVM_TRANSFORMS_LOWERALLOCATIONS_H
#define LLVM_TRANSFORMS_LOWERALLOCATIONS_H
-#include "llvm/Transforms/Pass.h"
+#include "llvm/Pass.h"
class TargetData;
class LowerAllocations : public Pass {
#ifndef LLVM_OPT_METHOD_INLINING_H
#define LLVM_OPT_METHOD_INLINING_H
-#include "llvm/Transforms/Pass.h"
+#include "llvm/Pass.h"
#include "llvm/BasicBlock.h"
class CallInst;
#ifndef LLVM_TRANSFORMS_HOISTPHICONSTANTS_H
#define LLVM_TRANSFORMS_HOISTPHICONSTANTS_H
-#include "llvm/Transforms/Pass.h"
+#include "llvm/Pass.h"
struct HoistPHIConstants : public Pass {
+ // doHoistPHIConstants - Hoist constants out of PHI instructions
+ //
static bool doHoistPHIConstants(Method *M);
-
virtual bool doPerMethodWork(Method *M) { return doHoistPHIConstants(M); }
};
#ifndef LLVM_TRANSFORMS_CONSTANTMERGE_H
#define LLVM_TRANSFORMS_CONSTANTMERGE_H
-#include "llvm/Transforms/Pass.h"
+#include "llvm/Pass.h"
#include <map>
class ConstPoolVal;
class GlobalVariable;
-// $Id$ -*-c++-*-
-//***************************************************************************
-// File:
-// TraceValues.h
-//
-// Purpose:
-// Support for inserting LLVM code to print values at basic block
-// and method exits. Also exports functions to create a call
-// "printf" instruction with one of the signatures listed below.
-//
-// History:
-// 10/11/01 - Vikram Adve - Created
-//**************************************************************************/
+//===- llvm/Transforms/Instrumentation/TraceValues.h - Tracing ---*- C++ -*--=//
+//
+// Support for inserting LLVM code to print values at basic block and method
+// exits.
+//
+//===----------------------------------------------------------------------===//
#ifndef LLVM_TRANSFORMS_INSTRUMENTATION_TRACEVALUES_H
#define LLVM_TRANSFORMS_INSTRUMENTATION_TRACEVALUES_H
-#include "llvm/Transforms/Pass.h"
+#include "llvm/Pass.h"
class InsertTraceCode : public Pass {
bool TraceBasicBlockExits, TraceMethodExits;
//
// Inserts tracing code for all live values at basic block and/or method exits
// as specified by `traceBasicBlockExits' and `traceMethodExits'.
- //--------------------------------------------------------------------------
-
+ //
static bool doInsertTraceCode(Method *M, bool traceBasicBlockExits,
bool traceMethodExits);
-
-
// doPerMethodWork - This method does the work. Always successful.
//
bool doPerMethodWork(Method *M) {
+++ /dev/null
-//===- llvm/Transforms/Pass.h - Base class for XForm Passes ------*- C++ -*--=//
-//
-// This file defines a marker class that indicates that a specified class is a
-// transformation pass implementation.
-//
-// Pass's are designed this way so that it is possible to apply N passes to a
-// module, by first doing N Pass specific initializations for the module, then
-// looping over all of the methods in the module, doing method specific work
-// N times for each method. Like this:
-//
-// for_each(Passes.begin(), Passes.end(), doPassInitialization(Module));
-// for_each(Method *M <- Module->begin(), Module->end())
-// for_each(Passes.begin(), Passes.end(), doPerMethodWork(M));
-//
-// The other way to do things is like this:
-// for_each(Pass *P <- Passes.begin(), Passes.end()) {
-// Passes->doPassInitialization(Module)
-// for_each(Module->begin(), Module->end(), P->doPerMethodWork);
-// }
-//
-// But this can cause thrashing and poor cache performance, so we don't do it
-// that way.
-//
-// Because a transformation does not see all methods consecutively, it should
-// be careful about the state that it maintains... another pass may modify a
-// method between two invocatations of doPerMethodWork.
-//
-// Also, implementations of doMethodWork should not remove any methods from the
-// module.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TRANSFORMS_PASS_H
-#define LLVM_TRANSFORMS_PASS_H
-
-#include "llvm/Module.h"
-#include "llvm/Method.h"
-
-//===----------------------------------------------------------------------===//
-// Pass interface - Implemented by all 'passes'.
-//
-struct Pass {
- //===--------------------------------------------------------------------===//
- // The externally useful entry points
- //
-
- // runAllPasses - Run a bunch of passes on the specified module, efficiently.
- static bool runAllPasses(Module *M, vector<Pass*> &Passes) {
- bool MadeChanges = false;
- // Run all of the pass initializers
- for (unsigned i = 0; i < Passes.size(); ++i)
- MadeChanges |= Passes[i]->doPassInitialization(M);
-
- // Loop over all of the methods, applying all of the passes to them
- for (unsigned m = 0; m < M->size(); ++m)
- for (unsigned i = 0; i < Passes.size(); ++i)
- MadeChanges |= Passes[i]->doPerMethodWork(*(M->begin()+m));
-
- // Run all of the pass finalizers...
- for (unsigned i = 0; i < Passes.size(); ++i)
- MadeChanges |= Passes[i]->doPassFinalization(M);
- return MadeChanges;
- }
-
- // runAllPassesAndFree - Run a bunch of passes on the specified module,
- // efficiently. When done, delete all of the passes.
- //
- static bool runAllPassesAndFree(Module *M, vector<Pass*> &Passes) {
- // First run all of the passes
- bool MadeChanges = runAllPasses(M, Passes);
-
- // Free all of the passes.
- for (unsigned i = 0; i < Passes.size(); ++i)
- delete Passes[i];
- return MadeChanges;
- }
-
-
- // run(Module*) - Run this pass on a module and all of the methods contained
- // within it. Returns true if any of the contained passes returned true.
- //
- bool run(Module *M) {
- bool MadeChanges = doPassInitialization(M);
-
- // Loop over methods in the module. doPerMethodWork could add a method to
- // the Module, so we have to keep checking for end of method list condition.
- //
- for (unsigned m = 0; m < M->size(); ++m)
- MadeChanges |= doPerMethodWork(*(M->begin()+m));
- return MadeChanges | doPassFinalization(M);
- }
-
- // run(Method*) - Run this pass on a module and one specific method. Returns
- // false on success.
- //
- bool run(Method *M) {
- return doPassInitialization(M->getParent()) | doPerMethodWork(M) |
- doPassFinalization(M->getParent());
- }
-
-
- //===--------------------------------------------------------------------===//
- // Functions to be implemented by subclasses
- //
-
- // Destructor - Virtual so we can be subclassed
- inline virtual ~Pass() {}
-
- // doPassInitialization - Virtual method overridden by subclasses to do
- // any neccesary per-module initialization.
- //
- virtual bool doPassInitialization(Module *M) { return false; }
-
- // doPerMethodWork - Virtual method overriden by subclasses to do the
- // per-method processing of the pass.
- //
- virtual bool doPerMethodWork(Method *M) { return false; }
-
- // doPassFinalization - Virtual method overriden by subclasses to do any post
- // processing needed after all passes have run.
- //
- virtual bool doPassFinalization(Module *M) { return false; }
-};
-
-#endif
-
#ifndef LLVM_TRANSFORMS_PRINTMODULE_H
#define LLVM_TRANSFORMS_PRINTMODULE_H
-#include "llvm/Transforms/Pass.h"
+#include "llvm/Pass.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Bytecode/Writer.h"
bool doPassFinalization(Module *M) {
WriteBytecodeToFile(M, *Out);
+ return false;
}
};
#ifndef LLVM_OPT_CONSTANT_PROPOGATION_H
#define LLVM_OPT_CONSTANT_PROPOGATION_H
-#include "llvm/Transforms/Pass.h"
+#include "llvm/Pass.h"
class TerminatorInst;
namespace opt {
#ifndef LLVM_OPT_DCE_H
#define LLVM_OPT_DCE_H
-#include "llvm/Transforms/Pass.h"
+#include "llvm/Pass.h"
namespace opt {
#ifndef LLVM_OPT_INDUCTION_VARS_H
#define LLVM_OPT_INDUCTION_VARS_H
-#include "llvm/Transforms/Pass.h"
-#include "llvm/Module.h"
+#include "llvm/Pass.h"
namespace opt {
#ifndef LLVM_OPT_SYMBOL_STRIPPING_H
#define LLVM_OPT_SYMBOL_STRIPPING_H
-class Method;
-class Module;
-#include "llvm/Transforms/Pass.h"
+#include "llvm/Pass.h"
namespace opt {
projects / oota-llvm.git / commitdiff