mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-16 11:30:51 +00:00
370910d2a0
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8522 91177308-0d34-0410-b5e6-96231b3b80d8
109 lines
4.1 KiB
C++
109 lines
4.1 KiB
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_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.
|
|
//
|
|
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();
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// 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);
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// 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.
|
|
//
|
|
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
|