6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-21 02:24:22 +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
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