1//===- llvm/DefaultPasses.h - Default Pass Support code --------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9// This file defines the infrastructure for registering the standard pass list.
10// This defines sets of standard optimizations that plugins can modify and
11// front ends can use.
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_DEFAULT_PASS_SUPPORT_H
15#define LLVM_DEFAULT_PASS_SUPPORT_H
16
17#include "llvm/PassSupport.h"
18
19namespace llvm {
20
21class PassManagerBase;
22
23/// Unique identifiers for the default standard passes.  The addresses of
24/// these symbols are used to uniquely identify passes from the default list.
25namespace DefaultStandardPasses {
26extern unsigned char AggressiveDCEID;
27extern unsigned char ArgumentPromotionID;
28extern unsigned char BasicAliasAnalysisID;
29extern unsigned char CFGSimplificationID;
30extern unsigned char ConstantMergeID;
31extern unsigned char CorrelatedValuePropagationID;
32extern unsigned char DeadArgEliminationID;
33extern unsigned char DeadStoreEliminationID;
34extern unsigned char EarlyCSEID;
35extern unsigned char FunctionAttrsID;
36extern unsigned char FunctionInliningID;
37extern unsigned char GVNID;
38extern unsigned char GlobalDCEID;
39extern unsigned char GlobalOptimizerID;
40extern unsigned char GlobalsModRefID;
41extern unsigned char IPSCCPID;
42extern unsigned char IndVarSimplifyID;
43extern unsigned char InlinerPlaceholderID;
44extern unsigned char InstructionCombiningID;
45extern unsigned char JumpThreadingID;
46extern unsigned char LICMID;
47extern unsigned char LoopDeletionID;
48extern unsigned char LoopIdiomID;
49extern unsigned char LoopRotateID;
50extern unsigned char LoopUnrollID;
51extern unsigned char LoopUnswitchID;
52extern unsigned char MemCpyOptID;
53extern unsigned char PruneEHID;
54extern unsigned char ReassociateID;
55extern unsigned char SCCPID;
56extern unsigned char ScalarReplAggregatesID;
57extern unsigned char SimplifyLibCallsID;
58extern unsigned char StripDeadPrototypesID;
59extern unsigned char TailCallEliminationID;
60extern unsigned char TypeBasedAliasAnalysisID;
61}
62
63/// StandardPass - The class responsible for maintaining the lists of standard
64class StandardPass {
65  friend class RegisterStandardPassLists;
66  public:
67  /// Predefined standard sets of passes
68  enum StandardSet {
69    AliasAnalysis,
70    Function,
71    Module,
72    LTO
73  };
74  /// Flags to specify whether a pass should be enabled.  Passes registered
75  /// with the standard sets may specify a minimum optimization level and one
76  /// or more flags that must be set when constructing the set for the pass to
77  /// be used.
78  enum OptimizationFlags {
79    /// Optimize for size was requested.
80    OptimizeSize = 1<<0,
81    /// Allow passes which may make global module changes.
82    UnitAtATime = 1<<1,
83    /// UnrollLoops - Allow loop unrolling.
84    UnrollLoops = 1<<2,
85    /// Allow library calls to be simplified.
86    SimplifyLibCalls = 1<<3,
87    /// Whether the module may have code using exceptions.
88    HaveExceptions = 1<<4,
89    // Run an inliner pass as part of this set.
90    RunInliner = 1<<5
91  };
92  enum OptimizationFlagComponents {
93    /// The low bits are used to store the optimization level.  When requesting
94    /// passes, this should store the requested optimisation level.  When
95    /// setting passes, this should set the minimum optimization level at which
96    /// the pass will run.
97    OptimizationLevelMask=0xf,
98    /// The maximum optimisation level at which the pass is run.
99    MaxOptimizationLevelMask=0xf0,
100    // Flags that must be set
101    RequiredFlagMask=0xff00,
102    // Flags that may not be set.
103    DisallowedFlagMask=0xff0000,
104    MaxOptimizationLevelShift=4,
105    RequiredFlagShift=8,
106    DisallowedFlagShift=16
107  };
108  /// Returns the optimisation level from a set of flags.
109  static unsigned OptimizationLevel(unsigned flags) {
110      return flags & OptimizationLevelMask;
111  }
112  /// Returns the maximum optimization level for this set of flags
113  static unsigned MaxOptimizationLevel(unsigned flags) {
114      return (flags & MaxOptimizationLevelMask) >> 4;
115  }
116  /// Constructs a set of flags from the specified minimum and maximum
117  /// optimisation level
118  static unsigned OptimzationFlags(unsigned minLevel=0, unsigned maxLevel=0xf,
119      unsigned requiredFlags=0, unsigned disallowedFlags=0) {
120    return ((minLevel & OptimizationLevelMask) |
121            ((maxLevel<<MaxOptimizationLevelShift) & MaxOptimizationLevelMask)
122            | ((requiredFlags<<RequiredFlagShift) & RequiredFlagMask)
123            | ((disallowedFlags<<DisallowedFlagShift) & DisallowedFlagMask));
124  }
125  /// Returns the flags that must be set for this to match
126  static unsigned RequiredFlags(unsigned flags) {
127      return (flags & RequiredFlagMask) >> RequiredFlagShift;
128  }
129  /// Returns the flags that must not be set for this to match
130  static unsigned DisallowedFlags(unsigned flags) {
131      return (flags & DisallowedFlagMask) >> DisallowedFlagShift;
132  }
133  /// Register a standard pass in the specified set.  If flags is non-zero,
134  /// then the pass will only be returned when the specified flags are set.
135  template<typename passName>
136  class RegisterStandardPass {
137    public:
138    RegisterStandardPass(StandardSet set, unsigned char *runBefore=0,
139        unsigned flags=0, unsigned char *ID=0) {
140      // Use the pass's ID if one is not specified
141      RegisterDefaultPass(PassInfo::NormalCtor_t(callDefaultCtor<passName>),
142               ID ? ID : (unsigned char*)&passName::ID, runBefore, set, flags);
143    }
144  };
145  /// Adds the passes from the specified set to the provided pass manager
146  static void AddPassesFromSet(PassManagerBase *PM,
147                               StandardSet set,
148                               unsigned flags=0,
149                               bool VerifyEach=false,
150                               Pass *inliner=0);
151  private:
152  /// Registers the default passes.  This is set by RegisterStandardPassLists
153  /// and is called lazily.
154  static void (*RegisterDefaultPasses)(void);
155  /// Creates the verifier pass that is inserted when a VerifyEach is passed to
156  /// AddPassesFromSet()
157  static Pass* (*CreateVerifierPass)(void);
158  /// Registers the pass
159  static void RegisterDefaultPass(PassInfo::NormalCtor_t constructor,
160                                  unsigned char *newPass,
161                                  unsigned char *oldPass,
162                                  StandardSet set,
163                                  unsigned flags=0);
164};
165
166} // namespace llvm
167
168#endif
169