mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-28 04:33:05 +00:00
1afcace3a3
patch brings numerous advantages to LLVM. One way to look at it is through diffstat: 109 files changed, 3005 insertions(+), 5906 deletions(-) Removing almost 3K lines of code is a good thing. Other advantages include: 1. Value::getType() is a simple load that can be CSE'd, not a mutating union-find operation. 2. Types a uniqued and never move once created, defining away PATypeHolder. 3. Structs can be "named" now, and their name is part of the identity that uniques them. This means that the compiler doesn't merge them structurally which makes the IR much less confusing. 4. Now that there is no way to get a cycle in a type graph without a named struct type, "upreferences" go away. 5. Type refinement is completely gone, which should make LTO much MUCH faster in some common cases with C++ code. 6. Types are now generally immutable, so we can use "Type *" instead "const Type *" everywhere. Downsides of this patch are that it removes some functions from the C API, so people using those will have to upgrade to (not yet added) new API. "LLVM 3.0" is the right time to do this. There are still some cleanups pending after this, this patch is large enough as-is. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
332 lines
13 KiB
C++
332 lines
13 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,
|
|
|
|
/// EP_ScalarOptimizerLate - This extension point allows adding optimization
|
|
/// passes after most of the main optimizations, but before the last
|
|
/// cleanup-ish optimizations.
|
|
EP_ScalarOptimizerLate
|
|
};
|
|
|
|
/// 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());
|
|
FPM.add(createLowerExpectIntrinsicPass());
|
|
}
|
|
|
|
/// 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.
|
|
// 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
|
|
|
|
addExtensionsToPM(EP_ScalarOptimizerLate, MPM);
|
|
|
|
MPM.add(createAggressiveDCEPass()); // Delete dead instructions
|
|
MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
|
|
MPM.add(createInstructionCombiningPass()); // Clean up after everything.
|
|
|
|
if (!DisableUnitAtATime) {
|
|
// FIXME: We shouldn't bother with this anymore.
|
|
MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
|
|
|
|
// 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
|