-//===- llvm/Transforms/CleanupGCCOutput.h - Cleanup GCC Output ---*- C++ -*--=//
+//===- llvm/Transforms/IPO.h - Interprocedural Transformations --*- C++ -*-===//
//
-// These passes are used to cleanup the output of GCC. GCC's output is
-// unneccessarily gross for a couple of reasons. This pass does the following
-// things to try to clean it up:
+// This header file defines prototypes for accessor functions that expose passes
+// in the IPO transformations library.
//
-// * Eliminate names for GCC types that we know can't be needed by the user.
-// * Eliminate names for types that are unused in the entire translation unit
-// * Fix various problems that we might have in PHI nodes and casts
-// * Link uses of 'void %foo(...)' to 'void %foo(sometypes)'
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_H
+#define LLVM_TRANSFORMS_IPO_H
+
+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.
//
-// Note: This code produces dead declarations, it is a good idea to run DCE
-// after this pass.
+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.
//
+Pass *createConstantMergePass();
+
+
//===----------------------------------------------------------------------===//
+// createRaiseAllocationsPass - Return a new pass that transforms malloc and
+// free function calls into malloc and free instructions.
+//
+Pass *createRaiseAllocationsPass();
-#ifndef LLVM_TRANSFORMS_CLEANUPGCCOUTPUT_H
-#define LLVM_TRANSFORMS_CLEANUPGCCOUTPUT_H
-class Pass;
+//===----------------------------------------------------------------------===//
+// createDeadTypeEliminationPass - Return a new pass that eliminates symbol
+// table entries for types that are never used.
+//
+Pass *createDeadTypeEliminationPass();
+
-// CleanupGCCOutputPass - Perform all of the function body transformations.
+//===----------------------------------------------------------------------===//
+// createGlobalDCEPass - This transform is designed to eliminate unreachable
+// internal globals (functions or global variables)
//
-Pass *createCleanupGCCOutputPass();
+Pass *createGlobalDCEPass();
+
+//===----------------------------------------------------------------------===//
+// 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:
//
Pass *createFunctionResolvingPass();
+//===----------------------------------------------------------------------===//
+// 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.
+//
+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.
+//
+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);
+
+
+//===----------------------------------------------------------------------===//
+// These passes are wrappers that can do a few simple structure mutation
+// transformations.
+//
+Pass *createSwapElementsPass();
+Pass *createSortElementsPass();
+
#endif