mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-01-30 04:35:00 +00:00
Corrected formatting.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@30942 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling
parent
4a84ad7a2b
commit
1ccc47ec38
@ -36,18 +36,16 @@ FunctionPass *createRaisePointerReferencesPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Constant Propagation Pass - A worklist driven constant propagation pass
|
||||
// ConstantPropagation - A worklist driven constant propagation pass
|
||||
//
|
||||
FunctionPass *createConstantPropagationPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Sparse Conditional Constant Propagation Pass
|
||||
// SCCP - Sparse conditional constant propagation.
|
||||
//
|
||||
FunctionPass *createSCCPPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// DeadInstElimination - This pass quickly removes trivially dead instructions
|
||||
@ -56,7 +54,6 @@ FunctionPass *createSCCPPass();
|
||||
//
|
||||
FunctionPass *createDeadInstEliminationPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// DeadCodeElimination - This pass is more powerful than DeadInstElimination,
|
||||
@ -81,15 +78,13 @@ FunctionPass *createDeadStoreEliminationPass();
|
||||
//
|
||||
FunctionPass *createAggressiveDCEPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Scalar Replacement of Aggregates - Break up alloca's of aggregates into
|
||||
// multiple allocas if possible.
|
||||
// ScalarReplAggregates - Break up alloca's of aggregates into multiple allocas
|
||||
// if possible.
|
||||
//
|
||||
FunctionPass *createScalarReplAggregatesPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// GCSE - This pass is designed to be a very quick global transformation that
|
||||
@ -99,7 +94,6 @@ FunctionPass *createScalarReplAggregatesPass();
|
||||
//
|
||||
FunctionPass *createGCSEPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// InductionVariableSimplify - Transform induction variables in a program to all
|
||||
@ -107,12 +101,11 @@ FunctionPass *createGCSEPass();
|
||||
//
|
||||
FunctionPass *createIndVarSimplifyPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// InstructionCombining - Combine instructions to form fewer, simple
|
||||
// instructions. This pass does not modify the CFG, and has a tendency to
|
||||
// make instructions dead, so a subsequent DCE pass is useful.
|
||||
// instructions. This pass does not modify the CFG, and has a tendency to make
|
||||
// instructions dead, so a subsequent DCE pass is useful.
|
||||
//
|
||||
// This pass combines things like:
|
||||
// %Y = add int 1, %X
|
||||
@ -122,7 +115,6 @@ FunctionPass *createIndVarSimplifyPass();
|
||||
//
|
||||
FunctionPass *createInstructionCombiningPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// LICM - This pass is a loop invariant code motion and memory promotion pass.
|
||||
@ -144,7 +136,6 @@ FunctionPass *createLoopStrengthReducePass(const TargetLowering *TLI = NULL);
|
||||
//
|
||||
FunctionPass *createLoopUnswitchPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// LoopUnroll - This pass is a simple loop unrolling pass.
|
||||
@ -153,8 +144,9 @@ FunctionPass *createLoopUnrollPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This pass is used to promote memory references to be register references. A
|
||||
// simple example of the transformation performed by this pass is:
|
||||
// PromoteMemoryToRegister - This pass is used to promote memory references to
|
||||
// be register references. A simple example of the transformation performed by
|
||||
// this pass is:
|
||||
//
|
||||
// FROM CODE TO CODE
|
||||
// %X = alloca int, uint 1 ret int 42
|
||||
@ -167,16 +159,17 @@ extern const PassInfo *PromoteMemoryToRegisterID;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This pass is used to demote registers to memory references .
|
||||
// In basically undoes the PromoteMemoryToRegister pass to
|
||||
// make cfg hacking easier.
|
||||
// DemoteRegisterToMemoryPass - This pass is used to demote registers to memory
|
||||
// references. In basically undoes the PromoteMemoryToRegister pass to make cfg
|
||||
// hacking easier.
|
||||
//
|
||||
FunctionPass *createDemoteRegisterToMemoryPass();
|
||||
extern const PassInfo *DemoteRegisterToMemoryID;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This pass reassociates commutative expressions in an order that is designed
|
||||
// to promote better constant propagation, GCSE, LICM, PRE...
|
||||
// Reassociate - This pass reassociates commutative expressions in an order that
|
||||
// is designed to promote better constant propagation, GCSE, LICM, PRE...
|
||||
//
|
||||
// For example: 4 + (x + 5) -> x + (4 + 5)
|
||||
//
|
||||
@ -184,7 +177,8 @@ FunctionPass *createReassociatePass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This pass eliminates correlated conditions, such as these:
|
||||
// CorrelatedExpressionElimination - This pass eliminates correlated
|
||||
// conditions, such as these:
|
||||
// if (X == 0)
|
||||
// if (X > 2) ; // Known false
|
||||
// else
|
||||
@ -192,10 +186,11 @@ FunctionPass *createReassociatePass();
|
||||
//
|
||||
FunctionPass *createCorrelatedExpressionEliminationPass();
|
||||
|
||||
|
||||
// createCondPropagationPass - This pass propagates information about
|
||||
// conditional expressions through the program, allowing it to eliminate
|
||||
// conditional branches in some cases.
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// CondPropagationPass - This pass propagates information about conditional
|
||||
// expressions through the program, allowing it to eliminate conditional
|
||||
// branches in some cases.
|
||||
//
|
||||
FunctionPass *createCondPropagationPass();
|
||||
|
||||
@ -206,7 +201,6 @@ FunctionPass *createCondPropagationPass();
|
||||
//
|
||||
FunctionPass *createTailDuplicationPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// CFGSimplification - Merge basic blocks, eliminate unreachable blocks,
|
||||
@ -214,12 +208,11 @@ FunctionPass *createTailDuplicationPass();
|
||||
//
|
||||
FunctionPass *createCFGSimplificationPass();
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// BreakCriticalEdges pass - Break all of the critical edges in the CFG by
|
||||
// inserting a dummy basic block. This pass may be "required" by passes that
|
||||
// cannot deal with critical edges. For this usage, a pass must call:
|
||||
// BreakCriticalEdges - Break all of the critical edges in the CFG by inserting
|
||||
// a dummy basic block. This pass may be "required" by passes that cannot deal
|
||||
// with critical edges. For this usage, a pass must call:
|
||||
//
|
||||
// AU.addRequiredID(BreakCriticalEdgesID);
|
||||
//
|
||||
@ -231,9 +224,9 @@ extern const PassInfo *BreakCriticalEdgesID;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// LoopSimplify pass - Insert Pre-header blocks into the CFG for every function
|
||||
// in the module. This pass updates dominator information, loop information,
|
||||
// and does not add critical edges to the CFG.
|
||||
// LoopSimplify - Insert Pre-header blocks into the CFG for every function in
|
||||
// the module. This pass updates dominator information, loop information, and
|
||||
// does not add critical edges to the CFG.
|
||||
//
|
||||
// AU.addRequiredID(LoopSimplifyID);
|
||||
//
|
||||
@ -241,17 +234,18 @@ FunctionPass *createLoopSimplifyPass();
|
||||
extern const PassInfo *LoopSimplifyID;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// This pass converts SelectInst instructions into conditional branch and PHI
|
||||
// instructions. If the OnlyFP flag is set to true, then only floating point
|
||||
// select instructions are lowered.
|
||||
//
|
||||
// LowerSelect - This pass converts SelectInst instructions into conditional
|
||||
// branch and PHI instructions. If the OnlyFP flag is set to true, then only
|
||||
// floating point select instructions are lowered.
|
||||
//
|
||||
FunctionPass *createLowerSelectPass(bool OnlyFP = false);
|
||||
extern const PassInfo *LowerSelectID;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// LowerAllocations Pass - Turn malloc and free instructions into %malloc and
|
||||
// %free calls.
|
||||
// LowerAllocations - Turn malloc and free instructions into %malloc and %free
|
||||
// calls.
|
||||
//
|
||||
// AU.addRequiredID(LowerAllocationsID);
|
||||
//
|
||||
@ -260,56 +254,66 @@ extern const PassInfo *LowerAllocationsID;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This pass eliminates call instructions to the current function which occur
|
||||
// immediately before return instructions.
|
||||
// TailCallElimination - This pass eliminates call instructions to the current
|
||||
// function which occur immediately before return instructions.
|
||||
//
|
||||
FunctionPass *createTailCallEliminationPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// This pass converts SwitchInst instructions into a sequence of chained binary
|
||||
// branch instructions.
|
||||
//
|
||||
// LowerSwitch - This pass converts SwitchInst instructions into a sequence of
|
||||
// chained binary branch instructions.
|
||||
//
|
||||
FunctionPass *createLowerSwitchPass();
|
||||
extern const PassInfo *LowerSwitchID;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// This pass converts PackedType operations into low-level scalar operations.
|
||||
//
|
||||
// LowerPacked - This pass converts PackedType operations into low-level scalar
|
||||
// operations.
|
||||
//
|
||||
FunctionPass *createLowerPackedPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// This pass converts invoke and unwind instructions to use sjlj exception
|
||||
// handling mechanisms. Note that after this pass runs the CFG is not entirely
|
||||
// accurate (exceptional control flow edges are not correct anymore) so only
|
||||
// very simple things should be done after the lowerinvoke pass has run (like
|
||||
// generation of native code). This should *NOT* be used as a general purpose
|
||||
// "my LLVM-to-LLVM pass doesn't support the invoke instruction yet" lowering
|
||||
// pass.
|
||||
//
|
||||
// LowerInvoke - This pass converts invoke and unwind instructions to use sjlj
|
||||
// exception handling mechanisms. Note that after this pass runs the CFG is not
|
||||
// entirely accurate (exceptional control flow edges are not correct anymore) so
|
||||
// only very simple things should be done after the lowerinvoke pass has run
|
||||
// (like generation of native code). This should *NOT* be used as a general
|
||||
// purpose "my LLVM-to-LLVM pass doesn't support the invoke instruction yet"
|
||||
// lowering pass.
|
||||
//
|
||||
FunctionPass *createLowerInvokePass(const TargetLowering *TLI = NULL);
|
||||
extern const PassInfo *LowerInvokePassID;
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// createLowerGCPass - This function returns an instance of the "lowergc"
|
||||
/// pass, which lowers garbage collection intrinsics to normal LLVM code.
|
||||
///
|
||||
//
|
||||
// LowerGCPass - This function returns an instance of the "lowergc" pass, which
|
||||
// lowers garbage collection intrinsics to normal LLVM code.
|
||||
//
|
||||
FunctionPass *createLowerGCPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// This pass reorders basic blocks in order to increase the number of fall-
|
||||
// through conditional branches.
|
||||
//
|
||||
// BlockPlacement - This pass reorders basic blocks in order to increase the
|
||||
// number of fall-through conditional branches.
|
||||
//
|
||||
FunctionPass *createBlockPlacementPass();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// This pass inserts phi nodes at loop boundaries to simplify other loop
|
||||
//
|
||||
// LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop
|
||||
// optimizations.
|
||||
//
|
||||
FunctionPass *createLCSSAPass();
|
||||
extern const PassInfo *LCSSAID;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// This pass collapses duplicate variables into one canonical form,
|
||||
// and tries to simplify expressions along the way.
|
||||
//
|
||||
// PredicateSimplifier - This pass collapses duplicate variables into one
|
||||
// canonical form, and tries to simplify expressions along the way.
|
||||
//
|
||||
FunctionPass *createPredicateSimplifierPass();
|
||||
|
||||
} // End llvm namespace
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user