Add accessor function for the PruneEH pass

[oota-llvm.git] / include / llvm / Transforms / IPO.h

diff --git a/include/llvm/Transforms/IPO.h b/include/llvm/Transforms/IPO.h
index 6bdba2241d354bb06a77b386bb1c71038f75bc36..1ae3c81b469f9faa3f2d94dcb53a76b3724e2db1 100644 (file)
--- a/include/llvm/Transforms/IPO.h
+++ b/include/llvm/Transforms/IPO.h
@@ -1,42 +1,94 @@
-//===- llvm/Transforms/CleanupGCCOutput.h - Cleanup GCC Output ---*- C++ -*--=//
+//===- llvm/Transforms/IPO.h - Interprocedural Transformations --*- C++ -*-===//
 //
+// This header file defines prototypes for accessor functions that expose passes
+// in the IPO transformations library.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TRANSFORMS_CLEANUPGCCOUTPUT_H
-#define LLVM_TRANSFORMS_CLEANUPGCCOUTPUT_H
+#ifndef LLVM_TRANSFORMS_IPO_H
+#define LLVM_TRANSFORMS_IPO_H
 
-#include "llvm/Analysis/FindUsedTypes.h"
+class Pass;
+class Function;
+
+//===----------------------------------------------------------------------===//
+// 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();
+
+
+//===----------------------------------------------------------------------===//
+// 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)
+//
+Pass *createGlobalDCEPass();
+
+
+//===----------------------------------------------------------------------===//
+// createFunctionExtractionPass - This pass deletes as much of the module as
+// possible, except for the function specified.
+//
+Pass *createFunctionExtractionPass(Function *F);
 
-class CleanupGCCOutput : public MethodPass {
-  Method *Malloc, *Free;  // Pointers to external declarations, or null if none
-  FindUsedTypes FUT;      // Use FUT to eliminate type names that are never used
-public:
 
-  inline CleanupGCCOutput() : Malloc(0), Free(0) {}
+//===----------------------------------------------------------------------===//
+// 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();
 
-  // PatchUpMethodReferences - This is a part of the functionality exported by
-  // the CleanupGCCOutput pass.  This causes functions with different signatures
-  // to be linked together if they have the same name.
-  //
-  static bool PatchUpMethodReferences(Module *M);
+//===----------------------------------------------------------------------===//
+// createFunctionInliningPass - Return a new pass object that uses a heuristic
+// to inline direct function calls to small functions.
+//
+Pass *createFunctionInliningPass();
 
-  // doPassInitialization - For this pass, it removes global symbol table
-  // entries for primitive types.  These are never used for linking in GCC and
-  // they make the output uglier to look at, so we nuke them.
-  //
-  // Also, initialize instance variables.
-  //
-  bool doInitialization(Module *M);
+//===----------------------------------------------------------------------===//
+// createPruneEHPass - Return a new pass object which transforms invoke
+// instructions into calls, if the callee can _not_ unwind the stack.
+//
+Pass *createPruneEHPass();
 
-  // doPerMethodWork - This method simplifies the specified method hopefully.
-  //
-  bool runOnMethod(Method *M);
+//===----------------------------------------------------------------------===//
+// 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.  If
+// DeleteFromExternalFunctions is true, the pass will modify functions that have
+// external linkage, which is not usually safe (this is used by bugpoint to
+// reduce testcases).
+//
+Pass *createDeadArgEliminationPass(bool DeleteFromExternalFunctions=false);
 
-  // doPassFinalization - Strip out type names that are unused by the program
-  bool doFinalization(Module *M);
-private:
-  bool doOneCleanupPass(Method *M);
-};
+
+//===----------------------------------------------------------------------===//
+// These passes are wrappers that can do a few simple structure mutation
+// transformations.
+//
+Pass *createSwapElementsPass();
+Pass *createSortElementsPass();
 
 #endif