mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-25 16:29:20 +00:00
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
167 lines
6.5 KiB
C++
167 lines
6.5 KiB
C++
//===- llvm/DefaultPasses.h - Default Pass Support code --------*- 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 infrastructure for registering the standard pass list.
|
|
// This defines sets of standard optimizations that plugins can modify and
|
|
// front ends can use.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_DEFAULT_PASS_SUPPORT_H
|
|
#define LLVM_DEFAULT_PASS_SUPPORT_H
|
|
|
|
namespace llvm {
|
|
|
|
class PassManagerBase;
|
|
|
|
/// Unique identifiers for the default standard passes. The addresses of
|
|
/// these symbols are used to uniquely identify passes from the default list.
|
|
namespace DefaultStandardPasses {
|
|
extern unsigned char AggressiveDCEID;
|
|
extern unsigned char ArgumentPromotionID;
|
|
extern unsigned char BasicAliasAnalysisID;
|
|
extern unsigned char CFGSimplificationID;
|
|
extern unsigned char ConstantMergeID;
|
|
extern unsigned char CorrelatedValuePropagationID;
|
|
extern unsigned char DeadArgEliminationID;
|
|
extern unsigned char DeadStoreEliminationID;
|
|
extern unsigned char EarlyCSEID;
|
|
extern unsigned char FunctionAttrsID;
|
|
extern unsigned char FunctionInliningID;
|
|
extern unsigned char GVNID;
|
|
extern unsigned char GlobalDCEID;
|
|
extern unsigned char GlobalOptimizerID;
|
|
extern unsigned char GlobalsModRefID;
|
|
extern unsigned char IPSCCPID;
|
|
extern unsigned char IndVarSimplifyID;
|
|
extern unsigned char InlinerPlaceholderID;
|
|
extern unsigned char InstructionCombiningID;
|
|
extern unsigned char JumpThreadingID;
|
|
extern unsigned char LICMID;
|
|
extern unsigned char LoopDeletionID;
|
|
extern unsigned char LoopIdiomID;
|
|
extern unsigned char LoopRotateID;
|
|
extern unsigned char LoopUnrollID;
|
|
extern unsigned char LoopUnswitchID;
|
|
extern unsigned char MemCpyOptID;
|
|
extern unsigned char PruneEHID;
|
|
extern unsigned char ReassociateID;
|
|
extern unsigned char SCCPID;
|
|
extern unsigned char ScalarReplAggregatesID;
|
|
extern unsigned char SimplifyLibCallsID;
|
|
extern unsigned char StripDeadPrototypesID;
|
|
extern unsigned char TailCallEliminationID;
|
|
extern unsigned char TypeBasedAliasAnalysisID;
|
|
}
|
|
|
|
/// StandardPass - The class responsible for maintaining the lists of standard
|
|
class StandardPass {
|
|
friend class RegisterStandardPassLists;
|
|
public:
|
|
/// Predefined standard sets of passes
|
|
enum StandardSet {
|
|
AliasAnalysis,
|
|
Function,
|
|
Module,
|
|
LTO
|
|
};
|
|
/// Flags to specify whether a pass should be enabled. Passes registered
|
|
/// with the standard sets may specify a minimum optimization level and one
|
|
/// or more flags that must be set when constructing the set for the pass to
|
|
/// be used.
|
|
enum OptimizationFlags {
|
|
/// Optimize for size was requested.
|
|
OptimizeSize = 1<<0,
|
|
/// Allow passes which may make global module changes.
|
|
UnitAtATime = 1<<1,
|
|
/// UnrollLoops - Allow loop unrolling.
|
|
UnrollLoops = 1<<2,
|
|
/// Allow library calls to be simplified.
|
|
SimplifyLibCalls = 1<<3,
|
|
/// Whether the module may have code using exceptions.
|
|
HaveExceptions = 1<<4,
|
|
// Run an inliner pass as part of this set.
|
|
RunInliner = 1<<5
|
|
};
|
|
enum OptimizationFlagComponents {
|
|
/// The low bits are used to store the optimization level. When requesting
|
|
/// passes, this should store the requested optimisation level. When
|
|
/// setting passes, this should set the minimum optimization level at which
|
|
/// the pass will run.
|
|
OptimizationLevelMask=0xf,
|
|
/// The maximum optimisation level at which the pass is run.
|
|
MaxOptimizationLevelMask=0xf0,
|
|
// Flags that must be set
|
|
RequiredFlagMask=0xff00,
|
|
// Flags that may not be set.
|
|
DisallowedFlagMask=0xff0000,
|
|
MaxOptimizationLevelShift=4,
|
|
RequiredFlagShift=8,
|
|
DisallowedFlagShift=16
|
|
};
|
|
/// Returns the optimisation level from a set of flags.
|
|
static unsigned OptimizationLevel(unsigned flags) {
|
|
return flags & OptimizationLevelMask;
|
|
}
|
|
/// Returns the maximum optimization level for this set of flags
|
|
static unsigned MaxOptimizationLevel(unsigned flags) {
|
|
return (flags & MaxOptimizationLevelMask) >> 4;
|
|
}
|
|
/// Constructs a set of flags from the specified minimum and maximum
|
|
/// optimisation level
|
|
static unsigned OptimzationFlags(unsigned minLevel=0, unsigned maxLevel=0xf,
|
|
unsigned requiredFlags=0, unsigned disallowedFlags=0) {
|
|
return ((minLevel & OptimizationLevelMask) |
|
|
((maxLevel<<MaxOptimizationLevelShift) & MaxOptimizationLevelMask)
|
|
| ((requiredFlags<<RequiredFlagShift) & RequiredFlagMask)
|
|
| ((disallowedFlags<<DisallowedFlagShift) & DisallowedFlagMask));
|
|
}
|
|
/// Returns the flags that must be set for this to match
|
|
static unsigned RequiredFlags(unsigned flags) {
|
|
return (flags & RequiredFlagMask) >> RequiredFlagShift;
|
|
}
|
|
/// Returns the flags that must not be set for this to match
|
|
static unsigned DisallowedFlags(unsigned flags) {
|
|
return (flags & DisallowedFlagMask) >> DisallowedFlagShift;
|
|
}
|
|
/// Register a standard pass in the specified set. If flags is non-zero,
|
|
/// then the pass will only be returned when the specified flags are set.
|
|
template<typename passName>
|
|
class RegisterStandardPass {
|
|
public:
|
|
RegisterStandardPass(StandardSet set, unsigned char *runBefore=0,
|
|
unsigned flags=0, unsigned char *ID=0) {
|
|
// Use the pass's ID if one is not specified
|
|
RegisterDefaultPass(PassInfo::NormalCtor_t(callDefaultCtor<passName>),
|
|
ID ? ID : (unsigned char*)&passName::ID, runBefore, set, flags);
|
|
}
|
|
};
|
|
/// Adds the passes from the specified set to the provided pass manager
|
|
static void AddPassesFromSet(PassManagerBase *PM,
|
|
StandardSet set,
|
|
unsigned flags=0,
|
|
bool VerifyEach=false,
|
|
Pass *inliner=0);
|
|
private:
|
|
/// Registers the default passes. This is set by RegisterStandardPassLists
|
|
/// and is called lazily.
|
|
static void (*RegisterDefaultPasses)(void);
|
|
/// Creates the verifier pass that is inserted when a VerifyEach is passed to
|
|
/// AddPassesFromSet()
|
|
static Pass* (*CreateVerifierPass)(void);
|
|
/// Registers the pass
|
|
static void RegisterDefaultPass(PassInfo::NormalCtor_t constructor,
|
|
unsigned char *newPass,
|
|
unsigned char *oldPass,
|
|
StandardSet set,
|
|
unsigned flags=0);
|
|
};
|
|
|
|
} // namespace llvm
|
|
|
|
#endif
|