6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-14 00:32:55 +00:00
Code Issues Projects Releases Wiki Activity

Change over to use new style pass mechanism, now passes only expose small

Browse Source 
creation functions in their public header file, unless they can help it.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1816 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2002-02-26 21:46:54 +00:00
parent 3b2541424f
commit bd0ef77cde
32 changed files with 528 additions and 512 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
include/llvm/Transforms/ChangeAllocations.h
View File

@ -10,51 +10,10 @@
#ifndef LLVM_TRANSFORMS_CHANGEALLOCATIONS_H
#define LLVM_TRANSFORMS_CHANGEALLOCATIONS_H
#include "llvm/Pass.h"
class Pass;
class TargetData;
// LowerAllocations - Turn malloc and free instructions into %malloc and %free
// calls.
//
class LowerAllocations : public BasicBlockPass {
Method *MallocMeth; // Methods in the module we are processing
Method *FreeMeth; // Initialized by doInitialization
const TargetData &DataLayout;
public:
inline LowerAllocations(const TargetData &TD) : DataLayout(TD) {
MallocMeth = FreeMeth = 0;
}
// doPassInitialization - For the lower allocations pass, this ensures that a
// module contains a declaration for a malloc and a free function.
//
bool doInitialization(Module *M);
// runOnBasicBlock - This method does the actual work of converting
// instructions over, assuming that the pass has already been initialized.
//
bool runOnBasicBlock(BasicBlock *BB);
};
// RaiseAllocations - Turn %malloc and %free calls into the appropriate
// instruction.
//
class RaiseAllocations : public BasicBlockPass {
Method *MallocMeth; // Methods in the module we are processing
Method *FreeMeth; // Initialized by doPassInitializationVirt
public:
inline RaiseAllocations() : MallocMeth(0), FreeMeth(0) {}
// doPassInitialization - For the raise allocations pass, this finds a
// declaration for malloc and free if they exist.
//
bool doInitialization(Module *M);
// runOnBasicBlock - This method does the actual work of converting
// instructions over, assuming that the pass has already been initialized.
//
bool runOnBasicBlock(BasicBlock *BB);
};
Pass *createLowerAllocationsPass(const TargetData &TD);
Pass *createRaiseAllocationsPass();
#endif

17
include/llvm/Transforms/FunctionInlining.h
View File

@ -4,23 +4,14 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_OPT_METHOD_INLINING_H
#define LLVM_OPT_METHOD_INLINING_H
#ifndef LLVM_TRANSFORMS_METHOD_INLINING_H
#define LLVM_TRANSFORMS_METHOD_INLINING_H
#include "llvm/Pass.h"
#include "llvm/BasicBlock.h"
class CallInst;
class Pass;
struct MethodInlining : public MethodPass {
// DoMethodInlining - Use a heuristic based approach to inline methods that
// seem to look good.
//
static bool doMethodInlining(Method *M);
virtual bool runOnMethod(Method *M) {
return doMethodInlining(M);
}
};
Pass *createMethodInliningPass();
// InlineMethod - This function forcibly inlines the called method into the
// basic block of the caller. This returns true if it is not possible to inline

11
include/llvm/Transforms/HoistPHIConstants.h
View File

@ -9,14 +9,7 @@
#ifndef LLVM_TRANSFORMS_HOISTPHICONSTANTS_H
#define LLVM_TRANSFORMS_HOISTPHICONSTANTS_H
#include "llvm/Pass.h"
struct HoistPHIConstants : public MethodPass {
// doHoistPHIConstants - Hoist constants out of PHI instructions
//
static bool doHoistPHIConstants(Method *M);
virtual bool runOnMethod(Method *M) { return doHoistPHIConstants(M); }
};
class Pass;
Pass *createHoistPHIConstantsPass();
#endif

32
include/llvm/Transforms/IPO.h
View File

@ -6,35 +6,7 @@
#ifndef LLVM_TRANSFORMS_CLEANUPGCCOUTPUT_H
#define LLVM_TRANSFORMS_CLEANUPGCCOUTPUT_H
#include "llvm/Pass.h"
struct CleanupGCCOutput : public MethodPass {
// PatchUpMethodReferences - This is a part of the functionality exported by
// the CleanupGCCOutput pass. This causes functions with different signatures
// to be linked together if they have the same name.
//
static bool PatchUpMethodReferences(Module *M);
// doPassInitialization - For this pass, it removes global symbol table
// entries for primitive types. These are never used for linking in GCC and
// they make the output uglier to look at, so we nuke them.
//
// Also, initialize instance variables.
//
bool doInitialization(Module *M);
// doPerMethodWork - This method simplifies the specified method hopefully.
//
bool runOnMethod(Method *M);
// doPassFinalization - Strip out type names that are unused by the program
bool doFinalization(Module *M);
// getAnalysisUsageInfo - This function needs FindUsedTypes to do its job...
//
virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided);
};
class Pass;
Pass *createCleanupGCCOutputPass();
#endif

42
include/llvm/Transforms/IPO/ConstantMerge.h
View File

@ -17,44 +17,8 @@
#ifndef LLVM_TRANSFORMS_CONSTANTMERGE_H
#define LLVM_TRANSFORMS_CONSTANTMERGE_H
#include "llvm/Pass.h"
class Constant;
class GlobalVariable;
// FIXME: ConstantMerge should not be a methodPass!!!
class ConstantMerge : public MethodPass {
protected:
std::map<Constant*, GlobalVariable*> Constants;
unsigned LastConstantSeen;
public:
inline ConstantMerge() : LastConstantSeen(0) {}
// mergeDuplicateConstants - Static accessor for clients that don't want to
// deal with passes.
//
static bool mergeDuplicateConstants(Module *M);
// doInitialization - For this pass, process all of the globals in the
// module, eliminating duplicate constants.
//
bool doInitialization(Module *M);
bool runOnMethod(Method*) { return false; }
// doFinalization - Clean up internal state for this module
//
bool doFinalization(Module *M) {
LastConstantSeen = 0;
Constants.clear();
return false;
}
};
struct DynamicConstantMerge : public ConstantMerge {
// doPerMethodWork - Check to see if any globals have been added to the
// global list for the module. If so, eliminate them.
//
bool runOnMethod(Method *M);
};
class Pass;
Pass *createConstantMergePass();
Pass *createDynamicConstantMergePass();
#endif

22
include/llvm/Transforms/IPO/GlobalDCE.h
View File

