1 //===-- Passes.h - Target independent code generation passes ----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines interfaces to access the target independent code generation
11 // passes provided by the LLVM backend.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CODEGEN_PASSES_H
16 #define LLVM_CODEGEN_PASSES_H
26 class RegisterCoalescer;
28 /// createUnreachableBlockEliminationPass - The LLVM code generator does not
29 /// work well with unreachable basic blocks (what live ranges make sense for a
30 /// block that cannot be reached?). As such, a code generator should either
31 /// not instruction select unreachable blocks, or it can run this pass as it's
32 /// last LLVM modifying pass to clean up blocks that are not reachable from
34 FunctionPass *createUnreachableBlockEliminationPass();
36 /// MachineFunctionPrinter pass - This pass prints out the machine function to
37 /// standard error, as a debugging tool.
38 FunctionPass *createMachineFunctionPrinterPass(std::ostream *OS,
39 const std::string &Banner ="");
41 /// MachineLoopInfo pass - This pass is a loop analysis pass.
43 extern const PassInfo *const MachineLoopInfoID;
45 /// MachineDominators pass - This pass is a machine dominators analysis pass.
47 extern const PassInfo *const MachineDominatorsID;
49 /// PHIElimination pass - This pass eliminates machine instruction PHI nodes
50 /// by inserting copy instructions. This destroys SSA information, but is the
51 /// desired input for some register allocators. This pass is "required" by
52 /// these register allocator like this: AU.addRequiredID(PHIEliminationID);
54 extern const PassInfo *const PHIEliminationID;
56 /// StrongPHIElimination pass - This pass eliminates machine instruction PHI
57 /// nodes by inserting copy instructions. This destroys SSA information, but
58 /// is the desired input for some register allocators. This pass is
59 /// "required" by these register allocator like this:
60 /// AU.addRequiredID(PHIEliminationID);
61 /// This pass is still in development
62 extern const PassInfo *const StrongPHIEliminationID;
64 /// SimpleRegisterCoalescing pass. Aggressively coalesces every register
67 extern const PassInfo *const SimpleRegisterCoalescingID;
69 /// TwoAddressInstruction pass - This pass reduces two-address instructions to
70 /// use two operands. This destroys SSA information but it is desired by
71 /// register allocators.
72 extern const PassInfo *const TwoAddressInstructionPassID;
74 /// UnreachableMachineBlockElimination pass - This pass removes unreachable
75 /// machine basic blocks.
76 extern const PassInfo *const UnreachableMachineBlockElimID;
78 /// Creates a register allocator as the user specified on the command line.
80 FunctionPass *createRegisterAllocator();
82 /// SimpleRegisterAllocation Pass - This pass converts the input machine code
83 /// from SSA form to use explicit registers by spilling every register. Wow,
86 FunctionPass *createSimpleRegisterAllocator();
88 /// LocalRegisterAllocation Pass - This pass register allocates the input code
89 /// a basic block at a time, yielding code better than the simple register
90 /// allocator, but not as good as a global allocator.
92 FunctionPass *createLocalRegisterAllocator();
94 /// BigBlockRegisterAllocation Pass - The BigBlock register allocator
95 /// munches single basic blocks at a time, like the local register
96 /// allocator. While the BigBlock allocator is a little slower, and uses
97 /// somewhat more memory than the local register allocator, it tends to
98 /// yield the best allocations (of any of the allocators) for blocks that
99 /// have hundreds or thousands of instructions in sequence.
101 FunctionPass *createBigBlockRegisterAllocator();
103 /// LinearScanRegisterAllocation Pass - This pass implements the linear scan
104 /// register allocation algorithm, a global register allocator.
106 FunctionPass *createLinearScanRegisterAllocator();
108 /// SimpleRegisterCoalescing Pass - Coalesce all copies possible. Can run
109 /// independently of the register allocator.
111 RegisterCoalescer *createSimpleRegisterCoalescer();
113 /// PrologEpilogCodeInserter Pass - This pass inserts prolog and epilog code,
114 /// and eliminates abstract frame references.
116 FunctionPass *createPrologEpilogCodeInserter();
118 /// LowerSubregs Pass - This pass lowers subregs to register-register copies
119 /// which yields suboptimal, but correct code if the register allocator
120 /// cannot coalesce all subreg operations during allocation.
122 FunctionPass *createLowerSubregsPass();
124 /// createPostRAScheduler - under development.
125 FunctionPass *createPostRAScheduler();
127 /// BranchFolding Pass - This pass performs machine code CFG based
128 /// optimizations to delete branches to branches, eliminate branches to
129 /// successor blocks (creating fall throughs), and eliminating branches over
131 FunctionPass *createBranchFoldingPass(bool DefaultEnableTailMerge);
133 /// IfConverter Pass - This pass performs machine code if conversion.
134 FunctionPass *createIfConverterPass();
136 /// LoopAligner Pass - This pass aligns loop headers to target specific
137 /// alignment boundary.
138 FunctionPass *createLoopAlignerPass();
140 /// DebugLabelFoldingPass - This pass prunes out redundant debug labels. This
141 /// allows a debug emitter to determine if the range of two labels is empty,
142 /// by seeing if the labels map to the same reduced label.
143 FunctionPass *createDebugLabelFoldingPass();
145 /// MachineCodeDeletion Pass - This pass deletes all of the machine code for
146 /// the current function, which should happen after the function has been
147 /// emitted to a .s file or to memory.
148 FunctionPass *createMachineCodeDeleter();
150 /// getRegisterAllocator - This creates an instance of the register allocator
152 FunctionPass *getRegisterAllocator(TargetMachine &T);
154 /// IntrinsicLowering Pass - Performs target-independent LLVM IR
155 /// transformations for highly portable strategies.
156 FunctionPass *createGCLoweringPass();
158 /// MachineCodeAnalysis Pass - Target-independent pass to mark safe points in
159 /// machine code. Must be added very late during code generation, just prior
160 /// to output, and importantly after all CFG transformations (such as branch
162 FunctionPass *createGCMachineCodeAnalysisPass();
164 /// Deleter Pass - Releases GC metadata.
166 FunctionPass *createGCInfoDeleter();
168 /// Creates a pass to print GC metadata.
170 FunctionPass *createGCInfoPrinter(std::ostream &OS);
172 /// createMachineLICMPass - This pass performs LICM on machine instructions.
174 FunctionPass *createMachineLICMPass();
176 /// createMachineSinkingPass - This pass performs sinking on machine
178 FunctionPass *createMachineSinkingPass();
180 /// createStackSlotColoringPass - This pass performs stack slot coloring.
181 FunctionPass *createStackSlotColoringPass();
183 } // End llvm namespace