Rename createLoopExtractorPass to createSingleLoopExtractorPass

Doxygenify


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@12389 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 64 insertions, 63 deletions

diff --git a/include/llvm/Transforms/IPO.h b/include/llvm/Transforms/IPO.h
index 695dc80..24fbad6 100644
--- a/include/llvm/Transforms/IPO.h
+++ b/include/llvm/Transforms/IPO.h
@@ -21,126 +21,127 @@ class Pass;
 class Function;
 
 //===----------------------------------------------------------------------===//
-// createLowerSetJmpPass - This function lowers the setjmp/longjmp intrinsics 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.
-//
+/// createLowerSetJmpPass - This function lowers the setjmp/longjmp intrinsics
+/// 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();
 
 //===----------------------------------------------------------------------===//
-// createConstantMergePass - This function returns a new pass that merges
-// duplicate global constants together into a single constant that is shared.
-// This is useful because some passes (ie TraceValues) insert a lot of string
-// constants into the program, regardless of whether or not they duplicate an
-// existing string.
-//
+/// createConstantMergePass - This function returns a new pass that merges
+/// duplicate global constants together into a single constant that is shared.
+/// This is useful because some passes (ie TraceValues) insert a lot of string
+/// constants into the program, regardless of whether or not they duplicate an
+/// existing string.
+///
 Pass *createConstantMergePass();
 
 
 //===----------------------------------------------------------------------===//
-// createGlobalConstifierPass - This function returns a new pass that marks
-// internal globals "constant" if they are provably never written to.
-//
+/// createGlobalConstifierPass - This function returns a new pass that marks
+/// internal globals "constant" if they are provably never written to.
+///
 Pass *createGlobalConstifierPass();
 
 
 //===----------------------------------------------------------------------===//
-// createRaiseAllocationsPass - Return a new pass that transforms malloc and
-// free function calls into malloc and free instructions.
-//
+/// createRaiseAllocationsPass - Return a new pass that transforms malloc and
+/// free function calls into malloc and free instructions.
+///
 Pass *createRaiseAllocationsPass();
 
 
 //===----------------------------------------------------------------------===//
-// createDeadTypeEliminationPass - Return a new pass that eliminates symbol
-// table entries for types that are never used.
-//
+/// createDeadTypeEliminationPass - Return a new pass that eliminates symbol
+/// table entries for types that are never used.
+///
 Pass *createDeadTypeEliminationPass();
 
 
 //===----------------------------------------------------------------------===//
-// createGlobalDCEPass - This transform is designed to eliminate unreachable
-// internal globals (functions or global variables)
-//
+/// createGlobalDCEPass - This transform is designed to eliminate unreachable
+/// internal globals (functions or global variables)
+///
 Pass *createGlobalDCEPass();
 
 
 //===----------------------------------------------------------------------===//
-// createFunctionExtractionPass - This pass deletes as much of the module as
-// possible, except for the function specified.
-//
+/// createFunctionExtractionPass - This pass deletes as much of the module as
+/// possible, except for the function specified.
+///
 Pass *createFunctionExtractionPass(Function *F);
 
 
 //===----------------------------------------------------------------------===//
-// FunctionResolvingPass - Go over the functions that are in the module and
-// look for functions that have the same name.  More often than not, there will
-// be things like:
-//    void "foo"(...)
-//    void "foo"(int, int)
-// because of the way things are declared in C.  If this is the case, patch
-// things up.
-//
-// This is an interprocedural pass.
-//
+/// FunctionResolvingPass - Go over the functions that are in the module and
+/// look for functions that have the same name.  More often than not, there will
+/// be things like:
+///    void "foo"(...)
+///    void "foo"(int, int)
+/// because of the way things are declared in C.  If this is the case, patch
+/// things up.
+///
+/// This is an interprocedural pass.
+///
 Pass *createFunctionResolvingPass();
 
 //===----------------------------------------------------------------------===//
-// createFunctionInliningPass - Return a new pass object that uses a heuristic
-// to inline direct function calls to small functions.
-//
+/// createFunctionInliningPass - Return a new pass object that uses a heuristic
+/// to inline direct function calls to small functions.
+///
 Pass *createFunctionInliningPass();
 
 //===----------------------------------------------------------------------===//
-// createPruneEHPass - Return a new pass object which transforms invoke
-// instructions into calls, if the callee can _not_ unwind the stack.
-//
+/// createPruneEHPass - Return a new pass object which transforms invoke
+/// instructions into calls, if the callee can _not_ unwind the stack.
+///
 Pass *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.
-//
+/// 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();
 
 //===----------------------------------------------------------------------===//
-// createDeadArgEliminationPass - This pass removes arguments from functions
-// which are not used by the body of the function.
-//
+/// createDeadArgEliminationPass - This pass removes arguments from functions
+/// which are not used by the body of the function.
+///
 Pass *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.
+/// 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();
 
 //===----------------------------------------------------------------------===//
-// createArgumentPromotionPass - This pass promotes "by reference" arguments to
-// be passed by value.
-//
+/// createArgumentPromotionPass - This pass promotes "by reference" arguments to
+/// be passed by value.
+///
 Pass *createArgumentPromotionPass();
 
 //===----------------------------------------------------------------------===//
-// createIPConstantPropagationPass - This pass propagates constants from call
-// sites into the bodies of functions.
-//
+/// createIPConstantPropagationPass - This pass propagates constants from call
+/// sites into the bodies of functions.
+///
 Pass *createIPConstantPropagationPass();
 
 
 //===----------------------------------------------------------------------===//
-// These passes are wrappers that can do a few simple structure mutation
-// transformations.
-//
+/// These passes are wrappers that can do a few simple structure mutation
+/// transformations.
+///
 Pass *createSwapElementsPass();
 Pass *createSortElementsPass();
 
 
 //===----------------------------------------------------------------------===//
 //
-// LoopExtractor - This pass moves every natural loop into its own function.
-// Mostly useful in debugging via bugpoint.
-//
-Pass *createLoopExtractorPass();
+/// createSingleLoopExtractorPass - This pass extracts one natural loop from the
+/// program into a function if it can.  This is used by bugpoint.
+///
+Pass *createSingleLoopExtractorPass();
 
 } // End llvm namespace