@ -7,25 +7,7 @@
#ifndef LLVM_TRANSFORM_IPO_GLOBALDCE_H
#define LLVM_TRANSFORM_IPO_GLOBALDCE_H
#include "llvm/Pass.h"
namespace cfg { class CallGraph; }
class Module;
struct GlobalDCE : public Pass {
// run - Do the GlobalDCE pass on the specified module, optionally updating
// the specified callgraph to reflect the changes.
//
bool run(Module *M);
// getAnalysisUsageInfo - This function works on the call graph of a module.
// It is capable of updating the call graph to reflect the new state of the
// module.
//
virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided);
};
class Pass;
Pass *createGlobalDCEPass();
#endif

28
include/llvm/Transforms/IPO/SimpleStructMutation.h
View File

@ -8,30 +8,8 @@
#ifndef LLVM_TRANSFORMS_SIMPLESTRUCTMUTATION_H
#define LLVM_TRANSFORMS_SIMPLESTRUCTMUTATION_H
#include "llvm/Transforms/IPO/MutateStructTypes.h"
class SimpleStructMutation : public MutateStructTypes {
public:
enum Transform { SwapElements, SortElements } CurrentXForm;
SimpleStructMutation(enum Transform XForm) : CurrentXForm(XForm) {}
virtual bool run(Module *M) {
setTransforms(getTransforms(M, CurrentXForm));
bool Changed = MutateStructTypes::run(M);
clearTransforms();
return Changed;
}
// getAnalysisUsageInfo - This function needs the results of the
// FindUsedTypes and FindUnsafePointerTypes analysis passes...
//
virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided);
private:
TransformsType getTransforms(Module *M, enum Transform);
};
class Pass;
Pass *createSwapElementsPass();
Pass *createSortElementsPass();
#endif

33
include/llvm/Transforms/Instrumentation/TraceValues.h
View File

@ -8,35 +8,8 @@
#ifndef LLVM_TRANSFORMS_INSTRUMENTATION_TRACEVALUES_H
#define LLVM_TRANSFORMS_INSTRUMENTATION_TRACEVALUES_H
#include "llvm/Pass.h"
class Method;
class InsertTraceCode : public MethodPass {
bool TraceBasicBlockExits, TraceMethodExits;
Method *PrintfMeth;
public:
InsertTraceCode(bool traceBasicBlockExits, bool traceMethodExits)
: TraceBasicBlockExits(traceBasicBlockExits),
TraceMethodExits(traceMethodExits) {}
// Add a prototype for printf if it is not already in the program.
//
bool doInitialization(Module *M);
//--------------------------------------------------------------------------
// Function InsertCodeToTraceValues
//
// Inserts tracing code for all live values at basic block and/or method exits
// as specified by `traceBasicBlockExits' and `traceMethodExits'.
//
static bool doit(Method *M, bool traceBasicBlockExits,
bool traceMethodExits, Method *Printf);
// runOnMethod - This method does the work. Always successful.
//
bool runOnMethod(Method *M) {
return doit(M, TraceBasicBlockExits, TraceMethodExits, PrintfMeth);
}
};
class Pass;
Pass *createTraceValuesPassForMethod(); // Just trace methods
Pass *createTraceValuesPassForBasicBlocks(); // Trace BB's and methods
#endif

19
include/llvm/Transforms/RaisePointerReferences.h
View File

@ -9,27 +9,12 @@
#ifndef LLVM_TRANSFORMS_LEVELCHANGE_H
#define LLVM_TRANSFORMS_LEVELCHANGE_H
#include "llvm/Pass.h"
class Pass;
// RaisePointerReferences - Try to eliminate as many pointer arithmetic
// expressions as possible, by converting expressions to use getelementptr and
// friends.
//
struct RaisePointerReferences : public MethodPass {
static bool doit(Method *M);
virtual bool runOnMethod(Method *M) { return doit(M); }
};
// EliminateAuxillaryInductionVariables - Eliminate all aux indvars. This
// converts all induction variables to reference a cannonical induction
// variable (which starts at 0 and counts by 1).
//
struct EliminateAuxillaryInductionVariables : public MethodPass {
static bool doit(Method *M) { return false; } // TODO!
virtual bool runOnMethod(Method *M) { return doit(M); }
};
Pass *createRaisePointerReferencesPass();
#endif

33
include/llvm/Transforms/Scalar/ConstantProp.h
View File

@ -7,26 +7,19 @@
#ifndef LLVM_TRANSFORMS_SCALAR_CONSTANT_PROPOGATION_H
#define LLVM_TRANSFORMS_SCALAR_CONSTANT_PROPOGATION_H
#include "llvm/Pass.h"
#include "llvm/BasicBlock.h"
class TerminatorInst;
class Pass;
struct ConstantPropogation : public MethodPass {
// doConstantPropogation - Do trivial constant propogation and expression
// folding
static bool doConstantPropogation(Method *M);
// doConstantPropogation - Constant prop a specific instruction. Returns true
// and potentially moves the iterator if constant propogation was performed.
//
static bool doConstantPropogation(BasicBlock *BB, BasicBlock::iterator &I);
inline bool runOnMethod(Method *M) {
return doConstantPropogation(M);
}
};
//===----------------------------------------------------------------------===//
// Normal Constant Propogation Pass
//
Pass *createConstantPropogationPass();
// doConstantPropogation - Constant prop a specific instruction. Returns true
// and potentially moves the iterator if constant propogation was performed.
//
bool doConstantPropogation(BasicBlock *BB, BasicBlock::iterator &I);
// ConstantFoldTerminator - If a terminator instruction is predicated on a
// constant value, convert it into an unconditional branch to the constant
@ -38,12 +31,6 @@ bool ConstantFoldTerminator(TerminatorInst *T);
//===----------------------------------------------------------------------===//
// Sparse Conditional Constant Propogation Pass
//
struct SCCPPass : public MethodPass {
static bool doSCCP(Method *M);
inline bool runOnMethod(Method *M) {
return doSCCP(M);
}
};
Pass *createSCCPPass();
#endif

54
include/llvm/Transforms/Scalar/DCE.h
View File

