llvm-6502/include/llvm/DefaultPasses.h

163 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 DeadTypeEliminationID;
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