forked from OSchip/llvm-project
Do not prototype any of these passes as returning Pass*. Instead, be specific
llvm-svn: 16431
This commit is contained in:
Chris Lattner
parent
3c11c04d43
commit
1556b2722d
|
|
@ -19,7 +19,7 @@
|
|||
|
||||
namespace llvm {
|
||||
|
||||
class Pass;
|
||||
class ModulePass;
|
||||
class Function;
|
||||
class BasicBlock;
|
||||
|
||||
|
|
@ -28,7 +28,7 @@ class BasicBlock;
|
|||
/// to invoke/unwind instructions. This should really be part of the C/C++
|
||||
/// front-end, but it's so much easier to write transformations in LLVM proper.
|
||||
///
|
||||
Pass* createLowerSetJmpPass();
|
||||
ModulePass* createLowerSetJmpPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createConstantMergePass - This function returns a new pass that merges
|
||||
|
|
@ -37,35 +37,35 @@ Pass* createLowerSetJmpPass();
|
|||
/// constants into the program, regardless of whether or not they duplicate an
|
||||
/// existing string.
|
||||
///
|
||||
Pass *createConstantMergePass();
|
||||
ModulePass *createConstantMergePass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createGlobalConstifierPass - This function returns a new pass that marks
|
||||
/// internal globals "constant" if they are provably never written to.
|
||||
///
|
||||
Pass *createGlobalConstifierPass();
|
||||
ModulePass *createGlobalConstifierPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createRaiseAllocationsPass - Return a new pass that transforms malloc and
|
||||
/// free function calls into malloc and free instructions.
|
||||
///
|
||||
Pass *createRaiseAllocationsPass();
|
||||
ModulePass *createRaiseAllocationsPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createDeadTypeEliminationPass - Return a new pass that eliminates symbol
|
||||
/// table entries for types that are never used.
|
||||
///
|
||||
Pass *createDeadTypeEliminationPass();
|
||||
ModulePass *createDeadTypeEliminationPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createGlobalDCEPass - This transform is designed to eliminate unreachable
|
||||
/// internal globals (functions or global variables)
|
||||
///
|
||||
Pass *createGlobalDCEPass();
|
||||
ModulePass *createGlobalDCEPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -73,7 +73,7 @@ Pass *createGlobalDCEPass();
|
|||
/// the specified function. Otherwise, it deletes as much of the module as
|
||||
/// possible, except for the function specified.
|
||||
///
|
||||
Pass *createFunctionExtractionPass(Function *F, bool deleteFn = false);
|
||||
ModulePass *createFunctionExtractionPass(Function *F, bool deleteFn = false);
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -87,49 +87,49 @@ Pass *createFunctionExtractionPass(Function *F, bool deleteFn = false);
|
|||
///
|
||||
/// This is an interprocedural pass.
|
||||
///
|
||||
Pass *createFunctionResolvingPass();
|
||||
ModulePass *createFunctionResolvingPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createFunctionInliningPass - Return a new pass object that uses a heuristic
|
||||
/// to inline direct function calls to small functions.
|
||||
///
|
||||
Pass *createFunctionInliningPass();
|
||||
ModulePass *createFunctionInliningPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createPruneEHPass - Return a new pass object which transforms invoke
|
||||
/// instructions into calls, if the callee can _not_ unwind the stack.
|
||||
///
|
||||
Pass *createPruneEHPass();
|
||||
ModulePass *createPruneEHPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createInternalizePass - This pass loops over all of the functions in the
|
||||
/// input module, looking for a main function. If a main function is found, all
|
||||
/// other functions are marked as internal.
|
||||
///
|
||||
Pass *createInternalizePass();
|
||||
ModulePass *createInternalizePass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createDeadArgEliminationPass - This pass removes arguments from functions
|
||||
/// which are not used by the body of the function.
|
||||
///
|
||||
Pass *createDeadArgEliminationPass();
|
||||
ModulePass *createDeadArgEliminationPass();
|
||||
|
||||
/// DeadArgHacking pass - Same as DAE, but delete arguments of external
|
||||
/// functions as well. This is definitely not safe, and should only be used by
|
||||
/// bugpoint.
|
||||
Pass *createDeadArgHackingPass();
|
||||
ModulePass *createDeadArgHackingPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createArgumentPromotionPass - This pass promotes "by reference" arguments to
|
||||
/// be passed by value.
|
||||
///
|
||||
Pass *createArgumentPromotionPass();
|
||||
ModulePass *createArgumentPromotionPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createIPConstantPropagationPass - This pass propagates constants from call
|
||||
/// sites into the bodies of functions.
|
||||
///
|
||||
Pass *createIPConstantPropagationPass();
|
||||
ModulePass *createIPConstantPropagationPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -137,12 +137,12 @@ Pass *createIPConstantPropagationPass();
|
|||
/// createSingleLoopExtractorPass - This pass extracts one natural loop from the
|
||||
/// program into a function if it can. This is used by bugpoint.
|
||||
///
|
||||
Pass *createSingleLoopExtractorPass();
|
||||
ModulePass *createSingleLoopExtractorPass();
|
||||
|
||||
// createBlockExtractorPass - This pass extracts all blocks (except those
|
||||
// specified in the argument list) from the functions in the module.
|
||||
//
|
||||
Pass *llvm::createBlockExtractorPass(std::vector<BasicBlock*> &BTNE);
|
||||
ModulePass *llvm::createBlockExtractorPass(std::vector<BasicBlock*> &BTNE);
|
||||
|
||||
} // End llvm namespace
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
|
||||
namespace llvm {
|
||||
|
||||
class Pass;
|
||||
class ModulePass;
|
||||
class FunctionPass;
|
||||
class GetElementPtrInst;
|
||||
class PassInfo;
|
||||
|
|
@ -29,20 +29,20 @@ class TerminatorInst;
|
|||
// expressions as possible, by converting expressions to use getelementptr and
|
||||
// friends.
|
||||
//
|
||||
Pass *createRaisePointerReferencesPass();
|
||||
FunctionPass *createRaisePointerReferencesPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Constant Propagation Pass - A worklist driven constant propagation pass
|
||||
//
|
||||
Pass *createConstantPropagationPass();
|
||||
FunctionPass *createConstantPropagationPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Sparse Conditional Constant Propagation Pass
|
||||
//
|
||||
Pass *createSCCPPass();
|
||||
FunctionPass *createSCCPPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -51,7 +51,7 @@ Pass *createSCCPPass();
|
|||
// without modifying the CFG of the function. It is a BasicBlockPass, so it
|
||||
// runs efficiently when queued next to other BasicBlockPass's.
|
||||
//
|
||||
Pass *createDeadInstEliminationPass();
|
||||
FunctionPass *createDeadInstEliminationPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -68,7 +68,7 @@ FunctionPass *createDeadCodeEliminationPass();
|
|||
// DeadStoreElimination - This pass deletes stores that are post-dominated by
|
||||
// must-aliased stores and are not loaded used between the stores.
|
||||
//
|
||||
Pass *createDeadStoreEliminationPass();
|
||||
FunctionPass *createDeadStoreEliminationPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
|
|
@ -76,7 +76,7 @@ Pass *createDeadStoreEliminationPass();
|
|||
// algorithm assumes instructions are dead until proven otherwise, which makes
|
||||
// it more successful are removing non-obviously dead instructions.
|
||||
//
|
||||
Pass *createAggressiveDCEPass();
|
||||
FunctionPass *createAggressiveDCEPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -84,7 +84,7 @@ Pass *createAggressiveDCEPass();
|
|||
// Scalar Replacement of Aggregates - Break up alloca's of aggregates into
|
||||
// multiple allocas if possible.
|
||||
//
|
||||
Pass *createScalarReplAggregatesPass();
|
||||
FunctionPass *createScalarReplAggregatesPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
|
|
@ -117,7 +117,7 @@ FunctionPass *createGCSEPass();
|
|||
// InductionVariableSimplify - Transform induction variables in a program to all
|
||||
// use a single canonical induction variable per loop.
|
||||
//
|
||||
Pass *createIndVarSimplifyPass();
|
||||
FunctionPass *createIndVarSimplifyPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -167,7 +167,7 @@ FunctionPass *createLoopUnrollPass();
|
|||
// %Y = load int* %X
|
||||
// ret int %Y
|
||||
//
|
||||
Pass *createPromoteMemoryToRegister();
|
||||
FunctionPass *createPromoteMemoryToRegister();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -187,14 +187,14 @@ FunctionPass *createReassociatePass();
|
|||
// else
|
||||
// Y = X * Z; // = 0
|
||||
//
|
||||
Pass *createCorrelatedExpressionEliminationPass();
|
||||
FunctionPass *createCorrelatedExpressionEliminationPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// TailDuplication - Eliminate unconditional branches through controlled code
|
||||
// duplication, creating simpler CFG structures.
|
||||
//
|
||||
Pass *createTailDuplicationPass();
|
||||
FunctionPass *createTailDuplicationPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -227,7 +227,7 @@ extern const PassInfo *BreakCriticalEdgesID;
|
|||
//
|
||||
// AU.addRequiredID(LoopSimplifyID);
|
||||
//
|
||||
Pass *createLoopSimplifyPass();
|
||||
FunctionPass *createLoopSimplifyPass();
|
||||
extern const PassInfo *LoopSimplifyID;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -286,8 +286,8 @@ FunctionPass* createLowerConstantExpressionsPass();
|
|||
//
|
||||
// These functions removes symbols from functions and modules.
|
||||
//
|
||||
Pass *createSymbolStrippingPass();
|
||||
Pass *createFullSymbolStrippingPass();
|
||||
FunctionPass *createSymbolStrippingPass();
|
||||
FunctionPass *createFullSymbolStrippingPass();
|
||||
|
||||
} // End llvm namespace
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue