From 1ccc47ec386e6726ca76955b0e739328a49a65c5 Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Fri, 13 Oct 2006 20:53:50 +0000 Subject: [PATCH] Corrected formatting. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@30942 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Transforms/Scalar.h | 128 ++++++++++++++++--------------- 1 file changed, 66 insertions(+), 62 deletions(-) diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index 85242f8a77d..4b388874392 100644 --- a/include/llvm/Transforms/Scalar.h +++ b/include/llvm/Transforms/Scalar.h @@ -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,20 +201,18 @@ FunctionPass *createCondPropagationPass(); // FunctionPass *createTailDuplicationPass(); - //===----------------------------------------------------------------------===// // -// CFG Simplification - Merge basic blocks, eliminate unreachable blocks, +// CFGSimplification - Merge basic blocks, eliminate unreachable blocks, // simplify terminator instructions, etc... // 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 -- 2.34.1