mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-10-07 05:55:44 +00:00
9fbd318d36
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@133108 91177308-0d34-0410-b5e6-96231b3b80d8
325 lines
12 KiB
C++
325 lines
12 KiB
C++
//===-- llvm/Support/PassManagerBuilder.h - Build Standard Pass -*- 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 the PassManagerBuilder class, which is used to set up a
|
|
// "standard" optimization sequence suitable for languages like C and C++.
|
|
//
|
|
// These are implemented as inline functions so that we do not have to worry
|
|
// about link issues.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_SUPPORT_PASSMANAGERBUILDER_H
|
|
#define LLVM_SUPPORT_PASSMANAGERBUILDER_H
|
|
|
|
#include "llvm/PassManager.h"
|
|
#include "llvm/DefaultPasses.h"
|
|
#include "llvm/Analysis/Passes.h"
|
|
#include "llvm/Analysis/Verifier.h"
|
|
#include "llvm/Target/TargetLibraryInfo.h"
|
|
#include "llvm/Transforms/Scalar.h"
|
|
#include "llvm/Transforms/IPO.h"
|
|
|
|
namespace llvm {
|
|
|
|
/// PassManagerBuilder - This class is used to set up a standard optimization
|
|
/// sequence for languages like C and C++, allowing some APIs to customize the
|
|
/// pass sequence in various ways. A simple example of using it would be:
|
|
///
|
|
/// PassManagerBuilder Builder;
|
|
/// Builder.OptLevel = 2;
|
|
/// Builder.populateFunctionPassManager(FPM);
|
|
/// Builder.populateModulePassManager(MPM);
|
|
///
|
|
/// In addition to setting up the basic passes, PassManagerBuilder allows
|
|
/// frontends to vend a plugin API, where plugins are allowed to add extensions
|
|
/// to the default pass manager. They do this by specifying where in the pass
|
|
/// pipeline they want to be added, along with a callback function that adds
|
|
/// the pass(es). For example, a plugin that wanted to add a loop optimization
|
|
/// could do something like this:
|
|
///
|
|
/// static void addMyLoopPass(const PMBuilder &Builder, PassManagerBase &PM) {
|
|
/// if (Builder.getOptLevel() > 2 && Builder.getOptSizeLevel() == 0)
|
|
/// PM.add(createMyAwesomePass());
|
|
/// }
|
|
/// ...
|
|
/// Builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd,
|
|
/// addMyLoopPass);
|
|
/// ...
|
|
class PassManagerBuilder {
|
|
public:
|
|
|
|
/// Extensions are passed the builder itself (so they can see how it is
|
|
/// configured) as well as the pass manager to add stuff to.
|
|
typedef void (*ExtensionFn)(const PassManagerBuilder &Builder,
|
|
PassManagerBase &PM);
|
|
enum ExtensionPointTy {
|
|
/// EP_EarlyAsPossible - This extension point allows adding passes before
|
|
/// any other transformations, allowing them to see the code as it is coming
|
|
/// out of the frontend.
|
|
EP_EarlyAsPossible,
|
|
|
|
/// EP_LoopOptimizerEnd - This extension point allows adding loop passes to
|
|
/// the end of the loop optimizer.
|
|
EP_LoopOptimizerEnd
|
|
};
|
|
|
|
/// The Optimization Level - Specify the basic optimization level.
|
|
/// 0 = -O0, 1 = -O1, 2 = -O2, 3 = -O3
|
|
unsigned OptLevel;
|
|
|
|
/// SizeLevel - How much we're optimizing for size.
|
|
/// 0 = none, 1 = -Os, 2 = -Oz
|
|
unsigned SizeLevel;
|
|
|
|
/// LibraryInfo - Specifies information about the runtime library for the
|
|
/// optimizer. If this is non-null, it is added to both the function and
|
|
/// per-module pass pipeline.
|
|
TargetLibraryInfo *LibraryInfo;
|
|
|
|
/// Inliner - Specifies the inliner to use. If this is non-null, it is
|
|
/// added to the per-module passes.
|
|
Pass *Inliner;
|
|
|
|
bool DisableSimplifyLibCalls;
|
|
bool DisableUnitAtATime;
|
|
bool DisableUnrollLoops;
|
|
|
|
private:
|
|
/// ExtensionList - This is list of all of the extensions that are registered.
|
|
std::vector<std::pair<ExtensionPointTy, ExtensionFn> > Extensions;
|
|
|
|
public:
|
|
PassManagerBuilder() {
|
|
OptLevel = 2;
|
|
SizeLevel = 0;
|
|
LibraryInfo = 0;
|
|
Inliner = 0;
|
|
DisableSimplifyLibCalls = false;
|
|
DisableUnitAtATime = false;
|
|
DisableUnrollLoops = false;
|
|
}
|
|
|
|
~PassManagerBuilder() {
|
|
delete LibraryInfo;
|
|
delete Inliner;
|
|
}
|
|
|
|
void addExtension(ExtensionPointTy Ty, ExtensionFn Fn) {
|
|
Extensions.push_back(std::make_pair(Ty, Fn));
|
|
}
|
|
|
|
private:
|
|
void addExtensionsToPM(ExtensionPointTy ETy, PassManagerBase &PM) const {
|
|
for (unsigned i = 0, e = Extensions.size(); i != e; ++i)
|
|
if (Extensions[i].first == ETy)
|
|
Extensions[i].second(*this, PM);
|
|
}
|
|
|
|
void addInitialAliasAnalysisPasses(PassManagerBase &PM) const {
|
|
// Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
|
|
// BasicAliasAnalysis wins if they disagree. This is intended to help
|
|
// support "obvious" type-punning idioms.
|
|
PM.add(createTypeBasedAliasAnalysisPass());
|
|
PM.add(createBasicAliasAnalysisPass());
|
|
}
|
|
public:
|
|
|
|
/// populateFunctionPassManager - This fills in the function pass manager,
|
|
/// which is expected to be run on each function immediately as it is
|
|
/// generated. The idea is to reduce the size of the IR in memory.
|
|
void populateFunctionPassManager(FunctionPassManager &FPM) {
|
|
addExtensionsToPM(EP_EarlyAsPossible, FPM);
|
|
|
|
// Add LibraryInfo if we have some.
|
|
if (LibraryInfo) FPM.add(new TargetLibraryInfo(*LibraryInfo));
|
|
|
|
if (OptLevel == 0) return;
|
|
|
|
addInitialAliasAnalysisPasses(FPM);
|
|
|
|
FPM.add(createCFGSimplificationPass());
|
|
FPM.add(createScalarReplAggregatesPass());
|
|
FPM.add(createEarlyCSEPass());
|
|
}
|
|
|
|
/// populateModulePassManager - This sets up the primary pass manager.
|
|
void populateModulePassManager(PassManagerBase &MPM) {
|
|
// If all optimizations are disabled, just run the always-inline pass.
|
|
if (OptLevel == 0) {
|
|
if (Inliner) {
|
|
MPM.add(Inliner);
|
|
Inliner = 0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Add LibraryInfo if we have some.
|
|
if (LibraryInfo) MPM.add(new TargetLibraryInfo(*LibraryInfo));
|
|
|
|
addInitialAliasAnalysisPasses(MPM);
|
|
|
|
if (!DisableUnitAtATime) {
|
|
MPM.add(createGlobalOptimizerPass()); // Optimize out global vars
|
|
|
|
MPM.add(createIPSCCPPass()); // IP SCCP
|
|
MPM.add(createDeadArgEliminationPass()); // Dead argument elimination
|
|
|
|
MPM.add(createInstructionCombiningPass());// Clean up after IPCP & DAE
|
|
MPM.add(createCFGSimplificationPass()); // Clean up after IPCP & DAE
|
|
}
|
|
|
|
// Start of CallGraph SCC passes.
|
|
if (!DisableUnitAtATime)
|
|
MPM.add(createPruneEHPass()); // Remove dead EH info
|
|
if (Inliner) {
|
|
MPM.add(Inliner);
|
|
Inliner = 0;
|
|
}
|
|
if (!DisableUnitAtATime)
|
|
MPM.add(createFunctionAttrsPass()); // Set readonly/readnone attrs
|
|
if (OptLevel > 2)
|
|
MPM.add(createArgumentPromotionPass()); // Scalarize uninlined fn args
|
|
|
|
// Start of function pass.
|
|
MPM.add(createObjCARCExpandPass()); // Canonicalize ObjC ARC code.
|
|
// Break up aggregate allocas, using SSAUpdater.
|
|
MPM.add(createScalarReplAggregatesPass(-1, false));
|
|
MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
|
|
if (!DisableSimplifyLibCalls)
|
|
MPM.add(createSimplifyLibCallsPass()); // Library Call Optimizations
|
|
MPM.add(createJumpThreadingPass()); // Thread jumps.
|
|
MPM.add(createCorrelatedValuePropagationPass()); // Propagate conditionals
|
|
MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
|
|
MPM.add(createInstructionCombiningPass()); // Combine silly seq's
|
|
|
|
MPM.add(createTailCallEliminationPass()); // Eliminate tail calls
|
|
MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
|
|
MPM.add(createReassociatePass()); // Reassociate expressions
|
|
MPM.add(createLoopRotatePass()); // Rotate Loop
|
|
MPM.add(createLICMPass()); // Hoist loop invariants
|
|
MPM.add(createLoopUnswitchPass(SizeLevel || OptLevel < 3));
|
|
MPM.add(createInstructionCombiningPass());
|
|
MPM.add(createIndVarSimplifyPass()); // Canonicalize indvars
|
|
MPM.add(createLoopIdiomPass()); // Recognize idioms like memset.
|
|
MPM.add(createLoopDeletionPass()); // Delete dead loops
|
|
if (!DisableUnrollLoops)
|
|
MPM.add(createLoopUnrollPass()); // Unroll small loops
|
|
addExtensionsToPM(EP_LoopOptimizerEnd, MPM);
|
|
|
|
if (OptLevel > 1)
|
|
MPM.add(createGVNPass()); // Remove redundancies
|
|
MPM.add(createMemCpyOptPass()); // Remove memcpy / form memset
|
|
MPM.add(createSCCPPass()); // Constant prop with SCCP
|
|
|
|
// Run instcombine after redundancy elimination to exploit opportunities
|
|
// opened up by them.
|
|
MPM.add(createInstructionCombiningPass());
|
|
MPM.add(createJumpThreadingPass()); // Thread jumps
|
|
MPM.add(createCorrelatedValuePropagationPass());
|
|
MPM.add(createDeadStoreEliminationPass()); // Delete dead stores
|
|
MPM.add(createObjCARCOptPass()); // Objective-C ARC optimizations.
|
|
MPM.add(createAggressiveDCEPass()); // Delete dead instructions
|
|
MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
|
|
MPM.add(createInstructionCombiningPass()); // Clean up after everything.
|
|
|
|
if (!DisableUnitAtATime) {
|
|
MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
|
|
MPM.add(createDeadTypeEliminationPass()); // Eliminate dead types
|
|
|
|
// GlobalOpt already deletes dead functions and globals, at -O3 try a
|
|
// late pass of GlobalDCE. It is capable of deleting dead cycles.
|
|
if (OptLevel > 2)
|
|
MPM.add(createGlobalDCEPass()); // Remove dead fns and globals.
|
|
|
|
if (OptLevel > 1)
|
|
MPM.add(createConstantMergePass()); // Merge dup global constants
|
|
}
|
|
}
|
|
|
|
void populateLTOPassManager(PassManagerBase &PM, bool Internalize,
|
|
bool RunInliner) {
|
|
// Provide AliasAnalysis services for optimizations.
|
|
addInitialAliasAnalysisPasses(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));
|
|
|
|
// 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.
|
|
PM.add(createIPSCCPPass());
|
|
|
|
// Now that we internalized some globals, see if we can hack on them!
|
|
PM.add(createGlobalOptimizerPass());
|
|
|
|
// Linking modules together can lead to duplicated global constants, only
|
|
// keep one copy of each constant.
|
|
PM.add(createConstantMergePass());
|
|
|
|
// Remove unused arguments from functions.
|
|
PM.add(createDeadArgEliminationPass());
|
|
|
|
// 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.
|
|
PM.add(createInstructionCombiningPass());
|
|
|
|
// Inline small functions
|
|
if (RunInliner)
|
|
PM.add(createFunctionInliningPass());
|
|
|
|
PM.add(createPruneEHPass()); // Remove dead EH info.
|
|
|
|
// Optimize globals again if we ran the inliner.
|
|
if (RunInliner)
|
|
PM.add(createGlobalOptimizerPass());
|
|
PM.add(createGlobalDCEPass()); // Remove dead functions.
|
|
|
|
// 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.
|
|
PM.add(createArgumentPromotionPass());
|
|
|
|
// The IPO passes may leave cruft around. Clean up after them.
|
|
PM.add(createInstructionCombiningPass());
|
|
PM.add(createJumpThreadingPass());
|
|
// Break up allocas
|
|
PM.add(createScalarReplAggregatesPass());
|
|
|
|
// Run a few AA driven optimizations here and now, to cleanup the code.
|
|
PM.add(createFunctionAttrsPass()); // Add nocapture.
|
|
PM.add(createGlobalsModRefPass()); // IP alias analysis.
|
|
|
|
PM.add(createLICMPass()); // Hoist loop invariants.
|
|
PM.add(createGVNPass()); // Remove redundancies.
|
|
PM.add(createMemCpyOptPass()); // Remove dead memcpys.
|
|
// Nuke dead stores.
|
|
PM.add(createDeadStoreEliminationPass());
|
|
|
|
// Cleanup and simplify the code after the scalar optimizations.
|
|
PM.add(createInstructionCombiningPass());
|
|
|
|
PM.add(createJumpThreadingPass());
|
|
|
|
// Delete basic blocks, which optimization passes may have killed.
|
|
PM.add(createCFGSimplificationPass());
|
|
|
|
// Now that we have optimized the program, discard unreachable functions.
|
|
PM.add(createGlobalDCEPass());
|
|
}
|
|
};
|
|
|
|
|
|
} // end namespace llvm
|
|
#endif
|