mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-11-01 00:11:00 +00:00
681cf74ab5
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49 91177308-0d34-0410-b5e6-96231b3b80d8
106 lines
3.3 KiB
C++
106 lines
3.3 KiB
C++
//===-- llvm/AllOpts.h - Header file to get all opt passes -------*- C++ -*--=//
|
|
//
|
|
// This file #include's all of the small optimization header files.
|
|
//
|
|
// Note that all optimizations return true if they modified the program, false
|
|
// if not.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_OPT_ALLOPTS_H
|
|
#define LLVM_OPT_ALLOPTS_H
|
|
|
|
#include "llvm/Module.h"
|
|
#include "llvm/BasicBlock.h"
|
|
#include "llvm/Tools/STLExtras.h"
|
|
class Method;
|
|
class CallInst;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Helper functions
|
|
//
|
|
|
|
static inline bool ApplyOptToAllMethods(Module *C, bool (*Opt)(Method*)) {
|
|
return reduce_apply(C->getMethodList().begin(), C->getMethodList().end(),
|
|
bitwise_or<bool>(), false, ptr_fun(Opt));
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Dead Code Elimination Pass
|
|
//
|
|
|
|
bool DoDeadCodeElimination(Method *M); // DCE a method
|
|
bool DoRemoveUnusedConstants(SymTabValue *S); // RUC a method or module
|
|
bool DoDeadCodeElimination(Module *C); // DCE & RUC a whole module
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Constant Propogation Pass
|
|
//
|
|
|
|
bool DoConstantPropogation(Method *M);
|
|
|
|
static inline bool DoConstantPropogation(Module *C) {
|
|
return ApplyOptToAllMethods(C, DoConstantPropogation);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Method Inlining Pass
|
|
//
|
|
|
|
// DoMethodInlining - Use a heuristic based approach to inline methods that seem
|
|
// to look good.
|
|
//
|
|
bool DoMethodInlining(Method *M);
|
|
|
|
static inline bool DoMethodInlining(Module *C) {
|
|
return ApplyOptToAllMethods(C, DoMethodInlining);
|
|
}
|
|
|
|
// InlineMethod - This function forcibly inlines the called method into the
|
|
// basic block of the caller. This returns true if it is not possible to inline
|
|
// this call. The program is still in a well defined state if this occurs
|
|
// though.
|
|
//
|
|
// Note that this only does one level of inlining. For example, if the
|
|
// instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now
|
|
// exists in the instruction stream. Similiarly this will inline a recursive
|
|
// method by one level.
|
|
//
|
|
bool InlineMethod(CallInst *C);
|
|
bool InlineMethod(BasicBlock::InstListType::iterator CI);// *CI must be CallInst
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Symbol Stripping Pass
|
|
//
|
|
|
|
// DoSymbolStripping - Remove all symbolic information from a method
|
|
//
|
|
bool DoSymbolStripping(Method *M);
|
|
|
|
// DoSymbolStripping - Remove all symbolic information from all methods in a
|
|
// module
|
|
//
|
|
static inline bool DoSymbolStripping(Module *M) {
|
|
return ApplyOptToAllMethods(M, DoSymbolStripping);
|
|
}
|
|
|
|
// DoFullSymbolStripping - Remove all symbolic information from all methods
|
|
// in a module, and all module level symbols. (method names, etc...)
|
|
//
|
|
bool DoFullSymbolStripping(Module *M);
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Induction Variable Cannonicalization
|
|
//
|
|
|
|
// DoInductionVariableCannonicalize - Simplify induction variables in loops
|
|
//
|
|
bool DoInductionVariableCannonicalize(Method *M);
|
|
static inline bool DoInductionVariableCannonicalize(Module *M) {
|
|
return ApplyOptToAllMethods(M, DoInductionVariableCannonicalize);
|
|
}
|
|
|
|
#endif
|