remove StandardPasses, it has been replaced with PassManagerBuilder
llvm-svn: 131827
This commit is contained in:
Chris Lattner
parent
3d70addad7
commit
b5865ded27
|
|
@ -1,403 +0,0 @@
|
|||
//===-- llvm/Support/StandardPasses.h - Standard pass lists -----*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This file defines utility functions for creating a "standard" set of
|
||||
// optimization passes, so that compilers and tools which use optimization
|
||||
// passes use the same set of standard passes.
|
||||
//
|
||||
// These are implemented as inline functions so that we do not have to worry
|
||||
// about link issues.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_SUPPORT_STANDARDPASSES_H
|
||||
#define LLVM_SUPPORT_STANDARDPASSES_H
|
||||
|
||||
#include "llvm/PassManager.h"
|
||||
#include "llvm/DefaultPasses.h"
|
||||
#include "llvm/Analysis/Passes.h"
|
||||
#include "llvm/Analysis/Verifier.h"
|
||||
#include "llvm/Transforms/Scalar.h"
|
||||
#include "llvm/Transforms/IPO.h"
|
||||
|
||||
namespace llvm {
|
||||
//template<Pass*(*X)(void)> static Pass *CreatePassFn(void) { return X(); }
|
||||
|
||||
/// RegisterStandardPassLists solves a circular dependency problem. The
|
||||
/// default list of passes has to live somewhere. It can't live in the core
|
||||
/// modules, because these don't link to the libraries that actually define
|
||||
/// the passes. It's in this header, so that a copy is created in every
|
||||
/// library that requests the default set, while still allowing plugins to
|
||||
/// register new passes without requiring them to link anything more than
|
||||
/// VMCore.
|
||||
class RegisterStandardPassLists {
|
||||
public:
|
||||
RegisterStandardPassLists() {
|
||||
StandardPass::RegisterDefaultPasses = RegisterStandardPassList;
|
||||
StandardPass::CreateVerifierPass = CreateVerifierPass;
|
||||
}
|
||||
private:
|
||||
/// Define a set of function overloads that does the casting for us, so
|
||||
/// that we can perform safe function pointer casts, but catch unsafe ones.
|
||||
PassInfo::NormalCtor_t static CreatePassFn(llvm::ImmutablePass*(*X)(void)) {
|
||||
return reinterpret_cast<PassInfo::NormalCtor_t>(X);
|
||||
}
|
||||
PassInfo::NormalCtor_t static CreatePassFn(llvm::ModulePass*(*X)(void)) {
|
||||
return reinterpret_cast<PassInfo::NormalCtor_t>(X);
|
||||
}
|
||||
PassInfo::NormalCtor_t static CreatePassFn(llvm::FunctionPass*(*X)(void)) {
|
||||
return reinterpret_cast<PassInfo::NormalCtor_t>(X);
|
||||
}
|
||||
PassInfo::NormalCtor_t static CreatePassFn(llvm::Pass*(*X)(void)) {
|
||||
return reinterpret_cast<PassInfo::NormalCtor_t>(X);
|
||||
}
|
||||
|
||||
static llvm::Pass *CreateVerifierPass() { return createVerifierPass(); }
|
||||
/// Passes must be registered with functions that take no arguments, so we have
|
||||
/// to wrap their existing constructors.
|
||||
static Pass *createScalarReplAggregatesPass(void) {
|
||||
return llvm::createScalarReplAggregatesPass();
|
||||
}
|
||||
static Pass *createSSAScalarReplAggregatesPass(void) {
|
||||
return llvm::createScalarReplAggregatesPass(-1, false);
|
||||
}
|
||||
static Pass *createDefaultLoopUnswitchPass(void) {
|
||||
return createLoopUnswitchPass(false);
|
||||
}
|
||||
static Pass *createSizeOptimizingLoopUnswitchPass(void) {
|
||||
return createLoopUnswitchPass(true);
|
||||
}
|
||||
static Pass *createArgumentPromotionPass(void) {
|
||||
return llvm::createArgumentPromotionPass();
|
||||
}
|
||||
static Pass *createLoopUnrollPass(void) {
|
||||
return llvm::createLoopUnrollPass();
|
||||
}
|
||||
static Pass *createGVNPass(void) {
|
||||
return llvm::createGVNPass();
|
||||
}
|
||||
static void RegisterStandardPassList(void) {
|
||||
// Standard alias analysis passes
|
||||
|
||||
// Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
|
||||
// BasicAliasAnalysis wins if they disagree. This is intended to help
|
||||
// support "obvious" type-punning idioms.
|
||||
#define DEFAULT_ALIAS_ANALYSIS_PASS(pass, flags)\
|
||||
StandardPass::RegisterDefaultPass(\
|
||||
CreatePassFn(create ## pass ## Pass),\
|
||||
&DefaultStandardPasses::pass ## ID, (unsigned char*)0, StandardPass::AliasAnalysis, flags)
|
||||
DEFAULT_ALIAS_ANALYSIS_PASS(TypeBasedAliasAnalysis, 0);
|
||||
DEFAULT_ALIAS_ANALYSIS_PASS(BasicAliasAnalysis, 0);
|
||||
#undef DEFAULT_ALIAS_ANALYSIS_PASS
|
||||
|
||||
#define DEFAULT_FUNCTION_PASS(pass, flags)\
|
||||
StandardPass::RegisterDefaultPass(\
|
||||
CreatePassFn(create ## pass ## Pass),\
|
||||
&DefaultStandardPasses::pass ## ID, 0, StandardPass::Function, flags)
|
||||
DEFAULT_FUNCTION_PASS(CFGSimplification,
|
||||
StandardPass::OptimzationFlags(1));
|
||||
DEFAULT_FUNCTION_PASS(ScalarReplAggregates,
|
||||
StandardPass::OptimzationFlags(1));
|
||||
DEFAULT_FUNCTION_PASS(EarlyCSE, StandardPass::OptimzationFlags(1));
|
||||
#undef DEFAULT_FUNCTION_PASS
|
||||
|
||||
#define DEFAULT_MODULE_PASS(pass, flags)\
|
||||
StandardPass::RegisterDefaultPass(\
|
||||
CreatePassFn(create ## pass ## Pass),\
|
||||
&DefaultStandardPasses::pass ## ID, 0, StandardPass::Module, flags)
|
||||
// Optimize out global vars
|
||||
DEFAULT_MODULE_PASS(GlobalOptimizer,
|
||||
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
|
||||
// IP SCCP
|
||||
DEFAULT_MODULE_PASS(IPSCCP,
|
||||
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
|
||||
// Dead argument elimination
|
||||
DEFAULT_MODULE_PASS(DeadArgElimination,
|
||||
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
|
||||
// Clean up after IPCP & DAE
|
||||
DEFAULT_MODULE_PASS(InstructionCombining,
|
||||
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
|
||||
// Clean up after IPCP & DAE
|
||||
DEFAULT_MODULE_PASS(CFGSimplification,
|
||||
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
|
||||
|
||||
// Remove dead EH info
|
||||
DEFAULT_MODULE_PASS(PruneEH, StandardPass::OptimzationFlags(0, 0,
|
||||
StandardPass::UnitAtATime | StandardPass::HaveExceptions));
|
||||
// Placeholder that will be replaced by an inliner if one is specified
|
||||
StandardPass::RegisterDefaultPass(0,
|
||||
&DefaultStandardPasses::InlinerPlaceholderID, 0,
|
||||
StandardPass::Module);
|
||||
// Set readonly/readnone attrs
|
||||
DEFAULT_MODULE_PASS(FunctionAttrs, StandardPass::OptimzationFlags(0, 0,
|
||||
StandardPass::UnitAtATime));
|
||||
// Scalarize uninlined fn args
|
||||
DEFAULT_MODULE_PASS(ArgumentPromotion, StandardPass::OptimzationFlags(3));
|
||||
// Start of function pass.
|
||||
// Break up aggregate allocas, using SSAUpdater.
|
||||
StandardPass::RegisterDefaultPass(
|
||||
CreatePassFn(createSSAScalarReplAggregatesPass),
|
||||
&DefaultStandardPasses::ScalarReplAggregatesID, 0,
|
||||
StandardPass::Module, 0);
|
||||
// Catch trivial redundancies
|
||||
DEFAULT_MODULE_PASS(EarlyCSE, 0);
|
||||
// Library Call Optimizations
|
||||
DEFAULT_MODULE_PASS(SimplifyLibCalls,
|
||||
StandardPass::OptimzationFlags(0, 0, StandardPass::SimplifyLibCalls));
|
||||
// Thread jumps
|
||||
DEFAULT_MODULE_PASS(JumpThreading, 0);
|
||||
// Propagate conditionals
|
||||
DEFAULT_MODULE_PASS(CorrelatedValuePropagation, 0);
|
||||
// Merge & remove BBs
|
||||
DEFAULT_MODULE_PASS(CFGSimplification, 0);
|
||||
// Combine silly seq's
|
||||
DEFAULT_MODULE_PASS(InstructionCombining, 0);
|
||||
// Eliminate tail calls
|
||||
DEFAULT_MODULE_PASS(TailCallElimination, 0);
|
||||
// Merge & remove BBs
|
||||
DEFAULT_MODULE_PASS(CFGSimplification, 0);
|
||||
// Reassociate expressions
|
||||
DEFAULT_MODULE_PASS(Reassociate, 0);
|
||||
// Rotate Loop
|
||||
DEFAULT_MODULE_PASS(LoopRotate, 0);
|
||||
// Hoist loop invariants
|
||||
DEFAULT_MODULE_PASS(LICM, 0);
|
||||
// Optimize for size if the optimzation level is 0-2
|
||||
StandardPass::RegisterDefaultPass(
|
||||
CreatePassFn(createSizeOptimizingLoopUnswitchPass),
|
||||
&DefaultStandardPasses::LoopUnswitchID, 0,
|
||||
StandardPass::Module,
|
||||
StandardPass::OptimzationFlags(0, 2));
|
||||
// Optimize for size if the optimzation level is >2, and OptimizeSize is
|
||||
// set
|
||||
StandardPass::RegisterDefaultPass(
|
||||
CreatePassFn(createSizeOptimizingLoopUnswitchPass),
|
||||
&DefaultStandardPasses::LoopUnswitchID, 0,
|
||||
StandardPass::Module,
|
||||
StandardPass::OptimzationFlags(3, 0, StandardPass::OptimizeSize));
|
||||
// Don't optimize for size if optimisation level is >2 and OptimizeSize
|
||||
// is not set
|
||||
StandardPass::RegisterDefaultPass(
|
||||
CreatePassFn(createDefaultLoopUnswitchPass),
|
||||
&DefaultStandardPasses::LoopUnswitchID, 0,
|
||||
StandardPass::Module,
|
||||
StandardPass::OptimzationFlags(3, 0, 0, StandardPass::OptimizeSize));
|
||||
DEFAULT_MODULE_PASS(InstructionCombining, 0);
|
||||
// Canonicalize indvars
|
||||
DEFAULT_MODULE_PASS(IndVarSimplify, 0);
|
||||
// Recognize idioms like memset.
|
||||
DEFAULT_MODULE_PASS(LoopIdiom, 0);
|
||||
// Delete dead loops
|
||||
DEFAULT_MODULE_PASS(LoopDeletion, 0);
|
||||
// Unroll small loops
|
||||
DEFAULT_MODULE_PASS(LoopUnroll,
|
||||
StandardPass::OptimzationFlags(0, 0, StandardPass::UnrollLoops));
|
||||
// Remove redundancies
|
||||
DEFAULT_MODULE_PASS(GVN, StandardPass::OptimzationFlags(2));
|
||||
// Remove memcpy / form memset
|
||||
DEFAULT_MODULE_PASS(MemCpyOpt, 0);
|
||||
// Constant prop with SCCP
|
||||
DEFAULT_MODULE_PASS(SCCP, 0);
|
||||
|
||||
// Run instcombine after redundancy elimination to exploit opportunities
|
||||
// opened up by them.
|
||||
DEFAULT_MODULE_PASS(InstructionCombining, 0);
|
||||
// Thread jumps
|
||||
DEFAULT_MODULE_PASS(JumpThreading, 0);
|
||||
DEFAULT_MODULE_PASS(CorrelatedValuePropagation, 0);
|
||||
// Delete dead stores
|
||||
DEFAULT_MODULE_PASS(DeadStoreElimination, 0);
|
||||
// Delete dead instructions
|
||||
DEFAULT_MODULE_PASS(AggressiveDCE, 0);
|
||||
// Merge & remove BBs
|
||||
DEFAULT_MODULE_PASS(CFGSimplification, 0);
|
||||
// Clean up after everything.
|
||||
DEFAULT_MODULE_PASS(InstructionCombining, 0);
|
||||
|
||||
// Get rid of dead prototypes
|
||||
DEFAULT_MODULE_PASS(StripDeadPrototypes,
|
||||
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
|
||||
// Eliminate dead types
|
||||
DEFAULT_MODULE_PASS(DeadTypeElimination,
|
||||
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
|
||||
|
||||
// GlobalOpt already deletes dead functions and globals, at -O3 try a
|
||||
// late pass of GlobalDCE. It is capable of deleting dead cycles.
|
||||
// Remove dead fns and globals.
|
||||
DEFAULT_MODULE_PASS(GlobalDCE,
|
||||
StandardPass::OptimzationFlags(3, 0, StandardPass::UnitAtATime));
|
||||
// Merge dup global constants
|
||||
DEFAULT_MODULE_PASS(ConstantMerge,
|
||||
StandardPass::OptimzationFlags(2, 0, StandardPass::UnitAtATime));
|
||||
#undef DEFAULT_MODULE_PASS
|
||||
|
||||
#define DEFAULT_LTO_PASS(pass, flags)\
|
||||
StandardPass::RegisterDefaultPass(\
|
||||
CreatePassFn(create ## pass ## Pass),\
|
||||
&DefaultStandardPasses::pass ## ID, 0, StandardPass::LTO, flags)
|
||||
|
||||
// LTO passes
|
||||
|
||||
// Propagate constants at call sites into the functions they call. This
|
||||
// opens opportunities for globalopt (and inlining) by substituting function
|
||||
// pointers passed as arguments to direct uses of functions.
|
||||
DEFAULT_LTO_PASS(IPSCCP, 0);
|
||||
|
||||
// Now that we internalized some globals, see if we can hack on them!
|
||||
DEFAULT_LTO_PASS(GlobalOptimizer, 0);
|
||||
|
||||
// Linking modules together can lead to duplicated global constants, only
|
||||
// keep one copy of each constant...
|
||||
DEFAULT_LTO_PASS(ConstantMerge, 0);
|
||||
|
||||
// Remove unused arguments from functions...
|
||||
DEFAULT_LTO_PASS(DeadArgElimination, 0);
|
||||
|
||||
// Reduce the code after globalopt and ipsccp. Both can open up significant
|
||||
// simplification opportunities, and both can propagate functions through
|
||||
// function pointers. When this happens, we often have to resolve varargs
|
||||
// calls, etc, so let instcombine do this.
|
||||
DEFAULT_LTO_PASS(InstructionCombining, 0);
|
||||
|
||||
// Inline small functions
|
||||
DEFAULT_LTO_PASS(FunctionInlining,
|
||||
StandardPass::OptimzationFlags(0, 0xf, StandardPass::RunInliner));
|
||||
// Remove dead EH info.
|
||||
DEFAULT_LTO_PASS(PruneEH, 0);
|
||||
// Optimize globals again if we ran the inliner.
|
||||
DEFAULT_LTO_PASS(GlobalOptimizer,
|
||||
StandardPass::OptimzationFlags(0, 0xf, StandardPass::RunInliner));
|
||||
DEFAULT_LTO_PASS(GlobalDCE, 0);
|
||||
|
||||
// If we didn't decide to inline a function, check to see if we can
|
||||
// transform it to pass arguments by value instead of by reference.
|
||||
DEFAULT_LTO_PASS(ArgumentPromotion, 0);
|
||||
|
||||
// The IPO passes may leave cruft around. Clean up after them.
|
||||
DEFAULT_LTO_PASS(InstructionCombining, 0);
|
||||
DEFAULT_LTO_PASS(JumpThreading, 0);
|
||||
// Break up allocas
|
||||
DEFAULT_LTO_PASS(ScalarReplAggregates, 0);
|
||||
|
||||
// Run a few AA driven optimizations here and now, to cleanup the code.
|
||||
// Add nocapture.
|
||||
DEFAULT_LTO_PASS(FunctionAttrs, 0);
|
||||
// IP alias analysis.
|
||||
DEFAULT_LTO_PASS(GlobalsModRef, 0);
|
||||
|
||||
// Hoist loop invariants.
|
||||
DEFAULT_LTO_PASS(LICM, 0);
|
||||
// Remove redundancies.
|
||||
DEFAULT_LTO_PASS(GVN, 0);
|
||||
// Remove dead memcpys.
|
||||
DEFAULT_LTO_PASS(MemCpyOpt, 0);
|
||||
// Nuke dead stores.
|
||||
DEFAULT_LTO_PASS(DeadStoreElimination, 0);
|
||||
|
||||
// Cleanup and simplify the code after the scalar optimizations.
|
||||
DEFAULT_LTO_PASS(InstructionCombining, 0);
|
||||
|
||||
DEFAULT_LTO_PASS(JumpThreading, 0);
|
||||
|
||||
// Delete basic blocks, which optimization passes may have killed.
|
||||
DEFAULT_LTO_PASS(CFGSimplification, 0);
|
||||
|
||||
// Now that we have optimized the program, discard unreachable functions.
|
||||
DEFAULT_LTO_PASS(GlobalDCE, 0);
|
||||
#undef DEFAULT_LTO_PASS
|
||||
}
|
||||
};
|
||||
static RegisterStandardPassLists AutoRegister;
|
||||
|
||||
|
||||
static inline void createStandardAliasAnalysisPasses(PassManagerBase *PM) {
|
||||
StandardPass::AddPassesFromSet(PM, StandardPass::AliasAnalysis);
|
||||
}
|
||||
|
||||
/// createStandardFunctionPasses - Add the standard list of function passes to
|
||||
/// the provided pass manager.
|
||||
///
|
||||
/// \arg OptimizationLevel - The optimization level, corresponding to -O0,
|
||||
/// -O1, etc.
|
||||
static inline void createStandardFunctionPasses(PassManagerBase *PM,
|
||||
unsigned OptimizationLevel) {
|
||||
StandardPass::AddPassesFromSet(PM, StandardPass::AliasAnalysis);
|
||||
StandardPass::AddPassesFromSet(PM, StandardPass::Function, OptimizationLevel);
|
||||
}
|
||||
|
||||
/// createStandardModulePasses - Add the standard list of module passes to the
|
||||
/// provided pass manager.
|
||||
///
|
||||
/// \arg OptimizationLevel - The optimization level, corresponding to -O0,
|
||||
/// -O1, etc.
|
||||
/// \arg OptimizeSize - Whether the transformations should optimize for size.
|
||||
/// \arg UnitAtATime - Allow passes which may make global module changes.
|
||||
/// \arg UnrollLoops - Allow loop unrolling.
|
||||
/// \arg SimplifyLibCalls - Allow library calls to be simplified.
|
||||
/// \arg HaveExceptions - Whether the module may have code using exceptions.
|
||||
/// \arg InliningPass - The inlining pass to use, if any, or null. This will
|
||||
/// always be added, even at -O0.
|
||||
static inline void createStandardModulePasses(PassManagerBase *PM,
|
||||
unsigned OptimizationLevel,
|
||||
bool OptimizeSize,
|
||||
bool UnitAtATime,
|
||||
bool UnrollLoops,
|
||||
bool SimplifyLibCalls,
|
||||
bool HaveExceptions,
|
||||
Pass *InliningPass) {
|
||||
createStandardAliasAnalysisPasses(PM);
|
||||
|
||||
// If all optimizations are disabled, just run the always-inline pass.
|
||||
if (OptimizationLevel == 0) {
|
||||
if (InliningPass)
|
||||
PM->add(InliningPass);
|
||||
return;
|
||||
}
|
||||
|
||||
StandardPass::AddPassesFromSet(PM, StandardPass::Module,
|
||||
StandardPass::OptimzationFlags(OptimizationLevel, 0,
|
||||
(OptimizeSize ? StandardPass::OptimizeSize : 0) |
|
||||
(UnitAtATime ? StandardPass::UnitAtATime : 0) |
|
||||
(UnrollLoops ? StandardPass::UnrollLoops : 0) |
|
||||
(SimplifyLibCalls ? StandardPass::SimplifyLibCalls : 0) |
|
||||
(HaveExceptions ? StandardPass::HaveExceptions : 0)),
|
||||
false,
|
||||
InliningPass);
|
||||
|
||||
}
|
||||
|
||||
/// createStandardLTOPasses - Add the standard list of module passes suitable
|
||||
/// for link time optimization.
|
||||
///
|
||||
/// Internalize - Run the internalize pass.
|
||||
/// RunInliner - Use a function inlining pass.
|
||||
/// VerifyEach - Run the verifier after each pass.
|
||||
static inline void createStandardLTOPasses(PassManagerBase *PM,
|
||||
bool Internalize,
|
||||
bool RunInliner,
|
||||
bool VerifyEach) {
|
||||
// Provide AliasAnalysis services for optimizations.
|
||||
createStandardAliasAnalysisPasses(PM);
|
||||
|
||||
// Now that composite has been compiled, scan through the module, looking
|
||||
// for a main function. If main is defined, mark all other functions
|
||||
// internal.
|
||||
if (Internalize) {
|
||||
PM->add(createInternalizePass(true));
|
||||
if (VerifyEach)
|
||||
PM->add(createVerifierPass());
|
||||
}
|
||||
|
||||
StandardPass::AddPassesFromSet(PM, StandardPass::LTO,
|
||||
StandardPass::OptimzationFlags(0, 0, RunInliner ?
|
||||
StandardPass::RunInliner : 0), VerifyEach);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -28,7 +28,6 @@ add_llvm_library(LLVMCore
|
|||
PassManager.cpp
|
||||
PassRegistry.cpp
|
||||
PrintModulePass.cpp
|
||||
StandardPasses.cpp
|
||||
Type.cpp
|
||||
TypeSymbolTable.cpp
|
||||
Use.cpp
|
||||
|
|
|
|||
|
|
@ -1,247 +0,0 @@
|
|||
//===-- lib/Support/StandardPasses.cpp - Standard pass lists -----*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This file defines utility functions for creating a "standard" set of
|
||||
// optimization passes, so that compilers and tools which use optimization
|
||||
// passes use the same set of standard passes.
|
||||
//
|
||||
// This allows the creation of multiple standard sets, and their later
|
||||
// modification by plugins and front ends.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/PassManager.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/ManagedStatic.h"
|
||||
#include "llvm/DefaultPasses.h"
|
||||
#include "llvm/Support/Mutex.h"
|
||||
|
||||
using namespace llvm::DefaultStandardPasses;
|
||||
using namespace llvm;
|
||||
|
||||
namespace {
|
||||
|
||||
/// Entry in the standard passes list.
|
||||
struct StandardPassEntry {
|
||||
/// Function called to create the pass
|
||||
PassInfo::NormalCtor_t createPass;
|
||||
/// Unique identifier for this pass
|
||||
unsigned char *passID;
|
||||
/// Flags specifying when this pass should be run
|
||||
unsigned flags;
|
||||
|
||||
StandardPassEntry(PassInfo::NormalCtor_t constructor, unsigned char *ID,
|
||||
unsigned f) : createPass(constructor), passID(ID), flags(f) {}
|
||||
};
|
||||
|
||||
/// Standard alias analysis passes
|
||||
static llvm::SmallVector<StandardPassEntry, 4> AAPasses;
|
||||
/// Standard function passes
|
||||
static llvm::SmallVector<StandardPassEntry, 32> FunctionPasses;
|
||||
/// Standard module passes
|
||||
static llvm::SmallVector<StandardPassEntry, 32> ModulePasses;
|
||||
/// Standard link-time optimization passes
|
||||
static llvm::SmallVector<StandardPassEntry, 32> LTOPasses;
|
||||
|
||||
/// Entry in the unresolved standard pass list. IF a pass is inserted in front
|
||||
/// of a pass that is not yet registered in the standard pass list then it is
|
||||
/// stored in a separate list and resolved later.
|
||||
struct UnresolvedStandardPass : public StandardPassEntry {
|
||||
/// The set into which this is stored
|
||||
StandardPass::StandardSet set;
|
||||
/// The unique ID of the pass that should follow this one in the sequence
|
||||
unsigned char *next;
|
||||
UnresolvedStandardPass(PassInfo::NormalCtor_t constructor,
|
||||
unsigned char *newPass,
|
||||
unsigned char *oldPass,
|
||||
StandardPass::StandardSet s,
|
||||
unsigned f) :
|
||||
StandardPassEntry(constructor, newPass, f), set(s), next(oldPass) {}
|
||||
};
|
||||
|
||||
/// The passes that can not be inserted into the correct lists yet because of
|
||||
/// their place in the sequence.
|
||||
static llvm::SmallVector<UnresolvedStandardPass, 16> UnresolvedPasses;
|
||||
|
||||
/// Returns a reference to the pass list for the corresponding set of
|
||||
/// optimisations.
|
||||
llvm::SmallVectorImpl<StandardPassEntry>&
|
||||
PassList(StandardPass::StandardSet set) {
|
||||
switch (set) {
|
||||
case StandardPass::AliasAnalysis: return AAPasses;
|
||||
case StandardPass::Function: return FunctionPasses;
|
||||
case StandardPass::Module: return ModulePasses;
|
||||
case StandardPass::LTO: return LTOPasses;
|
||||
}
|
||||
// We could use a map of standard pass lists to allow definition of new
|
||||
// default sets
|
||||
llvm_unreachable("Invalid standard optimization set requested");
|
||||
}
|
||||
|
||||
static ManagedStatic<sys::SmartMutex<true> > Lock;
|
||||
|
||||
/// Registers the default set of standard passes. This is called lazily when
|
||||
/// an attempt is made to read or modify the standard pass list
|
||||
void RegisterDefaultStandardPasses(void(*doRegister)(void)) {
|
||||
// Only initialize the standard passes once
|
||||
static volatile bool initialized = false;
|
||||
if (initialized) return;
|
||||
|
||||
llvm::sys::SmartScopedLock<true> Guard(*Lock);
|
||||
if (initialized) return;
|
||||
if (doRegister) {
|
||||
assert("No passes registered before setting default passes" &&
|
||||
AAPasses.size() == 0 &&
|
||||
FunctionPasses.size() == 0 &&
|
||||
LTOPasses.size() == 0 &&
|
||||
ModulePasses.size() == 0);
|
||||
|
||||
// We must set initialized to true before calling this function, because
|
||||
// the doRegister() function will probably call RegisterDefaultPasses(),
|
||||
// which will call this function, and we'd end up with infinite recursion
|
||||
// and breakage if we didn't.
|
||||
initialized = true;
|
||||
doRegister();
|
||||
}
|
||||
}
|
||||
|
||||
} // Anonymous namespace
|
||||
|
||||
void (*StandardPass::RegisterDefaultPasses)(void);
|
||||
Pass* (*StandardPass::CreateVerifierPass)(void);
|
||||
|
||||
void StandardPass::RegisterDefaultPass(PassInfo::NormalCtor_t constructor,
|
||||
unsigned char *newPass,
|
||||
unsigned char *oldPass,
|
||||
StandardPass::StandardSet set,
|
||||
unsigned flags) {
|
||||
// Make sure that the standard sets are already regstered
|
||||
RegisterDefaultStandardPasses(RegisterDefaultPasses);
|
||||
// Get the correct list to modify
|
||||
llvm::SmallVectorImpl<StandardPassEntry>& passList = PassList(set);
|
||||
|
||||
// If there is no old pass specified, then we are adding a new final pass, so
|
||||
// just push it onto the end.
|
||||
if (!oldPass) {
|
||||
StandardPassEntry pass(constructor, newPass, flags);
|
||||
passList.push_back(pass);
|
||||
return;
|
||||
}
|
||||
|
||||
// Find the correct place to insert the pass. This is a linear search, but
|
||||
// this shouldn't be too slow since the SmallVector will store the values in
|
||||
// a contiguous block of memory. Each entry is just three words of memory, so
|
||||
// in most cases we are only going to be looking in one or two cache lines.
|
||||
// The extra memory accesses from a more complex search structure would
|
||||
// offset any performance gain (unless someone decides to add an insanely
|
||||
// large set of standard passes to a set)
|
||||
for (SmallVectorImpl<StandardPassEntry>::iterator i=passList.begin(),
|
||||
e=passList.end() ; i!=e ; ++i) {
|
||||
if (i->passID == oldPass) {
|
||||
StandardPassEntry pass(constructor, newPass, flags);
|
||||
passList.insert(i, pass);
|
||||
// If we've added a new pass, then there may have gained the ability to
|
||||
// insert one of the previously unresolved ones. If so, insert the new
|
||||
// one.
|
||||
for (SmallVectorImpl<UnresolvedStandardPass>::iterator
|
||||
u=UnresolvedPasses.begin(), eu=UnresolvedPasses.end() ; u!=eu ; ++u){
|
||||
if (u->next == newPass && u->set == set) {
|
||||
UnresolvedStandardPass p = *u;
|
||||
UnresolvedPasses.erase(u);
|
||||
RegisterDefaultPass(p.createPass, p.passID, p.next, p.set, p.flags);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
// If we get to here, then we didn't find the correct place to insert the new
|
||||
// pass
|
||||
UnresolvedStandardPass pass(constructor, newPass, oldPass, set, flags);
|
||||
UnresolvedPasses.push_back(pass);
|
||||
}
|
||||
|
||||
void StandardPass::AddPassesFromSet(PassManagerBase *PM,
|
||||
StandardSet set,
|
||||
unsigned flags,
|
||||
bool VerifyEach,
|
||||
Pass *inliner) {
|
||||
RegisterDefaultStandardPasses(RegisterDefaultPasses);
|
||||
unsigned level = OptimizationLevel(flags);
|
||||
flags = RequiredFlags(flags);
|
||||
llvm::SmallVectorImpl<StandardPassEntry>& passList = PassList(set);
|
||||
|
||||
// Add all of the passes from this set
|
||||
for (SmallVectorImpl<StandardPassEntry>::iterator i=passList.begin(),
|
||||
e=passList.end() ; i!=e ; ++i) {
|
||||
// Skip passes that don't have conditions that match the ones specified
|
||||
// here. For a pass to match:
|
||||
// - Its minimum optimisation level must be less than or equal to the
|
||||
// specified level.
|
||||
// - Its maximum optimisation level must be greater than or equal to the
|
||||
// specified level
|
||||
// - All of its required flags must be set
|
||||
// - None of its disallowed flags may be set
|
||||
if ((level >= OptimizationLevel(i->flags)) &&
|
||||
((level <= MaxOptimizationLevel(i->flags))
|
||||
|| MaxOptimizationLevel(i->flags) == 0) &&
|
||||
((RequiredFlags(i->flags) & flags) == RequiredFlags(i->flags)) &&
|
||||
((DisallowedFlags(i->flags) & flags) == 0)) {
|
||||
// This is quite an ugly way of allowing us to specify an inliner pass to
|
||||
// insert. Ideally, we'd replace this with a general mechanism allowing
|
||||
// callers to replace arbitrary passes in the list.
|
||||
Pass *p = 0;
|
||||
if (&InlinerPlaceholderID == i->passID) {
|
||||
p = inliner;
|
||||
} else if (i->createPass)
|
||||
p = i->createPass();
|
||||
if (p) {
|
||||
PM->add(p);
|
||||
if (VerifyEach)
|
||||
PM->add(CreateVerifierPass());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsigned char DefaultStandardPasses::AggressiveDCEID;
|
||||
unsigned char DefaultStandardPasses::ArgumentPromotionID;
|
||||
unsigned char DefaultStandardPasses::BasicAliasAnalysisID;
|
||||
unsigned char DefaultStandardPasses::CFGSimplificationID;
|
||||
unsigned char DefaultStandardPasses::ConstantMergeID;
|
||||
unsigned char DefaultStandardPasses::CorrelatedValuePropagationID;
|
||||
unsigned char DefaultStandardPasses::DeadArgEliminationID;
|
||||
unsigned char DefaultStandardPasses::DeadStoreEliminationID;
|
||||
unsigned char DefaultStandardPasses::DeadTypeEliminationID;
|
||||
unsigned char DefaultStandardPasses::EarlyCSEID;
|
||||
unsigned char DefaultStandardPasses::FunctionAttrsID;
|
||||
unsigned char DefaultStandardPasses::FunctionInliningID;
|
||||
unsigned char DefaultStandardPasses::GVNID;
|
||||
unsigned char DefaultStandardPasses::GlobalDCEID;
|
||||
unsigned char DefaultStandardPasses::GlobalOptimizerID;
|
||||
unsigned char DefaultStandardPasses::GlobalsModRefID;
|
||||
unsigned char DefaultStandardPasses::IPSCCPID;
|
||||
unsigned char DefaultStandardPasses::IndVarSimplifyID;
|
||||
unsigned char DefaultStandardPasses::InlinerPlaceholderID;
|
||||
unsigned char DefaultStandardPasses::InstructionCombiningID;
|
||||
unsigned char DefaultStandardPasses::JumpThreadingID;
|
||||
unsigned char DefaultStandardPasses::LICMID;
|
||||
unsigned char DefaultStandardPasses::LoopDeletionID;
|
||||
unsigned char DefaultStandardPasses::LoopIdiomID;
|
||||
unsigned char DefaultStandardPasses::LoopRotateID;
|
||||
unsigned char DefaultStandardPasses::LoopUnrollID;
|
||||
unsigned char DefaultStandardPasses::LoopUnswitchID;
|
||||
unsigned char DefaultStandardPasses::MemCpyOptID;
|
||||
unsigned char DefaultStandardPasses::PruneEHID;
|
||||
unsigned char DefaultStandardPasses::ReassociateID;
|
||||
unsigned char DefaultStandardPasses::SCCPID;
|
||||
unsigned char DefaultStandardPasses::ScalarReplAggregatesID;
|
||||
unsigned char DefaultStandardPasses::SimplifyLibCallsID;
|
||||
unsigned char DefaultStandardPasses::StripDeadPrototypesID;
|
||||
unsigned char DefaultStandardPasses::TailCallEliminationID;
|
||||
unsigned char DefaultStandardPasses::TypeBasedAliasAnalysisID;
|
||||
Loading…
Reference in New Issue