6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-07-24 22:24:54 +00:00
Code Issues Projects Releases Wiki Activity

Split AllOpts.h into lots of little .h files.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@108 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2001-06-30 04:34:07 +00:00
parent 2b05880476
commit 50d0b7ec3f
9 changed files with 214 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
include/llvm/Optimizations/AllOpts.h
View File

@@ -1,4 +1,4 @@
//===-- llvm/AllOpts.h - Header file to get all opt passes -------*- C++ -*--=//
//===-- llvm/Opt/AllOpts.h - Header file to get all opt passes ---*- C++ -*--=//
//
// This file #include's all of the small optimization header files.
//
@@ -10,136 +10,33 @@
#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;
class TerminatorInst;
//===----------------------------------------------------------------------===//
// Helper functions
// Dead Code Elimination
//
static inline bool ApplyOptToAllMethods(Module *C, bool (*Opt)(Method*)) {
return reduce_apply_bool(C->begin(), C->end(), ptr_fun(Opt));
}
#include "llvm/Optimizations/DCE.h"
//===----------------------------------------------------------------------===//
// Dead Code Elimination Pass
// Constant Propogation
//
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);
}
// ConstantFoldTerminator - If a terminator instruction is predicated on a
// constant value, convert it into an unconditional branch to the constant
// destination.
//
bool ConstantFoldTerminator(TerminatorInst *T);
//===----------------------------------------------------------------------===//
// Constant Pool Merging Pass
//
// This function merges all constants in the specified constant pool that have
// identical types and values. This is useful for passes that generate lots of
// constants as a side effect of running.
//
bool DoConstantPoolMerging(ConstantPool &CP);
bool DoConstantPoolMerging(Method *M);
static inline bool DoConstantPoolMerging(Module *M) {
return ApplyOptToAllMethods(M, DoConstantPoolMerging) |
DoConstantPoolMerging(M->getConstantPool());
}
//===----------------------------------------------------------------------===//
// Sparse Conditional Constant Propogation Pass
//
bool DoSparseConditionalConstantProp(Method *M);
static inline bool DoSparseConditionalConstantProp(Module *M) {
return ApplyOptToAllMethods(M, DoSparseConditionalConstantProp);
}
// Define a shorter version of the name...
template <class Unit> bool DoSCCP(Unit *M) {
return DoSparseConditionalConstantProp(M);
}
#include "llvm/Optimizations/ConstantProp.h"
//===----------------------------------------------------------------------===//
// 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::iterator CI); // *CI must be CallInst
#include "llvm/Optimizations/MethodInlining.h"
//===----------------------------------------------------------------------===//
// 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);
#include "llvm/Optimizations/SymbolStripping.h"
//===----------------------------------------------------------------------===//
// Induction Variable Cannonicalization
//
// DoInductionVariableCannonicalize - Simplify induction variables in loops
//
bool DoInductionVariableCannonicalize(Method *M);
static inline bool DoInductionVariableCannonicalize(Module *M) {
return ApplyOptToAllMethods(M, DoInductionVariableCannonicalize);
}
#include "llvm/Optimizations/InductionVars.h"
#endif