mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-05 01:30:18 +00:00
dependence on DominanceFrontier. Instead, add an explicit DominanceFrontier pass in StandardPasses.h to ensure that it gets scheduled at the right time. Declare that loop unrolling preserves ScalarEvolution, and shuffle some getAnalysisUsages. This eliminates one LoopSimplify and one LCCSA run in the standard compile opts sequence. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109413 91177308-0d34-0410-b5e6-96231b3b80d8
252 lines
11 KiB
C++
252 lines
11 KiB
C++
//===-- 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/Analysis/Dominators.h"
|
|
#include "llvm/Analysis/Passes.h"
|
|
#include "llvm/Analysis/Verifier.h"
|
|
#include "llvm/Transforms/Scalar.h"
|
|
#include "llvm/Transforms/IPO.h"
|
|
|
|
namespace llvm {
|
|
/// 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);
|
|
|
|
/// 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.a
|
|
static inline void createStandardModulePasses(PassManagerBase *PM,
|
|
unsigned OptimizationLevel,
|
|
bool OptimizeSize,
|
|
bool UnitAtATime,
|
|
bool UnrollLoops,
|
|
bool SimplifyLibCalls,
|
|
bool HaveExceptions,
|
|
Pass *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);
|
|
|
|
// Implementations
|
|
|
|
static inline void createStandardFunctionPasses(PassManagerBase *PM,
|
|
unsigned OptimizationLevel) {
|
|
if (OptimizationLevel > 0) {
|
|
PM->add(createCFGSimplificationPass());
|
|
if (OptimizationLevel == 1)
|
|
PM->add(createPromoteMemoryToRegisterPass());
|
|
else
|
|
PM->add(createScalarReplAggregatesPass());
|
|
PM->add(createInstructionCombiningPass());
|
|
}
|
|
}
|
|
|
|
/// createStandardModulePasses - Add the standard module passes. This is
|
|
/// expected to be run after the standard function passes.
|
|
static inline void createStandardModulePasses(PassManagerBase *PM,
|
|
unsigned OptimizationLevel,
|
|
bool OptimizeSize,
|
|
bool UnitAtATime,
|
|
bool UnrollLoops,
|
|
bool SimplifyLibCalls,
|
|
bool HaveExceptions,
|
|
Pass *InliningPass) {
|
|
if (OptimizationLevel == 0) {
|
|
if (InliningPass)
|
|
PM->add(InliningPass);
|
|
return;
|
|
}
|
|
|
|
if (UnitAtATime) {
|
|
PM->add(createGlobalOptimizerPass()); // Optimize out global vars
|
|
|
|
PM->add(createIPSCCPPass()); // IP SCCP
|
|
PM->add(createDeadArgEliminationPass()); // Dead argument elimination
|
|
}
|
|
PM->add(createInstructionCombiningPass()); // Clean up after IPCP & DAE
|
|
PM->add(createCFGSimplificationPass()); // Clean up after IPCP & DAE
|
|
|
|
// Start of CallGraph SCC passes.
|
|
if (UnitAtATime && HaveExceptions)
|
|
PM->add(createPruneEHPass()); // Remove dead EH info
|
|
if (InliningPass)
|
|
PM->add(InliningPass);
|
|
if (UnitAtATime)
|
|
PM->add(createFunctionAttrsPass()); // Set readonly/readnone attrs
|
|
if (OptimizationLevel > 2)
|
|
PM->add(createArgumentPromotionPass()); // Scalarize uninlined fn args
|
|
|
|
// Start of function pass.
|
|
|
|
PM->add(createScalarReplAggregatesPass()); // Break up aggregate allocas
|
|
if (SimplifyLibCalls)
|
|
PM->add(createSimplifyLibCallsPass()); // Library Call Optimizations
|
|
PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
|
|
PM->add(createJumpThreadingPass()); // Thread jumps.
|
|
PM->add(createCFGSimplificationPass()); // Merge & remove BBs
|
|
PM->add(createInstructionCombiningPass()); // Combine silly seq's
|
|
|
|
PM->add(createTailCallEliminationPass()); // Eliminate tail calls
|
|
PM->add(createCFGSimplificationPass()); // Merge & remove BBs
|
|
PM->add(createReassociatePass()); // Reassociate expressions
|
|
// Explicitly schedule this to ensure that it runs before any loop pass.
|
|
PM->add(new DominanceFrontier()); // Calculate Dominance Frontiers
|
|
PM->add(createLoopRotatePass()); // Rotate Loop
|
|
PM->add(createLICMPass()); // Hoist loop invariants
|
|
PM->add(createLoopUnswitchPass(OptimizeSize || OptimizationLevel < 3));
|
|
PM->add(createInstructionCombiningPass());
|
|
PM->add(createIndVarSimplifyPass()); // Canonicalize indvars
|
|
PM->add(createLoopDeletionPass()); // Delete dead loops
|
|
if (UnrollLoops)
|
|
PM->add(createLoopUnrollPass()); // Unroll small loops
|
|
PM->add(createInstructionCombiningPass()); // Clean up after the unroller
|
|
if (OptimizationLevel > 1)
|
|
PM->add(createGVNPass()); // Remove redundancies
|
|
PM->add(createMemCpyOptPass()); // Remove memcpy / form memset
|
|
PM->add(createSCCPPass()); // Constant prop with SCCP
|
|
|
|
// Run instcombine after redundancy elimination to exploit opportunities
|
|
// opened up by them.
|
|
PM->add(createInstructionCombiningPass());
|
|
PM->add(createJumpThreadingPass()); // Thread jumps
|
|
PM->add(createDeadStoreEliminationPass()); // Delete dead stores
|
|
PM->add(createAggressiveDCEPass()); // Delete dead instructions
|
|
PM->add(createCFGSimplificationPass()); // Merge & remove BBs
|
|
|
|
if (UnitAtATime) {
|
|
PM->add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
|
|
PM->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 (OptimizationLevel > 2)
|
|
PM->add(createGlobalDCEPass()); // Remove dead fns and globals.
|
|
|
|
if (OptimizationLevel > 1)
|
|
PM->add(createConstantMergePass()); // Merge dup global constants
|
|
}
|
|
}
|
|
|
|
static inline void addOnePass(PassManagerBase *PM, Pass *P, bool AndVerify) {
|
|
PM->add(P);
|
|
|
|
if (AndVerify)
|
|
PM->add(createVerifierPass());
|
|
}
|
|
|
|
static inline void createStandardLTOPasses(PassManagerBase *PM,
|
|
bool Internalize,
|
|
bool RunInliner,
|
|
bool VerifyEach) {
|
|
// 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)
|
|
addOnePass(PM, createInternalizePass(true), VerifyEach);
|
|
|
|
// 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.
|
|
addOnePass(PM, createIPSCCPPass(), VerifyEach);
|
|
|
|
// Now that we internalized some globals, see if we can hack on them!
|
|
addOnePass(PM, createGlobalOptimizerPass(), VerifyEach);
|
|
|
|
// Linking modules together can lead to duplicated global constants, only
|
|
// keep one copy of each constant...
|
|
addOnePass(PM, createConstantMergePass(), VerifyEach);
|
|
|
|
// Remove unused arguments from functions...
|
|
addOnePass(PM, createDeadArgEliminationPass(), VerifyEach);
|
|
|
|
// 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.
|
|
addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
|
|
|
|
// Inline small functions
|
|
if (RunInliner)
|
|
addOnePass(PM, createFunctionInliningPass(), VerifyEach);
|
|
|
|
addOnePass(PM, createPruneEHPass(), VerifyEach); // Remove dead EH info.
|
|
// Optimize globals again if we ran the inliner.
|
|
if (RunInliner)
|
|
addOnePass(PM, createGlobalOptimizerPass(), VerifyEach);
|
|
addOnePass(PM, createGlobalDCEPass(), VerifyEach); // 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.
|
|
addOnePass(PM, createArgumentPromotionPass(), VerifyEach);
|
|
|
|
// The IPO passes may leave cruft around. Clean up after them.
|
|
addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
|
|
addOnePass(PM, createJumpThreadingPass(), VerifyEach);
|
|
// Break up allocas
|
|
addOnePass(PM, createScalarReplAggregatesPass(), VerifyEach);
|
|
|
|
// Run a few AA driven optimizations here and now, to cleanup the code.
|
|
addOnePass(PM, createFunctionAttrsPass(), VerifyEach); // Add nocapture.
|
|
addOnePass(PM, createGlobalsModRefPass(), VerifyEach); // IP alias analysis.
|
|
|
|
addOnePass(PM, createLICMPass(), VerifyEach); // Hoist loop invariants.
|
|
addOnePass(PM, createGVNPass(), VerifyEach); // Remove redundancies.
|
|
addOnePass(PM, createMemCpyOptPass(), VerifyEach); // Remove dead memcpys.
|
|
// Nuke dead stores.
|
|
addOnePass(PM, createDeadStoreEliminationPass(), VerifyEach);
|
|
|
|
// Cleanup and simplify the code after the scalar optimizations.
|
|
addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
|
|
|
|
addOnePass(PM, createJumpThreadingPass(), VerifyEach);
|
|
|
|
// Delete basic blocks, which optimization passes may have killed.
|
|
addOnePass(PM, createCFGSimplificationPass(), VerifyEach);
|
|
|
|
// Now that we have optimized the program, discard unreachable functions.
|
|
addOnePass(PM, createGlobalDCEPass(), VerifyEach);
|
|
}
|
|
}
|
|
|
|
#endif
|