#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 {
class RegisterStandardPassLists {
public:
RegisterStandardPassLists() {
StandardPass::RegisterDefaultPasses = RegisterStandardPassList;
StandardPass::CreateVerifierPass = CreateVerifierPass;
}
private:
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(); }
static Pass *createScalarReplAggregatesPass(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) {
#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)
DEFAULT_MODULE_PASS(GlobalOptimizer,
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
DEFAULT_MODULE_PASS(IPSCCP,
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
DEFAULT_MODULE_PASS(DeadArgElimination,
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
DEFAULT_MODULE_PASS(InstructionCombining,
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
DEFAULT_MODULE_PASS(CFGSimplification,
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
DEFAULT_MODULE_PASS(PruneEH, StandardPass::OptimzationFlags(0, 0,
StandardPass::UnitAtATime | StandardPass::HaveExceptions));
StandardPass::RegisterDefaultPass(0,
&DefaultStandardPasses::InlinerPlaceholderID, 0,
StandardPass::Module);
DEFAULT_MODULE_PASS(FunctionAttrs, StandardPass::OptimzationFlags(0, 0,
StandardPass::UnitAtATime));
DEFAULT_MODULE_PASS(ArgumentPromotion, StandardPass::OptimzationFlags(3));
DEFAULT_MODULE_PASS(ScalarReplAggregates, 0);
DEFAULT_MODULE_PASS(EarlyCSE, 0);
DEFAULT_MODULE_PASS(SimplifyLibCalls,
StandardPass::OptimzationFlags(0, 0, StandardPass::SimplifyLibCalls));
DEFAULT_MODULE_PASS(JumpThreading, 0);
DEFAULT_MODULE_PASS(CorrelatedValuePropagation, 0);
DEFAULT_MODULE_PASS(CFGSimplification, 0);
DEFAULT_MODULE_PASS(InstructionCombining, 0);
DEFAULT_MODULE_PASS(TailCallElimination, 0);
DEFAULT_MODULE_PASS(CFGSimplification, 0);
DEFAULT_MODULE_PASS(Reassociate, 0);
DEFAULT_MODULE_PASS(LoopRotate, 0);
DEFAULT_MODULE_PASS(LICM, 0);
StandardPass::RegisterDefaultPass(
PassInfo::NormalCtor_t(createSizeOptimizingLoopUnswitchPass),
&DefaultStandardPasses::LoopUnswitchID, 0,
StandardPass::Module,
StandardPass::OptimzationFlags(0, 2));
StandardPass::RegisterDefaultPass(
PassInfo::NormalCtor_t(createSizeOptimizingLoopUnswitchPass),
&DefaultStandardPasses::LoopUnswitchID, 0,
StandardPass::Module,
StandardPass::OptimzationFlags(3, 0, StandardPass::OptimizeSize));
StandardPass::RegisterDefaultPass(
PassInfo::NormalCtor_t(createDefaultLoopUnswitchPass),
&DefaultStandardPasses::LoopUnswitchID, 0,
StandardPass::Module,
StandardPass::OptimzationFlags(3, 0, 0, StandardPass::OptimizeSize));
DEFAULT_MODULE_PASS(InstructionCombining, 0);
DEFAULT_MODULE_PASS(IndVarSimplify, 0);
DEFAULT_MODULE_PASS(LoopIdiom, 0);
DEFAULT_MODULE_PASS(LoopDeletion, 0);
DEFAULT_MODULE_PASS(LoopUnroll,
StandardPass::OptimzationFlags(0, 0, StandardPass::UnrollLoops));
DEFAULT_MODULE_PASS(GVN, StandardPass::OptimzationFlags(2));
DEFAULT_MODULE_PASS(MemCpyOpt, 0);
DEFAULT_MODULE_PASS(SCCP, 0);
DEFAULT_MODULE_PASS(InstructionCombining, 0);
DEFAULT_MODULE_PASS(JumpThreading, 0);
DEFAULT_MODULE_PASS(CorrelatedValuePropagation, 0);
DEFAULT_MODULE_PASS(DeadStoreElimination, 0);
DEFAULT_MODULE_PASS(AggressiveDCE, 0);
DEFAULT_MODULE_PASS(CFGSimplification, 0);
DEFAULT_MODULE_PASS(InstructionCombining, 0);
DEFAULT_MODULE_PASS(StripDeadPrototypes,
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
DEFAULT_MODULE_PASS(DeadTypeElimination,
StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
DEFAULT_MODULE_PASS(GlobalDCE,
StandardPass::OptimzationFlags(3, 0, StandardPass::UnitAtATime));
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)
DEFAULT_LTO_PASS(IPSCCP, 0);
DEFAULT_LTO_PASS(GlobalOptimizer, 0);
DEFAULT_LTO_PASS(ConstantMerge, 0);
DEFAULT_LTO_PASS(DeadArgElimination, 0);
DEFAULT_LTO_PASS(InstructionCombining, 0);
DEFAULT_LTO_PASS(FunctionInlining,
StandardPass::OptimzationFlags(0, 0xf, StandardPass::RunInliner));
DEFAULT_LTO_PASS(PruneEH, 0);
DEFAULT_LTO_PASS(GlobalOptimizer,
StandardPass::OptimzationFlags(0, 0xf, StandardPass::RunInliner));
DEFAULT_LTO_PASS(GlobalDCE, 0);
DEFAULT_LTO_PASS(ArgumentPromotion, 0);
DEFAULT_LTO_PASS(InstructionCombining, 0);
DEFAULT_LTO_PASS(JumpThreading, 0);
DEFAULT_LTO_PASS(ScalarReplAggregates, 0);
DEFAULT_LTO_PASS(FunctionAttrs, 0);
DEFAULT_LTO_PASS(GlobalsModRef, 0);
DEFAULT_LTO_PASS(LICM, 0);
DEFAULT_LTO_PASS(GVN, 0);
DEFAULT_LTO_PASS(MemCpyOpt, 0);
DEFAULT_LTO_PASS(DeadStoreElimination, 0);
DEFAULT_LTO_PASS(InstructionCombining, 0);
DEFAULT_LTO_PASS(JumpThreading, 0);
DEFAULT_LTO_PASS(CFGSimplification, 0);
DEFAULT_LTO_PASS(GlobalDCE, 0);
#undef DEFAULT_LTO_PASS
}
};
static RegisterStandardPassLists AutoRegister;
static inline void createStandardAliasAnalysisPasses(PassManagerBase *PM) {
StandardPass::AddPassesFromSet(PM, StandardPass::AliasAnalysis);
}
static inline void createStandardFunctionPasses(PassManagerBase *PM,
unsigned OptimizationLevel) {
StandardPass::AddPassesFromSet(PM, StandardPass::AliasAnalysis);
StandardPass::AddPassesFromSet(PM, StandardPass::Function, OptimizationLevel);
}
static inline void createStandardModulePasses(PassManagerBase *PM,
unsigned OptimizationLevel,
bool OptimizeSize,
bool UnitAtATime,
bool UnrollLoops,
bool SimplifyLibCalls,
bool HaveExceptions,
Pass *InliningPass) {
createStandardAliasAnalysisPasses(PM);
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);
}
static inline void createStandardLTOPasses(PassManagerBase *PM,
bool Internalize,
bool RunInliner,
bool VerifyEach) {
createStandardAliasAnalysisPasses(PM);
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