RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-24 04:09:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Do not prototype any of these passes as returning Pass*. Instead, be specific

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@16431 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2004-09-20 04:41:39 +00:00
parent f627892e26
commit 8e47e7292c
2 changed files with 33 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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

30
include/llvm/Transforms/Scalar.h
View File

@ -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