@ -5,21 +5,19 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_OPT_DCE_H
#define LLVM_OPT_DCE_H
#ifndef LLVM_TRANSFORMS_SCALAR_DCE_H
#define LLVM_TRANSFORMS_SCALAR_DCE_H
#include "llvm/Pass.h"
#include "llvm/Method.h"
#include "llvm/BasicBlock.h"
class Pass;
//===----------------------------------------------------------------------===//
// DeadInstElimination - This pass quickly removes trivially dead instructions
// without modifying the CFG of the function. It is a BasicBlockPass, so it
// runs efficiently when queued next to other BasicBlockPass's.
//
struct DeadInstElimination : public BasicBlockPass {
virtual bool runOnBasicBlock(BasicBlock *BB);
};
Pass *createDeadInstEliminationPass();
//===----------------------------------------------------------------------===//
@ -32,34 +30,16 @@ struct DeadInstElimination : public BasicBlockPass {
// otherwise simplifies control flow. This should be factored out of this pass
// eventually into it's own pass.
//
struct DeadCodeElimination : public MethodPass {
// External Interface:
//
static bool doDCE(Method *M);
// dceInstruction - Inspect the instruction at *BBI and figure out if it's
// [trivially] dead. If so, remove the instruction and update the iterator
// to point to the instruction that immediately succeeded the original
// instruction.
//
static bool dceInstruction(BasicBlock::InstListType &BBIL,
BasicBlock::iterator &BBI);
Pass *createDeadCodeEliminationPass();
// Remove unused global values - This removes unused global values of no
// possible value. This currently includes unused method prototypes and
// unitialized global variables.
//
static bool RemoveUnusedGlobalValues(Module *M);
// Pass Interface...
virtual bool doInitialization(Module *M) {
return RemoveUnusedGlobalValues(M);
}
virtual bool runOnMethod(Method *M) { return doDCE(M); }
virtual bool doFinalization(Module *M) {
return RemoveUnusedGlobalValues(M);
}
};
// dceInstruction - Inspect the instruction at *BBI and figure out if it's
// [trivially] dead. If so, remove the instruction and update the iterator
// to point to the instruction that immediately succeeded the original
// instruction.
//
bool dceInstruction(BasicBlock::InstListType &BBIL,
BasicBlock::iterator &BBI);
@ -68,15 +48,7 @@ struct DeadCodeElimination : public MethodPass {
// algorithm assumes instructions are dead until proven otherwise, which makes
// it more successful are removing non-obviously dead instructions.
//
struct AgressiveDCE : public MethodPass {
virtual bool runOnMethod(Method *M);
// getAnalysisUsageInfo - We require post dominance frontiers (aka Control
// Dependence Graph)
virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided);
};
Pass *createAgressiveDCEPass();
// SimplifyCFG - This function is used to do simplification of a CFG. For

15
include/llvm/Transforms/Scalar/IndVarSimplify.h
View File

@ -8,18 +8,7 @@
#ifndef LLVM_TRANSFORMS_SCALAR_INDVARSIMPLIFY_H
#define LLVM_TRANSFORMS_SCALAR_INDVARSIMPLIFY_H
#include "llvm/Pass.h"
namespace cfg { class LoopInfo; }
struct InductionVariableSimplify : public MethodPass {
static bool doit(Method *M, cfg::LoopInfo &Loops);
virtual bool runOnMethod(Method *M);
virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided);
};
class Pass;
Pass *createIndVarSimplifyPass();
#endif

11
include/llvm/Transforms/Scalar/InstructionCombining.h
View File

@ -15,14 +15,7 @@
#ifndef LLVM_TRANSFORMS_SCALAR_INSTRUCTIONCOMBINING_H
#define LLVM_TRANSFORMS_SCALAR_INSTRUCTIONCOMBINING_H
#include "llvm/Pass.h"
class Instruction;
struct InstructionCombining : public MethodPass {
static bool doit(Method *M);
static bool CombineInstruction(Instruction *I);
virtual bool runOnMethod(Method *M) { return doit(M); }
};
class Pass;
Pass *createInstructionCombiningPass();
#endif

33
include/llvm/Transforms/Scalar/SymbolStripping.h
View File

@ -5,35 +5,12 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_OPT_SYMBOL_STRIPPING_H
#define LLVM_OPT_SYMBOL_STRIPPING_H
#ifndef LLVM_TRANSFORMS_SYMBOL_STRIPPING_H
#define LLVM_TRANSFORMS_SYMBOL_STRIPPING_H
#include "llvm/Pass.h"
class Pass;
struct SymbolStripping : public MethodPass {
// doSymbolStripping - Remove all symbolic information from a method
//
static bool doSymbolStripping(Method *M);
virtual bool runOnMethod(Method *M) {
return doSymbolStripping(M);
}
};
struct FullSymbolStripping : public MethodPass {
// doStripGlobalSymbols - Remove all symbolic information from all methods
// in a module, and all module level symbols. (method names, etc...)
//
static bool doStripGlobalSymbols(Module *M);
virtual bool doInitialization(Module *M) {
return doStripGlobalSymbols(M);
}
virtual bool runOnMethod(Method *M) {
return SymbolStripping::doSymbolStripping(M);
}
};
Pass *createSymbolStrippingPass();
Pass *createFullSymbolStrippingPass();
#endif

4
include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
View File

@ -40,4 +40,8 @@ public:
}
};
static inline Pass *createUnifyMethodExitNodesPass() {
return new UnifyMethodExitNodes();
}
#endif

17
lib/Transforms/HoistPHIConstants.cpp
View File

@ -11,6 +11,7 @@
#include "llvm/iOther.h"
#include "llvm/BasicBlock.h"
#include "llvm/Method.h"
#include "llvm/Pass.h"
#include <map>
#include <vector>
@ -19,12 +20,6 @@ typedef std::map<BBConstTy, CastInst *> CachedCopyMap;
static Value *NormalizePhiOperand(PHINode *PN, Value *CPV,
BasicBlock *Pred, CachedCopyMap &CopyCache) {
/* NOTE: CahedCopyMap was disabled to insert phi elimination code
for all phi args -- Ruchira
*/
// Check if we've already inserted a copy for this constant in Pred
// Note that `copyCache[Pred]' will create an empty vector the first time
//
@ -47,7 +42,7 @@ static Value *NormalizePhiOperand(PHINode *PN, Value *CPV,
// Entry point for normalizing constant args in PHIs
//---------------------------------------------------------------------------
bool HoistPHIConstants::doHoistPHIConstants(Method *M) {
static bool doHoistPHIConstants(Method *M) {
CachedCopyMap Cache;
bool Changed = false;
@ -77,3 +72,11 @@ bool HoistPHIConstants::doHoistPHIConstants(Method *M) {
return Changed;
}
namespace {
struct HoistPHIConstants : public MethodPass {
virtual bool runOnMethod(Method *M) { return doHoistPHIConstants(M); }
};
}
Pass *createHoistPHIConstantsPass() { return new HoistPHIConstants(); }

61
lib/Transforms/IPO/ConstantMerge.cpp
View File

@ -18,6 +18,7 @@
#include "llvm/GlobalVariable.h"
#include "llvm/Module.h"
#include "llvm/Method.h"
#include "llvm/Pass.h"
// mergeDuplicateConstants - Workhorse for the pass. This eliminates duplicate
// constants, starting at global ConstantNo, and adds vars to the map if they
@ -56,27 +57,43 @@ bool mergeDuplicateConstants(Module *M, unsigned &ConstantNo,
return MadeChanges;
}
// mergeDuplicateConstants - Static accessor for clients that don't want to
// deal with passes.
//
bool ConstantMerge::mergeDuplicateConstants(Module *M) {
std::map<Constant*, GlobalVariable*> Constants;
unsigned LastConstantSeen = 0;
return ::mergeDuplicateConstants(M, LastConstantSeen, Constants);
namespace {
// FIXME: ConstantMerge should not be a methodPass!!!
class ConstantMerge : public MethodPass {
protected:
std::map<Constant*, GlobalVariable*> Constants;
unsigned LastConstantSeen;
public:
inline ConstantMerge() : LastConstantSeen(0) {}
// doInitialization - For this pass, process all of the globals in the
// module, eliminating duplicate constants.
//
bool doInitialization(Module *M) {
return ::mergeDuplicateConstants(M, LastConstantSeen, Constants);
}
bool runOnMethod(Method*) { return false; }
// doFinalization - Clean up internal state for this module
//
bool doFinalization(Module *M) {
LastConstantSeen = 0;
Constants.clear();
return false;
}
};
struct DynamicConstantMerge : public ConstantMerge {
// doPerMethodWork - Check to see if any globals have been added to the
// global list for the module. If so, eliminate them.
//
bool runOnMethod(Method *M) {
return ::mergeDuplicateConstants(M->getParent(), LastConstantSeen,
Constants);
}
};
}
// doInitialization - For this pass, process all of the globals in the
// module, eliminating duplicate constants.
//
bool ConstantMerge::doInitialization(Module *M) {
return ::mergeDuplicateConstants(M, LastConstantSeen, Constants);
}
// doPerMethodWork - Check to see if any globals have been added to the
// global list for the module. If so, eliminate them.
//
bool DynamicConstantMerge::runOnMethod(Method *M) {
return ::mergeDuplicateConstants(M->getParent(), LastConstantSeen, Constants);
}
Pass *createConstantMergePass() { return new ConstantMerge(); }
Pass *createDynamicConstantMergePass() { return new DynamicConstantMerge(); }

44
lib/Transforms/IPO/DeadTypeElimination.cpp
View File

@ -23,6 +23,7 @@
#include "llvm/iTerminators.h"
#include "llvm/iOther.h"
#include "llvm/Support/CFG.h"
#include "llvm/Pass.h"
#include <algorithm>
#include <iostream>
using std::vector;
@ -31,6 +32,36 @@ using std::cerr;
static const Type *PtrSByte = 0; // 'sbyte*' type
namespace {
struct CleanupGCCOutput : public MethodPass {
// doPassInitialization - For this pass, it removes global symbol table
// entries for primitive types. These are never used for linking in GCC and
// they make the output uglier to look at, so we nuke them.
//
// Also, initialize instance variables.
//
bool doInitialization(Module *M);
// doPerMethodWork - This method simplifies the specified method hopefully.
//
bool runOnMethod(Method *M);
// doPassFinalization - Strip out type names that are unused by the program
bool doFinalization(Module *M);
// getAnalysisUsageInfo - This function needs FindUsedTypes to do its job...
//
virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided) {
// FIXME: Invalidates the CFG
Required.push_back(FindUsedTypes::ID);
}
};
}
// ConvertCallTo - Convert a call to a varargs function with no arg types
// specified to a concrete nonvarargs method.
//
@ -79,7 +110,7 @@ static void ConvertCallTo(CallInst *CI, Method *Dest) {
// because of the way things are declared in C. If this is the case, patch
// things up.
//
bool CleanupGCCOutput::PatchUpMethodReferences(Module *M) {
static bool PatchUpMethodReferences(Module *M) {
SymbolTable *ST = M->getSymbolTable();
if (!ST) return false;
@ -545,12 +576,7 @@ bool CleanupGCCOutput::doFinalization(Module *M) {
return Changed;
}
// getAnalysisUsageInfo - This function needs the results of the
// FindUsedTypes and FindUnsafePointerTypes analysis passes...
//
void CleanupGCCOutput::getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided) {
// FIXME: Invalidates the CFG
Required.push_back(FindUsedTypes::ID);
Pass *createCleanupGCCOutputPass() {
return new CleanupGCCOutput();
}

36
lib/Transforms/IPO/GlobalDCE.cpp
View File

@ -8,6 +8,7 @@
#include "llvm/Analysis/CallGraph.h"
#include "llvm/Module.h"
#include "llvm/Method.h"
#include "llvm/Pass.h"
#include "Support/DepthFirstIterator.h"
#include <set>
@ -45,18 +46,27 @@ static bool RemoveUnreachableMethods(Module *M, cfg::CallGraph &CallGraph) {
return true;
}
bool GlobalDCE::run(Module *M) {
return RemoveUnreachableMethods(M, getAnalysis<cfg::CallGraph>());
namespace {
struct GlobalDCE : public Pass {
// run - Do the GlobalDCE pass on the specified module, optionally updating
// the specified callgraph to reflect the changes.
//
bool run(Module *M) {
return RemoveUnreachableMethods(M, getAnalysis<cfg::CallGraph>());
}
// getAnalysisUsageInfo - This function works on the call graph of a module.
// It is capable of updating the call graph to reflect the new state of the
// module.
//
virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided) {
Required.push_back(cfg::CallGraph::ID);
// FIXME: This should update the callgraph, not destroy it!
Destroyed.push_back(cfg::CallGraph::ID);
}
};
}
// getAnalysisUsageInfo - This function works on the call graph of a module.
// It is capable of updating the call graph to reflect the new state of the
// module.
//
void GlobalDCE::getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided) {
Required.push_back(cfg::CallGraph::ID);
// FIXME: This should update the callgraph, not destroy it!
Destroyed.push_back(cfg::CallGraph::ID);
}
Pass *createGlobalDCEPass() { return new GlobalDCE(); }

16
lib/Transforms/IPO/InlineSimple.cpp
View File

@ -21,6 +21,7 @@
#include "llvm/Transforms/MethodInlining.h"
#include "llvm/Module.h"
#include "llvm/Method.h"
#include "llvm/Pass.h"
#include "llvm/iTerminators.h"
#include "llvm/iPHINode.h"
#include "llvm/iOther.h"
@ -249,7 +250,10 @@ static inline bool DoMethodInlining(BasicBlock *BB) {
return false;
}
bool MethodInlining::doMethodInlining(Method *M) {
// doMethodInlining - Use a heuristic based approach to inline methods that
// seem to look good.
//
static bool doMethodInlining(Method *M) {
bool Changed = false;
// Loop through now and inline instructions a basic block at a time...
@ -264,3 +268,13 @@ bool MethodInlining::doMethodInlining(Method *M) {
return Changed;
}
namespace {
struct MethodInlining : public MethodPass {
virtual bool runOnMethod(Method *M) {
return doMethodInlining(M);
}
};
}
Pass *createMethodInliningPass() { return new MethodInlining(); }

47
lib/Transforms/IPO/SimpleStructMutation.cpp
View File

@ -19,6 +19,37 @@ using std::pair;
#include "llvm/Assembly/Writer.h"
namespace {
class SimpleStructMutation : public MutateStructTypes {
public:
enum Transform { SwapElements, SortElements } CurrentXForm;
SimpleStructMutation(enum Transform XForm) : CurrentXForm(XForm) {}
virtual bool run(Module *M) {
setTransforms(getTransforms(M, CurrentXForm));
bool Changed = MutateStructTypes::run(M);
clearTransforms();
return Changed;
}
// getAnalysisUsageInfo - This function needs the results of the
// FindUsedTypes and FindUnsafePointerTypes analysis passes...
//
virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided) {
Required.push_back(FindUsedTypes::ID);
Required.push_back(FindUnsafePointerTypes::ID);
MutateStructTypes::getAnalysisUsageInfo(Required, Destroyed, Provided);
}
private:
TransformsType getTransforms(Module *M, enum Transform);
};
} // end anonymous namespace
// PruneTypes - Given a type Ty, make sure that neither it, or one of its
// subtypes, occur in TypesToModify.
@ -87,6 +118,7 @@ static inline void GetTransformation(const StructType *ST,
}
}
SimpleStructMutation::TransformsType
SimpleStructMutation::getTransforms(Module *M, enum Transform XForm) {
// We need to know which types to modify, and which types we CAN'T modify
@ -137,13 +169,10 @@ SimpleStructMutation::TransformsType
}
// getAnalysisUsageInfo - This function needs the results of the
// FindUsedTypes and FindUnsafePointerTypes analysis passes...
//
void SimpleStructMutation::getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided){
Required.push_back(FindUsedTypes::ID);
Required.push_back(FindUnsafePointerTypes::ID);
MutateStructTypes::getAnalysisUsageInfo(Required, Destroyed, Provided);
Pass *createSwapElementsPass() {
return new SimpleStructMutation(SimpleStructMutation::SwapElements);
}
Pass *createSortElementsPass() {
return new SimpleStructMutation(SimpleStructMutation::SortElements);
}

43
lib/Transforms/Instrumentation/TraceValues.cpp
View File

@ -15,12 +15,55 @@
#include "llvm/Method.h"
#include "llvm/Module.h"
#include "llvm/SymbolTable.h"
#include "llvm/Pass.h"
#include "llvm/Assembly/Writer.h"
#include "Support/StringExtras.h"
#include <sstream>
using std::vector;
using std::string;
namespace {
class InsertTraceCode : public MethodPass {
bool TraceBasicBlockExits, TraceMethodExits;
Method *PrintfMeth;
public:
InsertTraceCode(bool traceBasicBlockExits, bool traceMethodExits)
: TraceBasicBlockExits(traceBasicBlockExits),
TraceMethodExits(traceMethodExits) {}
// Add a prototype for printf if it is not already in the program.
//
bool doInitialization(Module *M);
//--------------------------------------------------------------------------
// Function InsertCodeToTraceValues
//
// Inserts tracing code for all live values at basic block and/or method
// exits as specified by `traceBasicBlockExits' and `traceMethodExits'.
//
static bool doit(Method *M, bool traceBasicBlockExits,
bool traceMethodExits, Method *Printf);
// runOnMethod - This method does the work. Always successful.
//
bool runOnMethod(Method *M) {
return doit(M, TraceBasicBlockExits, TraceMethodExits, PrintfMeth);
}
};
} // end anonymous namespace
Pass *createTraceValuesPassForMethod() { // Just trace methods
return new InsertTraceCode(false, true);
}
Pass *createTraceValuesPassForBasicBlocks() { // Trace BB's and methods
return new InsertTraceCode(true, true);
}
// Add a prototype for printf if it is not already in the program.
//
bool InsertTraceCode::doInitialization(Module *M) {

20
lib/Transforms/LevelRaise.cpp
View File

@ -12,6 +12,7 @@
#include "llvm/iOther.h"
#include "llvm/iMemory.h"
#include "llvm/ConstantVals.h"
#include "llvm/Pass.h"
#include "llvm/Transforms/Scalar/DCE.h"
#include "llvm/Transforms/Scalar/ConstantHandling.h"
#include "llvm/Transforms/Scalar/ConstantProp.h"
@ -413,8 +414,7 @@ static bool DoRaisePass(Method *M) {
#if DEBUG_PEEPHOLE_INSTS
cerr << "Processing: " << *BI;
#endif
if (DeadCodeElimination::dceInstruction(BIL, BI) ||
ConstantPropogation::doConstantPropogation(BB, BI)) {
if (dceInstruction(BIL, BI) || doConstantPropogation(BB, BI)) {
Changed = true;
#ifdef DEBUG_PEEPHOLE_INSTS
cerr << "DeadCode Elinated!\n";
@ -429,12 +429,10 @@ static bool DoRaisePass(Method *M) {
}
// RaisePointerReferences::doit - Raise a method representation to a higher
// level.
//
bool RaisePointerReferences::doit(Method *M) {
static bool doRPR(Method *M) {
#ifdef DEBUG_PEEPHOLE_INSTS
cerr << "\n\n\nStarting to work on Method '" << M->getName() << "'\n";
#endif
@ -459,3 +457,15 @@ bool RaisePointerReferences::doit(Method *M) {
return Changed;
}
namespace {
struct RaisePointerReferences : public MethodPass {
virtual bool runOnMethod(Method *M) { return doRPR(M); }
};
}
Pass *createRaisePointerReferencesPass() {
return new RaisePointerReferences();
}

33
lib/Transforms/Scalar/ADCE.cpp
View File

@ -288,21 +288,24 @@ BasicBlock *ADCE::fixupCFG(BasicBlock *BB, std::set<BasicBlock*> &VisitedBlocks,
}
}
// doADCE - Execute the Agressive Dead Code Elimination Algorithm
//
bool AgressiveDCE::runOnMethod(Method *M) {
return ADCE(M).doADCE(
getAnalysis<cfg::DominanceFrontier>(cfg::DominanceFrontier::PostDomID));
namespace {
struct AgressiveDCE : public MethodPass {
// doADCE - Execute the Agressive Dead Code Elimination Algorithm
//
virtual bool runOnMethod(Method *M) {
return ADCE(M).doADCE(
getAnalysis<cfg::DominanceFrontier>(cfg::DominanceFrontier::PostDomID));
}
// getAnalysisUsageInfo - We require post dominance frontiers (aka Control
// Dependence Graph)
virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided) {
Requires.push_back(cfg::DominanceFrontier::PostDomID);
}
};
}
// getAnalysisUsageInfo - We require post dominance frontiers (aka Control
// Dependence Graph)
//
void AgressiveDCE::getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided) {
Requires.push_back(cfg::DominanceFrontier::PostDomID);
Pass *createAgressiveDCEPass() {
return new AgressiveDCE();
}

30
lib/Transforms/Scalar/ConstantProp.cpp
View File

@ -29,6 +29,7 @@
#include "llvm/iTerminators.h"
#include "llvm/iPHINode.h"
#include "llvm/iOther.h"
#include "llvm/Pass.h"
#include "llvm/ConstantVals.h"
inline static bool
@ -153,8 +154,7 @@ bool ConstantFoldTerminator(TerminatorInst *T) {
// ConstantFoldInstruction - If an instruction references constants, try to fold
// them together...
//
bool ConstantPropogation::doConstantPropogation(BasicBlock *BB,
BasicBlock::iterator &II) {
bool doConstantPropogation(BasicBlock *BB, BasicBlock::iterator &II) {
Instruction *Inst = *II;
if (isa<BinaryOperator>(Inst)) {
Constant *D1 = dyn_cast<Constant>(Inst->getOperand(0));
@ -200,7 +200,7 @@ static bool DoConstPropPass(Method *M) {
for (Method::iterator BBI = M->begin(); BBI != M->end(); ++BBI) {
BasicBlock *BB = *BBI;
for (BasicBlock::iterator I = BB->begin(); I != BB->end(); )
if (ConstantPropogation::doConstantPropogation(BB, I))
if (doConstantPropogation(BB, I))
SomethingChanged = true;
else
++I;
@ -208,14 +208,20 @@ static bool DoConstPropPass(Method *M) {
return SomethingChanged;
}
namespace {
struct ConstantPropogation : public MethodPass {
inline bool runOnMethod(Method *M) {
bool Modified = false;
// returns whether or not the underlying method was modified
//
bool ConstantPropogation::doConstantPropogation(Method *M) {
bool Modified = false;
// Fold constants until we make no progress...
while (DoConstPropPass(M)) Modified = true;
return Modified;
// Fold constants until we make no progress...
while (DoConstPropPass(M)) Modified = true;
return Modified;
}
};
}
Pass *createConstantPropogationPass() {
return new ConstantPropogation();
}

58
lib/Transforms/Scalar/DCE.cpp
View File

@ -32,6 +32,7 @@
#include "llvm/iPHINode.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Support/CFG.h"
#include "llvm/Pass.h"
#include "Support/STLExtras.h"
#include <algorithm>
@ -40,8 +41,8 @@
// to point to the instruction that immediately succeeded the original
// instruction.
//
bool DeadCodeElimination::dceInstruction(BasicBlock::InstListType &BBIL,
BasicBlock::iterator &BBI) {
bool dceInstruction(BasicBlock::InstListType &BBIL,
BasicBlock::iterator &BBI) {
// Look for un"used" definitions...
if ((*BBI)->use_empty() && !(*BBI)->hasSideEffects() &&
!isa<TerminatorInst>(*BBI)) {
@ -55,15 +56,21 @@ static inline bool RemoveUnusedDefs(BasicBlock::InstListType &Vals) {
bool Changed = false;
for (BasicBlock::InstListType::iterator DI = Vals.begin();
DI != Vals.end(); )
if (DeadCodeElimination::dceInstruction(Vals, DI))
if (dceInstruction(Vals, DI))
Changed = true;
else
++DI;
return Changed;
}
bool DeadInstElimination::runOnBasicBlock(BasicBlock *BB) {
return RemoveUnusedDefs(BB->getInstList());
struct DeadInstElimination : public BasicBlockPass {
virtual bool runOnBasicBlock(BasicBlock *BB) {
return RemoveUnusedDefs(BB->getInstList());
}
};
Pass *createDeadInstEliminationPass() {
return new DeadInstElimination();
}
// RemoveSingularPHIs - This removes PHI nodes from basic blocks that have only
@ -297,17 +304,11 @@ static bool DoDCEPass(Method *M) {
return Changed;
}
// It is possible that we may require multiple passes over the code to fully
// eliminate dead code. Iterate until we are done.
// Remove unused global values - This removes unused global values of no
// possible value. This currently includes unused method prototypes and
// unitialized global variables.
//
bool DeadCodeElimination::doDCE(Method *M) {
bool Changed = false;
while (DoDCEPass(M)) Changed = true;
return Changed;
}
bool DeadCodeElimination::RemoveUnusedGlobalValues(Module *Mod) {
static bool RemoveUnusedGlobalValues(Module *Mod) {
bool Changed = false;
for (Module::iterator MI = Mod->begin(); MI != Mod->end(); ) {
@ -338,3 +339,30 @@ bool DeadCodeElimination::RemoveUnusedGlobalValues(Module *Mod) {
return Changed;
}
namespace {
struct DeadCodeElimination : public MethodPass {
// Pass Interface...
virtual bool doInitialization(Module *M) {
return RemoveUnusedGlobalValues(M);
}
// It is possible that we may require multiple passes over the code to fully
// eliminate dead code. Iterate until we are done.
//
virtual bool runOnMethod(Method *M) {
bool Changed = false;
while (DoDCEPass(M)) Changed = true;
return Changed;
}
virtual bool doFinalization(Module *M) {
return RemoveUnusedGlobalValues(M);
}
};
}
Pass *createDeadCodeEliminationPass() {
return new DeadCodeElimination();
}

25
lib/Transforms/Scalar/IndVarSimplify.cpp
View File

@ -13,6 +13,7 @@
#include "llvm/Type.h"
#include "llvm/BasicBlock.h"
#include "llvm/ConstantVals.h"
#include "llvm/Pass.h"
#include "llvm/Support/CFG.h"
#include "Support/STLExtras.h"
@ -186,19 +187,29 @@ static bool TransformLoop(cfg::LoopInfo *Loops, cfg::Loop *Loop) {
return Changed;
}
bool InductionVariableSimplify::doit(Method *M, cfg::LoopInfo &Loops) {
static bool doit(Method *M, cfg::LoopInfo &Loops) {
// Induction Variables live in the header nodes of the loops of the method...
return reduce_apply_bool(Loops.getTopLevelLoops().begin(),
Loops.getTopLevelLoops().end(),
std::bind1st(std::ptr_fun(TransformLoop), &Loops));
}
bool InductionVariableSimplify::runOnMethod(Method *M) {
return doit(M, getAnalysis<cfg::LoopInfo>());
namespace {
struct InductionVariableSimplify : public MethodPass {
virtual bool runOnMethod(Method *M) {
return doit(M, getAnalysis<cfg::LoopInfo>());
}
virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
Pass::AnalysisSet &Destroyed,
Pass::AnalysisSet &Provided) {
Required.push_back(cfg::LoopInfo::ID);
}
};
}
void InductionVariableSimplify::getAnalysisUsageInfo(Pass::AnalysisSet &Req,
Pass::AnalysisSet &Dest,
Pass::AnalysisSet &Prov) {
Req.push_back(cfg::LoopInfo::ID);
Pass *createIndVarSimplifyPass() {
return new InductionVariableSimplify();
}

39
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -19,6 +19,7 @@
#include "llvm/Method.h"
#include "llvm/iMemory.h"
#include "llvm/InstrTypes.h"
#include "llvm/Pass.h"
#include "llvm/Support/InstIterator.h"
#include "../TransformInternals.h"
@ -37,7 +38,15 @@ static Instruction *CombineBinOp(BinaryOperator *I) {
LocalChange = false;
Value *Op1 = I->getOperand(0);
if (Constant *Op2 = dyn_cast<Constant>(I->getOperand(1))) {
if (I->getOpcode() == Instruction::Add) {
switch (I->getOpcode()) {
case Instruction::Add:
if (I->getType()->isIntegral() && cast<ConstantInt>(Op2)->equalsInt(0)){
// Eliminate 'add int %X, 0'
I->replaceAllUsesWith(Op1); // FIXME: This breaks the worklist
LocalChange = true;
break;
}
if (Instruction *IOp1 = dyn_cast<Instruction>(Op1)) {
if (IOp1->getOpcode() == Instruction::Add &&
isa<Constant>(IOp1->getOperand(1))) {
@ -54,10 +63,23 @@ static Instruction *CombineBinOp(BinaryOperator *I) {
I->setOperand(0, IOp1->getOperand(0));
I->setOperand(1, Val);
LocalChange = true;
break;
}
}
}
break;
case Instruction::Mul:
if (I->getType()->isIntegral() && cast<ConstantInt>(Op2)->equalsInt(1)){
// Eliminate 'mul int %X, 1'
I->replaceAllUsesWith(Op1); // FIXME: This breaks the worklist
LocalChange = true;
break;
}
default:
break;
}
}
Changed |= LocalChange;
@ -110,7 +132,7 @@ static Instruction *CombineIndicies(MemAccessInst *MAI) {
return 0;
}
bool InstructionCombining::CombineInstruction(Instruction *I) {
static bool CombineInstruction(Instruction *I) {
Instruction *Result = 0;
if (BinaryOperator *BOP = dyn_cast<BinaryOperator>(I))
Result = CombineBinOp(BOP);
@ -125,8 +147,7 @@ bool InstructionCombining::CombineInstruction(Instruction *I) {
return true;
}
bool InstructionCombining::doit(Method *M) {
static bool doInstCombining(Method *M) {
// Start the worklist out with all of the instructions in the method in it.
std::vector<Instruction*> WorkList(inst_begin(M), inst_end(M));
@ -148,3 +169,13 @@ bool InstructionCombining::doit(Method *M) {
return false;
}
namespace {
struct InstructionCombining : public MethodPass {
virtual bool runOnMethod(Method *M) { return doInstCombining(M); }
};
}
Pass *createInstructionCombiningPass() {
return new InstructionCombining();
}

22
lib/Transforms/Scalar/SCCP.cpp
View File

@ -25,6 +25,7 @@
#include "llvm/iMemory.h"
#include "llvm/iTerminators.h"
#include "llvm/iOther.h"
#include "llvm/Pass.h"
#include "llvm/Assembly/Writer.h"
#include "Support/STLExtras.h"
#include <algorithm>
@ -503,11 +504,18 @@ void SCCP::OperandChangedState(User *U) {
UpdateInstruction(I);
}
// DoSparseConditionalConstantProp - Use Sparse Conditional Constant Propogation
// to prove whether a value is constant and whether blocks are used.
//
bool SCCPPass::doSCCP(Method *M) {
SCCP S(M);
return S.doSCCP();
namespace {
// SCCPPass - Use Sparse Conditional Constant Propogation
// to prove whether a value is constant and whether blocks are used.
//
struct SCCPPass : public MethodPass {
inline bool runOnMethod(Method *M) {
SCCP S(M);
return S.doSCCP();
}
};
}
Pass *createSCCPPass() {
return new SCCPPass();
}

27
lib/Transforms/Scalar/SymbolStripping.cpp
View File

@ -18,6 +18,7 @@
#include "llvm/Module.h"
#include "llvm/Method.h"
#include "llvm/SymbolTable.h"
#include "llvm/Pass.h"
static bool StripSymbolTable(SymbolTable *SymTab) {
if (SymTab == 0) return false; // No symbol table? No problem.
@ -44,16 +45,38 @@ static bool StripSymbolTable(SymbolTable *SymTab) {
// DoSymbolStripping - Remove all symbolic information from a method
//
bool SymbolStripping::doSymbolStripping(Method *M) {
static bool doSymbolStripping(Method *M) {
return StripSymbolTable(M->getSymbolTable());
}
// doStripGlobalSymbols - Remove all symbolic information from all methods
// in a module, and all module level symbols. (method names, etc...)
//
bool FullSymbolStripping::doStripGlobalSymbols(Module *M) {
static bool doStripGlobalSymbols(Module *M) {
// Remove all symbols from methods in this module... and then strip all of the
// symbols in this module...
//
return StripSymbolTable(M->getSymbolTable());
}
namespace {
struct SymbolStripping : public MethodPass {
virtual bool runOnMethod(Method *M) {
return doSymbolStripping(M);
}
};
struct FullSymbolStripping : public SymbolStripping {
virtual bool doInitialization(Module *M) {
return doStripGlobalSymbols(M);
}
};
}
Pass *createSymbolStrippingPass() {
return new SymbolStripping();
}
Pass *createFullSymbolStrippingPass() {
return new FullSymbolStripping();
}

57
lib/Transforms/Utils/LowerAllocations.cpp
View File

@ -15,9 +15,57 @@
#include "llvm/iOther.h"
#include "llvm/SymbolTable.h"
#include "llvm/ConstantVals.h"
#include "llvm/Pass.h"
#include "TransformInternals.h"
using std::vector;
namespace {
// LowerAllocations - Turn malloc and free instructions into %malloc and %free
// calls.
//
class LowerAllocations : public BasicBlockPass {
Method *MallocMeth; // Methods in the module we are processing
Method *FreeMeth; // Initialized by doInitialization
const TargetData &DataLayout;
public:
inline LowerAllocations(const TargetData &TD) : DataLayout(TD) {
MallocMeth = FreeMeth = 0;
}
// doPassInitialization - For the lower allocations pass, this ensures that a
// module contains a declaration for a malloc and a free function.
//
bool doInitialization(Module *M);
// runOnBasicBlock - This method does the actual work of converting
// instructions over, assuming that the pass has already been initialized.
//
bool runOnBasicBlock(BasicBlock *BB);
};
// RaiseAllocations - Turn %malloc and %free calls into the appropriate
// instruction.
//
class RaiseAllocations : public BasicBlockPass {
Method *MallocMeth; // Methods in the module we are processing
Method *FreeMeth; // Initialized by doPassInitializationVirt
public:
inline RaiseAllocations() : MallocMeth(0), FreeMeth(0) {}
// doPassInitialization - For the raise allocations pass, this finds a
// declaration for malloc and free if they exist.
//
bool doInitialization(Module *M);
// runOnBasicBlock - This method does the actual work of converting
// instructions over, assuming that the pass has already been initialized.
//
bool runOnBasicBlock(BasicBlock *BB);
};
} // end anonymous namespace
// doInitialization - For the lower allocations pass, this ensures that a
// module contains a declaration for a malloc and a free function.
@ -181,3 +229,12 @@ bool RaiseAllocations::runOnBasicBlock(BasicBlock *BB) {
return Changed;
}
Pass *createLowerAllocationsPass(const TargetData &TD) {
return new LowerAllocations(TD);
}
Pass *createRaiseAllocationsPass() {
return new RaiseAllocations();
}

64
tools/opt/opt.cpp
View File

@ -53,27 +53,7 @@ enum Opts {
globaldce, swapstructs, sortstructs,
};
// New template functions - Provide functions that return passes of specified
// types, with specified arguments...
//
template<class PassClass>
Pass *New() {
return new PassClass();
}
template<class PassClass, typename ArgTy1, ArgTy1 Arg1>
Pass *New() {
return new PassClass(Arg1);
}
template<class PassClass, typename ArgTy1, ArgTy1 Arg1,
typename ArgTy2, ArgTy1 Arg2>
Pass *New() {
return new PassClass(Arg1, Arg2);
}
static Pass *NewPrintMethodPass() {
static Pass *createPrintMethodPass() {
return new PrintMethodPass("Current Method: \n", &cerr);
}
@ -83,35 +63,33 @@ struct {
enum Opts OptID;
Pass * (*PassCtor)();
} OptTable[] = {
{ dce , New<DeadCodeElimination> },
{ constprop , New<ConstantPropogation> },
{ inlining , New<MethodInlining> },
{ constmerge , New<ConstantMerge> },
{ strip , New<SymbolStripping> },
{ mstrip , New<FullSymbolStripping> },
{ mergereturn, New<UnifyMethodExitNodes> },
{ dce , createDeadCodeEliminationPass },
{ constprop , createConstantPropogationPass },
{ inlining , createMethodInliningPass },
{ constmerge , createConstantMergePass },
{ strip , createSymbolStrippingPass },
{ mstrip , createFullSymbolStrippingPass },
{ mergereturn, createUnifyMethodExitNodesPass },
{ indvars , New<InductionVariableSimplify> },
{ instcombine, New<InstructionCombining> },
{ sccp , New<SCCPPass> },
{ adce , New<AgressiveDCE> },
{ raise , New<RaisePointerReferences> },
{ indvars , createIndVarSimplifyPass },
{ instcombine, createInstructionCombiningPass },
{ sccp , createSCCPPass },
{ adce , createAgressiveDCEPass },
{ raise , createRaisePointerReferencesPass },
{ mem2reg , newPromoteMemoryToRegister },
{ trace , New<InsertTraceCode, bool, true, bool, true> },
{ tracem , New<InsertTraceCode, bool, false, bool, true> },
{ trace , createTraceValuesPassForBasicBlocks },
{ tracem , createTraceValuesPassForMethod },
{ paths , createProfilePathsPass },
{ print , NewPrintMethodPass },
{ print , createPrintMethodPass },
{ verify , createVerifierPass },
{ raiseallocs, New<RaiseAllocations> },
{ cleangcc , New<CleanupGCCOutput> },
{ globaldce , New<GlobalDCE> },
{ swapstructs, New<SimpleStructMutation, SimpleStructMutation::Transform,
SimpleStructMutation::SwapElements>},
{ sortstructs, New<SimpleStructMutation, SimpleStructMutation::Transform,
SimpleStructMutation::SortElements>},
{ raiseallocs, createRaiseAllocationsPass },
{ cleangcc , createCleanupGCCOutputPass },
{ globaldce , createGlobalDCEPass },
{ swapstructs, createSwapElementsPass },
{ sortstructs, createSortElementsPass },
};
// Command line option handling code...