mirrors/ldc
1
0
Fork 0
mirror of https://github.com/ldc-developers/ldc.git synced 2025-04-30 23:20:40 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Use llvm::PassManagerBuilder for optimization scheduling.

Browse source 
This commit is based on Kai's pull request #157.
This commit is contained in:
David Nadlinger 2012-11-04 00:26:15 +01:00
parent 2e8dac5f38
commit 2f78dc686d
2 changed files with 141 additions and 182 deletions
Download patch file Download diff file Expand all files Collapse all files

317
gen/optimizer.cpp
View file

@ -1,25 +1,28 @@
#include "gen/optimizer.h" #include "gen/optimizer.h"
#include "gen/cl_helpers.h" #include "gen/cl_helpers.h"
#include "gen/irstate.h"
#include "gen/logger.h" #include "gen/logger.h"
#include "gen/passes/Passes.h" #include "gen/passes/Passes.h"
#include "llvm/PassManager.h" #include "llvm/PassManager.h"
#include "llvm/LinkAllPasses.h" #include "llvm/LinkAllPasses.h"
#include "llvm/Analysis/LoopPass.h" #include "llvm/Module.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Analysis/Verifier.h" #include "llvm/Analysis/Verifier.h"
#if LDC_LLVM_VER >= 302 #if LDC_LLVM_VER >= 302
#include "llvm/DataLayout.h" #include "llvm/DataLayout.h"
#else #else
#include "llvm/Target/TargetData.h" #include "llvm/Target/TargetData.h"
#endif #endif
#include "llvm/Target/TargetLibraryInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/PassNameParser.h" #include "llvm/Support/PassNameParser.h"
#include "llvm/Transforms/IPO.h" #include "llvm/Transforms/IPO.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"
#include "mars.h" // error() #include "mars.h" // error()
#include "root.h"
#include <cstring> // strcmp();
using namespace llvm; using namespace llvm;
@ -30,7 +33,7 @@ static cl::list<const PassInfo*, bool, PassNameParser>
cl::Hidden // to clean up --help output cl::Hidden // to clean up --help output
); );
static cl::opt<unsigned char> optimizeLevel( static cl::opt<signed char> optimizeLevel(
cl::desc("Setting the optimization level:"), cl::desc("Setting the optimization level:"),
cl::ZeroOrMore, cl::ZeroOrMore,
cl::values( cl::values(
@ -39,8 +42,10 @@ static cl::opt<unsigned char> optimizeLevel(
clEnumValN(1, "O1", "Simple optimizations"), clEnumValN(1, "O1", "Simple optimizations"),
clEnumValN(2, "O2", "Good optimizations"), clEnumValN(2, "O2", "Good optimizations"),
clEnumValN(3, "O3", "Aggressive optimizations"), clEnumValN(3, "O3", "Aggressive optimizations"),
clEnumValN(4, "O4", "Link-time optimization"), // not implemented? clEnumValN(4, "O4", "Link-time optimization"), // Not implemented yet.
clEnumValN(5, "O5", "Link-time optimization"), // not implemented? clEnumValN(5, "O5", "Link-time optimization"), // Not implemented yet.
clEnumValN(-1, "Os", "Like -O2 with extra optimizations for size"),
clEnumValN(-2, "Oz", "Like -Os but reduces code size further"),
clEnumValEnd), clEnumValEnd),
cl::init(0)); cl::init(0));
@ -75,44 +80,28 @@ enableInlining("inlining",
cl::desc("(*) Enable function inlining in -O<N>"), cl::desc("(*) Enable function inlining in -O<N>"),
cl::ZeroOrMore); cl::ZeroOrMore);
#if LDC_LLVM_VER >= 301
static cl::opt<bool> static cl::opt<bool>
runVectorization("vectorize", cl::desc("Run vectorization passes")); unitAtATime("unit-at-a-time",
cl::desc("Enable basic IPO"),
cl::init(true));
static cl::opt<bool> static cl::opt<bool>
useGVNAfterVectorization("use-gvn-after-vectorization", stripDebug("strip-debug",
cl::init(false), cl::Hidden, cl::desc("Strip symbolic debug information before optimization"));
cl::desc("Run GVN instead of Early CSE after vectorization passes"));
#endif
// Determine whether or not to run the inliner as part of the default list of static unsigned optLevel() {
// optimization passes. // Use -O2 as a base for the size-optimization levels.
// If not explicitly specified, treat as false for -O0-2, and true for -O3. return optimizeLevel >= 0 ? optimizeLevel : 2;
bool doInline() {
return enableInlining == cl::BOU_TRUE
|| (enableInlining == cl::BOU_UNSET && optimizeLevel >= 3);
} }
// Determine whether the inliner will be run. static unsigned sizeLevel() {
return optimizeLevel < 0 ? -optimizeLevel : 0;
}
// Determines whether or not to run the normal, full inlining pass.
bool willInline() { bool willInline() {
if (doInline()) return enableInlining == cl::BOU_TRUE ||
return true; (enableInlining != cl::BOU_UNSET && optLevel() > 1);
// It may also have been specified explicitly on the command line as an explicit pass
typedef cl::list<const PassInfo*, bool, PassNameParser> PL;
for (PL::iterator I = passList.begin(), E = passList.end(); I != E; ++I) {
if (!std::strcmp((*I)->getPassArgument(), "inline"))
return true;
}
return false;
}
// Some extra accessors for the linker: (llvm-ld version only, currently unused?)
int optLevel() {
return optimizeLevel;
}
bool optimize() {
return optimizeLevel || doInline() || !passList.empty();
} }
llvm::CodeGenOpt::Level codeGenOptLevel() { llvm::CodeGenOpt::Level codeGenOptLevel() {
@ -132,138 +121,84 @@ llvm::CodeGenOpt::Level codeGenOptLevel() {
#endif #endif
} }
static void addPass(PassManager& pm, Pass* pass) { static inline void addPass(PassManagerBase& pm, Pass* pass) {
pm.add(pass); pm.add(pass);
if (verifyEach) pm.add(createVerifierPass()); if (verifyEach) pm.add(createVerifierPass());
} }
// this function inserts some or all of the std-compile-opts passes depending on the static void addStripExternalsPass(const PassManagerBuilder &builder, PassManagerBase &pm) {
// optimization level given. if (builder.OptLevel >= 1)
static void addPassesForOptLevel(PassManager& pm) { addPass(pm, createStripExternalsPass());
// -O1 }
if (optimizeLevel >= 1)
{
// Add alias analysis passes.
// This is at least required for FunctionAttrs pass.
addPass(pm, createTypeBasedAliasAnalysisPass());
addPass(pm, createBasicAliasAnalysisPass());
//addPass(pm, createStripDeadPrototypesPass());
addPass(pm, createGlobalDCEPass());
addPass(pm, createPromoteMemoryToRegisterPass());
addPass(pm, createCFGSimplificationPass());
if (optimizeLevel == 1)
addPass(pm, createPromoteMemoryToRegisterPass());
else
addPass(pm, createScalarReplAggregatesPass());
addPass(pm, createGlobalOptimizerPass());
}
// -O2 static void addSimplifyDRuntimeCallsPass(const PassManagerBuilder &builder, PassManagerBase &pm) {
if (optimizeLevel >= 2) if (builder.OptLevel >= 2 && builder.SizeLevel == 0)
{ addPass(pm, createSimplifyDRuntimeCalls());
addPass(pm, createIPConstantPropagationPass()); }
addPass(pm, createDeadArgEliminationPass());
addPass(pm, createInstructionCombiningPass());
addPass(pm, createCFGSimplificationPass());
addPass(pm, createPruneEHPass());
addPass(pm, createFunctionAttrsPass());
addPass(pm, createTailCallEliminationPass());
addPass(pm, createCFGSimplificationPass());
addPass(pm, createGVNPass());
}
// -inline
if (doInline()) {
addPass(pm, createFunctionInliningPass());
if (optimizeLevel >= 2) {
// Run some optimizations to clean up after inlining.
addPass(pm, createScalarReplAggregatesPass());
addPass(pm, createInstructionCombiningPass());
// -instcombine + gvn == devirtualization :)
addPass(pm, createGVNPass());
// Inline again, to catch things like now nonvirtual
// function calls, foreach delegates passed to inlined
// opApply's, etc. where the actual function being called
// wasn't known during the first inliner pass.
addPass(pm, createFunctionInliningPass());
}
}
if (optimizeLevel >= 2) {
if (!disableLangSpecificPasses) {
if (!disableSimplifyRuntimeCalls)
addPass(pm, createSimplifyDRuntimeCalls());
#if USE_METADATA #if USE_METADATA
if (!disableGCToStack) static void addGarbageCollect2StackPass(const PassManagerBuilder &builder, PassManagerBase &pm) {
addPass(pm, createGarbageCollect2Stack()); if (builder.OptLevel >= 2 && builder.SizeLevel == 0)
#endif // USE_METADATA addPass(pm, createGarbageCollect2Stack());
} }
// Run some clean-up passes #endif
addPass(pm, createInstructionCombiningPass());
addPass(pm, createScalarReplAggregatesPass()); /**
addPass(pm, createCFGSimplificationPass()); * Adds a set of optimization passes to the given module/function pass
addPass(pm, createInstructionCombiningPass()); * managers based on the given optimization and size reduction levels.
*
* The selection mirrors Clang behavior and is based on LLVM's
* PassManagerBuilder.
*/
static void addOptimizationPasses(PassManagerBase &mpm, FunctionPassManager &fpm,
unsigned optLevel, unsigned sizeLevel) {
fpm.add(createVerifierPass()); // Verify that input is correct
PassManagerBuilder builder;
builder.OptLevel = optLevel;
builder.SizeLevel = sizeLevel;
if (enableInlining == cl::BOU_FALSE) {
// If -disable-inlining has been explictly specified, don't perform
// any inlining at all.
} else if (willInline()) {
unsigned threshold = 225;
if (sizeLevel == 1) // -Os
threshold = 75;
else if (sizeLevel == 2) // -Oz
threshold = 25;
if (optLevel > 2)
threshold = 275;
builder.Inliner = createFunctionInliningPass(threshold);
} else {
builder.Inliner = createAlwaysInlinerPass();
} }
builder.DisableUnitAtATime = !unitAtATime;
builder.DisableUnrollLoops = optLevel == 0;
/* builder.Vectorize is set in ctor from command line switch */
// -O3 if (!disableLangSpecificPasses) {
if (optimizeLevel >= 3) if (!disableSimplifyRuntimeCalls)
{ builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd, addSimplifyDRuntimeCallsPass);
addPass(pm, createArgumentPromotionPass());
addPass(pm, createSimplifyLibCallsPass());
addPass(pm, createInstructionCombiningPass());
addPass(pm, createJumpThreadingPass());
addPass(pm, createCFGSimplificationPass());
addPass(pm, createScalarReplAggregatesPass());
addPass(pm, createInstructionCombiningPass());
addPass(pm, createConstantPropagationPass());
addPass(pm, createReassociatePass()); #if USE_METADATA
addPass(pm, createLoopRotatePass()); if (!disableGCToStack)
addPass(pm, createLICMPass()); Builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd, addGarbageCollect2StackPass);
addPass(pm, createLoopUnswitchPass()); #endif // USE_METADATA
addPass(pm, createInstructionCombiningPass());
addPass(pm, createIndVarSimplifyPass());
addPass(pm, createLoopDeletionPass());
addPass(pm, createLoopUnrollPass());
addPass(pm, createInstructionCombiningPass());
addPass(pm, createGVNPass());
addPass(pm, createMemCpyOptPass());
addPass(pm, createSCCPPass());
addPass(pm, createInstructionCombiningPass());
addPass(pm, createConstantPropagationPass());
addPass(pm, createDeadStoreEliminationPass());
addPass(pm, createAggressiveDCEPass());
addPass(pm, createCFGSimplificationPass());
addPass(pm, createConstantMergePass());
} }
#if LDC_LLVM_VER >= 301 #if LDC_LLVM_VER >= 301
// -vectorize // EP_OptimizerLast does not exist in LLVM 3.0, add it manually below.
if (runVectorization) builder.addExtension(PassManagerBuilder::EP_OptimizerLast, addStripExternalsPass);
{
addPass(pm, createBBVectorizePass());
addPass(pm, createInstructionCombiningPass());
if (optimizeLevel > 1 && useGVNAfterVectorization)
addPass(pm, createGVNPass()); // Remove redundancies
else
addPass(pm, createEarlyCSEPass()); // Catch trivial redundancies
}
#endif #endif
if (optimizeLevel >= 1) { builder.populateFunctionPassManager(fpm);
addPass(pm, createStripExternalsPass()); builder.populateModulePassManager(mpm);
addPass(pm, createGlobalDCEPass());
}
// level -O4 and -O5 are linktime optimizations #if LDC_LLVM_VER < 301
addStripExternalsPass(builder, mpm);
#endif
} }
////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////
@ -271,52 +206,80 @@ static void addPassesForOptLevel(PassManager& pm) {
// Returns true if any optimization passes were invoked. // Returns true if any optimization passes were invoked.
bool ldc_optimize_module(llvm::Module* m) bool ldc_optimize_module(llvm::Module* m)
{ {
if (!optimize()) // Create a PassManager to hold and optimize the collection of
return false; // per-module passes we are about to build.
PassManager mpm;
PassManager pm; // Add an appropriate TargetLibraryInfo pass for the module's triple.
TargetLibraryInfo *tli = new TargetLibraryInfo(Triple(m->getTargetTriple()));
if (verifyEach) pm.add(createVerifierPass()); // The -disable-simplify-libcalls flag actually disables all builtin optzns.
if (disableSimplifyRuntimeCalls)
tli->disableAllFunctions();
mpm.add(tli);
// Add an appropriate TargetData instance for this module.
#if LDC_LLVM_VER >= 302 #if LDC_LLVM_VER >= 302
addPass(pm, new DataLayout(m)); mpm.add(new DataLayout(m));
#else #else
addPass(pm, new TargetData(m)); mpm.add(new TargetData(m));
#endif #endif
bool optimize = optimizeLevel != 0 || doInline(); // Also set up a manager for the per-function passes.
FunctionPassManager fpm(m);
#if LDC_LLVM_VER >= 302
fpm.add(new DataLayout(m));
#else
fpm.add(new TargetData(m));
#endif
unsigned optPos = optimizeLevel != 0 // If the -strip-debug command line option was specified, add it before
? optimizeLevel.getPosition() // anything else.
: enableInlining.getPosition(); if (stripDebug)
addPass(mpm, createStripSymbolsPass(true));
for (size_t i = 0; i < passList.size(); i++) { bool defaultsAdded = false;
// insert -O<N> / -enable-inlining in right position // Create a new optimization pass for each one specified on the command line
if (optimize && optPos < passList.getPosition(i)) { for (unsigned i = 0; i < passList.size(); ++i) {
addPassesForOptLevel(pm); if (optimizeLevel && optimizeLevel.getPosition() < passList.getPosition(i)) {
optimize = false; addOptimizationPasses(mpm, fpm, optLevel(), sizeLevel());
defaultsAdded = true;
} }
const PassInfo* pass = passList[i]; const PassInfo *passInf = passList[i];
if (PassInfo::NormalCtor_t ctor = pass->getNormalCtor()) { Pass *pass = 0;
addPass(pm, ctor()); if (passInf->getNormalCtor())
} else { pass = passInf->getNormalCtor()();
const char* arg = pass->getPassArgument(); // may return null else {
const char* arg = passInf->getPassArgument(); // may return null
if (arg) if (arg)
error("Can't create pass '-%s' (%s)", arg, pass->getPassName()); error("Can't create pass '-%s' (%s)", arg, pass->getPassName());
else else
error("Can't create pass (%s)", pass->getPassName()); error("Can't create pass (%s)", pass->getPassName());
assert(0); // Should be unreachable; root.h:error() calls exit() llvm_unreachable("pass creation failed");
}
if (pass) {
addPass(mpm, pass);
} }
} }
// insert -O<N> / -enable-inlining if specified at the end,
if (optimize)
addPassesForOptLevel(pm);
pm.run(*m); // Add the default passes for the specified optimization level.
if (!defaultsAdded)
addOptimizationPasses(mpm, fpm, optLevel(), sizeLevel());
// Run per-function passes.
fpm.doInitialization();
for (llvm::Module::iterator F = m->begin(), E = m->end(); F != E; ++F)
fpm.run(*F);
fpm.doFinalization();
// Run per-module passes.
mpm.run(*m);
// Verify the resulting module.
verifyModule(m); verifyModule(m);
// Report that we run some passes.
return true; return true;
} }

6
gen/optimizer.h
View file

@ -12,13 +12,9 @@ namespace llvm { class Module; }
bool ldc_optimize_module(llvm::Module* m); bool ldc_optimize_module(llvm::Module* m);
// Determines whether the inliner will run in the -O<N> list of passes // Returns whether the normal, full inlining pass will be run.
bool doInline();
// Determines whether the inliner will be run at all.
bool willInline(); bool willInline();
int optLevel();
bool optimize(); bool optimize();
llvm::CodeGenOpt::Level codeGenOptLevel(); llvm::CodeGenOpt::Level codeGenOptLevel();