llvm.org GIT mirror llvm / 4e1be6d include / llvm / Transforms / IPO.h
4e1be6d

Tree @4e1be6d (Download .tar.gz)

IPO.h @4e1be6d

5c5db0e
3469538
6fbcc26
 
 
 
3469538
6fbcc26
2fa1144
5c5db0e
 
2fa1144
 
 
03917cc
 
2fa1144
45df557
 
d0fde30
 
ecc1cef
8e47e72
c71ca3c
5113eb0
45df557
b59d819
03917cc
92f6c15
 
 
 
 
 
 
7bc91c6
 
 
 
8e47e72
370910d
 
7bc91c6
 
 
 
 
 
8e47e72
5c5db0e
 
 
93a00e4
 
7bc91c6
93a00e4
fdf6a3c
 
 
7bc91c6
 
 
8e47e72
2757af2
 
 
7bc91c6
 
 
8e47e72
2fa1144
b59d819
03917cc
7bc91c6
 
 
8e47e72
ab955c3
 
 
3469538
7d24839
 
7bc91c6
b10308e
 
5113eb0
 
 
7bc91c6
 
 
c71ca3c
ab955c3
 
7bc91c6
 
 
c71ca3c
fa7f524
 
7bc91c6
f9c6105
 
 
 
7bc91c6
f9c6105
753d94a
ab955c3
1989d34
7bc91c6
 
 
8e47e72
3323f2a
7bc91c6
 
 
8e47e72
1989d34
815904d
7bc91c6
 
 
c71ca3c
f0b6070
 
7bc91c6
 
 
8e47e72
815904d
3c05176
 
 
 
 
 
ab955c3
 
4eddf37
bf65268
 
 
ecc1cef
bf65268
7bc91c6
 
 
ecc1cef
4eddf37
ef9b9a7
 
 
4e1be6d
45df557
ef9b9a7
 
bb3d5d2
 
3433141
ef9b9a7
 
3433141
 
ef9b9a7
 
 
 
d0fde30
 
2fa1144
//===- llvm/Transforms/IPO.h - Interprocedural Transformations --*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This header file defines prototypes for accessor functions that expose passes
// in the IPO transformations library.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_TRANSFORMS_IPO_H
#define LLVM_TRANSFORMS_IPO_H

#include <vector>

namespace llvm {

class FunctionPass;
class ModulePass;
class Pass;
class Function;
class BasicBlock;

//===----------------------------------------------------------------------===//
//
// These functions removes symbols from functions and modules.  If OnlyDebugInfo
// is true, only debugging information is removed from the module.
//
ModulePass *createStripSymbolsPass(bool OnlyDebugInfo = false);

//===----------------------------------------------------------------------===//
/// 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.
///
ModulePass* 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.
///
ModulePass *createConstantMergePass();


//===----------------------------------------------------------------------===//
/// createGlobalOptimizerPass - This function returns a new pass that optimizes
/// non-address taken internal globals.
///
ModulePass *createGlobalOptimizerPass();


//===----------------------------------------------------------------------===//
/// createRaiseAllocationsPass - Return a new pass that transforms malloc and
/// free function calls into malloc and free instructions.
///
ModulePass *createRaiseAllocationsPass();


//===----------------------------------------------------------------------===//
/// createDeadTypeEliminationPass - Return a new pass that eliminates symbol
/// table entries for types that are never used.
///
ModulePass *createDeadTypeEliminationPass();


//===----------------------------------------------------------------------===//
/// createGlobalDCEPass - This transform is designed to eliminate unreachable
/// internal globals (functions or global variables)
///
ModulePass *createGlobalDCEPass();


//===----------------------------------------------------------------------===//
/// createFunctionExtractionPass - If deleteFn is true, this pass deletes as
/// the specified function. Otherwise, it deletes as much of the module as
/// possible, except for the function specified.
///
ModulePass *createFunctionExtractionPass(Function *F, bool deleteFn = false,
                                         bool relinkCallees = false);


//===----------------------------------------------------------------------===//
/// 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 list of symbols is
/// specified with the -internalize-public-api-* command line options, those
/// symbols are internalized.  Otherwise if InternalizeEverything is set and
/// the main function is found, all other globals are marked as internal.
///
ModulePass *createInternalizePass(bool InternalizeEverything);
ModulePass *createInternalizePass(const std::vector<const char *> &exportList);

//===----------------------------------------------------------------------===//
/// createDeadArgEliminationPass - This pass removes arguments from functions
/// which are not used by the body of the function.
///
ModulePass *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.
ModulePass *createDeadArgHackingPass();

//===----------------------------------------------------------------------===//
/// 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.
///
ModulePass *createIPConstantPropagationPass();

//===----------------------------------------------------------------------===//
/// createIPSCCPPass - This pass propagates constants from call sites into the
/// bodies of functions, and keeps track of whether basic blocks are executable
/// in the process.
///
ModulePass *createIPSCCPPass();

//===----------------------------------------------------------------------===//
//
/// createLoopExtractorPass - This pass extracts all natural loops from the
/// program into a function if it can.
///
FunctionPass *createLoopExtractorPass();

/// createSingleLoopExtractorPass - This pass extracts one natural loop from the
/// program into a function if it can.  This is used by bugpoint.
///
FunctionPass *createSingleLoopExtractorPass();

/// createBlockExtractorPass - This pass extracts all blocks (except those
/// specified in the argument list) from the functions in the module.
///
ModulePass *createBlockExtractorPass(const std::vector<BasicBlock*> &BTNE);

/// createOptimizeWellKnownCallsPass - This pass optimizes specific calls to
/// specific well-known (library) functions.
ModulePass *createSimplifyLibCallsPass();


/// createIndMemRemPass - This pass removes potential indirect calls of
/// malloc and free
ModulePass *createIndMemRemPass();

/// createStripDeadPrototypesPass - This pass removes any function declarations
/// (prototypes) that are not used.
ModulePass *createStripDeadPrototypesPass();

} // End llvm namespace

#endif