llvm.org GIT mirror llvm / 6d1f753
[HotColdSplit] Move splitting earlier in the pipeline Performing splitting early has several advantages: - Inhibiting inlining of cold code early improves code size. Compared to scheduling splitting at the end of the pipeline, this cuts code size growth in half within the iOS shared cache (0.69% to 0.34%). - Inhibiting inlining of cold code improves compile time. There's no need to inline split cold functions, or to inline as much *within* those split functions as they are marked `minsize`. - During LTO, extra work is only done in the pre-link step. Less code must be inlined during cross-module inlining. An additional motivation here is that the most common cold regions identified by the static/conservative splitting heuristic can (a) be found before inlining and (b) do not grow after inlining. E.g. __assert_fail, os_log_error. The disadvantages are: - Some opportunities for splitting out cold code may be missed. This gap can potentially be narrowed by adding a worklist algorithm to the splitting pass. - Some opportunities to reduce code size may be lost (e.g. store sinking, when one side of the CFG diamond is split). This does not outweigh the code size benefits of splitting earlier. On net, splitting early in the pipeline has substantial code size benefits, and no major effects on memory locality or performance. We measured memory locality using ktrace data, and consistently found that 10% fewer pages were needed to capture 95% of text page faults in key iOS benchmarks. We measured performance on frequency-stabilized iOS devices using LNT+externals. This reverses course on the decision made to schedule splitting late in r344869 (D53437). Differential Revision: https://reviews.llvm.org/D57082 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@352080 91177308-0d34-0410-b5e6-96231b3b80d8 Vedant Kumar 6 months ago
5 changed file(s) with 50 addition(s) and 307 deletion(s). Raw diff Collapse all Expand all
657657 // globals.
658658 MPM.addPass(DeadArgumentEliminationPass());
659659
660 // Split out cold code. Splitting is done before inlining because 1) the most
661 // common kinds of cold regions can (a) be found before inlining and (b) do
662 // not grow after inlining, and 2) inhibiting inlining of cold code improves
663 // code size & compile time. Split after Mem2Reg to make code model estimates
664 // more accurate, but before InstCombine to allow it to clean things up.
665 if (EnableHotColdSplit && Phase != ThinLTOPhase::PostLink)
666 MPM.addPass(HotColdSplittingPass());
667
660668 // Create a small function pass pipeline to cleanup after all the global
661669 // optimizations.
662670 FunctionPassManager GlobalCleanupPM(DebugLogging);
721729 // CGSCC walk.
722730 MainCGPipeline.addPass(createCGSCCToFunctionPassAdaptor(
723731 buildFunctionSimplificationPipeline(Level, Phase, DebugLogging)));
724
725 // We only want to do hot cold splitting once for ThinLTO, during the
726 // post-link ThinLTO.
727 if (EnableHotColdSplit && Phase != ThinLTOPhase::PreLink)
728 MPM.addPass(HotColdSplittingPass());
729732
730733 for (auto &C : CGSCCOptimizerLateEPCallbacks)
731734 C(MainCGPipeline, Level);
419419
420420 void PassManagerBuilder::populateModulePassManager(
421421 legacy::PassManagerBase &MPM) {
422 // Whether this is a default or *LTO pre-link pipeline. The FullLTO post-link
423 // is handled separately, so just check this is not the ThinLTO post-link.
424 bool DefaultOrPreLinkPipeline = !PerformThinLTO;
425
422426 if (!PGOSampleUse.empty()) {
423427 MPM.add(createPruneEHPass());
424428 // In ThinLTO mode, when flattened profile is used, all the available
512516
513517 MPM.add(createDeadArgEliminationPass()); // Dead argument elimination
514518
519 // Split out cold code before inlining. See comment in the new PM
520 // (\ref buildModuleSimplificationPipeline).
521 if (EnableHotColdSplit && DefaultOrPreLinkPipeline)
522 MPM.add(createHotColdSplittingPass());
523
515524 addInstructionCombiningPass(MPM); // Clean up after IPCP & DAE
516525 addExtensionsToPM(EP_Peephole, MPM);
517526 MPM.add(createCFGSimplificationPass()); // Clean up after IPCP & DAE
521530 // profile annotation in backend more difficult.
522531 // PGO instrumentation is added during the compile phase for ThinLTO, do
523532 // not run it a second time
524 if (!PerformThinLTO && !PrepareForThinLTOUsingPGOSampleProfile)
533 if (DefaultOrPreLinkPipeline && !PrepareForThinLTOUsingPGOSampleProfile)
525534 addPGOInstrPasses(MPM);
526535
527536 // We add a module alias analysis pass here. In part due to bugs in the
736745 // flattening of blocks.
737746 MPM.add(createDivRemPairsPass());
738747
739 if (EnableHotColdSplit)
740 MPM.add(createHotColdSplittingPass());
741
742748 // LoopSink (and other loop passes since the last simplifyCFG) might have
743749 // resulted in single-entry-single-exit or empty blocks. Clean up the CFG.
744750 MPM.add(createCFGSimplificationPass());
0 ; RUN: opt -module-summary %s -o %t.bc
1 ; RUN: llvm-lto -hot-cold-split=true -thinlto-action=run %t.bc -debug-pass=Structure 2>&1 | FileCheck %s -check-prefix=OLDPM-THINLTO-POSTLINK-Os
2
3 ; REQUIRES: asserts
4
5 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
6 target triple = "x86_64-unknown-linux-gnu"
7
8 ; OLDPM-THINLTO-POSTLINK-Os-LABEL: Pass Arguments
9 ; OLDPM-THINLTO-POSTLINK-Os-NOT: Hot Cold Splitting
2525 ; RUN: opt -disable-verify -debug-pass-manager -new-pm-debug-info-for-profiling \
2626 ; RUN: -passes='thinlto-pre-link,name-anon-globals' -S %s 2>&1 \
2727 ; RUN: | FileCheck %s --check-prefixes=CHECK-DIS,CHECK-O,CHECK-O2,CHECK-PRELINK-O,CHECK-PRELINK-O2
28 ; Enabling the hot-cold-split pass should not affect the ThinLTO pre-link
29 ; RUN: opt -disable-verify -debug-pass-manager \
30 ; RUN: -passes='thinlto-pre-link,name-anon-globals' -hot-cold-split -S %s 2>&1 \
31 ; RUN: | FileCheck %s --check-prefixes=CHECK-O,CHECK-O2,CHECK-PRELINK-O,CHECK-PRELINK-O-NODIS,CHECK-PRELINK-O2
3228 ;
3329 ; Postlink pipelines:
3430 ; RUN: opt -disable-verify -debug-pass-manager \
None ; RUN: opt -mtriple=x86_64-- -Os -hotcoldsplit -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s
0 ; RUN: opt -mtriple=x86_64-- -Os -hot-cold-split=true -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=DEFAULT-Os
1 ; RUN: opt -mtriple=x86_64-- -Os -hot-cold-split=true -passes='lto-pre-link' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=LTO-PRELINK-Os
2 ; RUN: opt -mtriple=x86_64-- -Os -hot-cold-split=true -passes='thinlto-pre-link' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=THINLTO-PRELINK-Os
3 ; RUN: opt -mtriple=x86_64-- -Os -hot-cold-split=true -passes='thinlto' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=THINLTO-POSTLINK-Os
4
15 ; REQUIRES: asserts
26
3 ; CHECK-LABEL: Pass Arguments:
4 ; CHECK-NEXT: Target Transform Information
5 ; CHECK-NEXT: Type-Based Alias Analysis
6 ; CHECK-NEXT: Scoped NoAlias Alias Analysis
7 ; CHECK-NEXT: Assumption Cache Tracker
8 ; CHECK-NEXT: Target Library Information
9 ; CHECK-NEXT: FunctionPass Manager
10 ; CHECK-NEXT: Module Verifier
11 ; CHECK-NEXT: Instrument function entry/exit with calls to e.g. mcount() (pre inlining)
12 ; CHECK-NEXT: Simplify the CFG
13 ; CHECK-NEXT: Dominator Tree Construction
14 ; CHECK-NEXT: SROA
15 ; CHECK-NEXT: Early CSE
16 ; CHECK-NEXT: Lower 'expect' Intrinsics
17 ; CHECK-NEXT: Pass Arguments:
18 ; CHECK-NEXT: Target Library Information
19 ; CHECK-NEXT: Target Transform Information
20 ; Target Pass Configuration
21 ; CHECK: Type-Based Alias Analysis
22 ; CHECK-NEXT: Scoped NoAlias Alias Analysis
23 ; CHECK-NEXT: Assumption Cache Tracker
24 ; CHECK-NEXT: Profile summary info
25 ; CHECK-NEXT: ModulePass Manager
26 ; CHECK-NEXT: Force set function attributes
27 ; CHECK-NEXT: Infer set function attributes
28 ; CHECK-NEXT: Interprocedural Sparse Conditional Constant Propagation
29 ; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
30 ; CHECK-NEXT: Called Value Propagation
31 ; CHECK-NEXT: Global Variable Optimizer
32 ; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
33 ; CHECK-NEXT: FunctionPass Manager
34 ; CHECK-NEXT: Dominator Tree Construction
35 ; CHECK-NEXT: Promote Memory to Register
36 ; CHECK-NEXT: Dead Argument Elimination
37 ; CHECK-NEXT: FunctionPass Manager
38 ; CHECK-NEXT: Dominator Tree Construction
39 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
40 ; CHECK-NEXT: Function Alias Analysis Results
41 ; CHECK-NEXT: Natural Loop Information
42 ; CHECK-NEXT: Lazy Branch Probability Analysis
43 ; CHECK-NEXT: Lazy Block Frequency Analysis
44 ; CHECK-NEXT: Optimization Remark Emitter
45 ; CHECK-NEXT: Combine redundant instructions
46 ; CHECK-NEXT: Simplify the CFG
47 ; CHECK-NEXT: CallGraph Construction
48 ; CHECK-NEXT: Globals Alias Analysis
49 ; CHECK-NEXT: Call Graph SCC Pass Manager
50 ; CHECK-NEXT: Remove unused exception handling info
51 ; CHECK-NEXT: Function Integration/Inlining
52 ; CHECK-NEXT: Deduce function attributes
53 ; CHECK-NEXT: FunctionPass Manager
54 ; CHECK-NEXT: Dominator Tree Construction
55 ; CHECK-NEXT: SROA
56 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
57 ; CHECK-NEXT: Function Alias Analysis Results
58 ; CHECK-NEXT: Memory SSA
59 ; CHECK-NEXT: Early CSE w/ MemorySSA
60 ; CHECK-NEXT: Speculatively execute instructions if target has divergent branches
61 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
62 ; CHECK-NEXT: Function Alias Analysis Results
63 ; CHECK-NEXT: Lazy Value Information Analysis
64 ; CHECK-NEXT: Jump Threading
65 ; CHECK-NEXT: Value Propagation
66 ; CHECK-NEXT: Simplify the CFG
67 ; CHECK-NEXT: Dominator Tree Construction
68 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
69 ; CHECK-NEXT: Function Alias Analysis Results
70 ; CHECK-NEXT: Natural Loop Information
71 ; CHECK-NEXT: Lazy Branch Probability Analysis
72 ; CHECK-NEXT: Lazy Block Frequency Analysis
73 ; CHECK-NEXT: Optimization Remark Emitter
74 ; CHECK-NEXT: Combine redundant instructions
75 ; CHECK-NEXT: Optimization Remark Emitter
76 ; CHECK-NEXT: Tail Call Elimination
77 ; CHECK-NEXT: Simplify the CFG
78 ; CHECK-NEXT: Reassociate expressions
79 ; CHECK-NEXT: Dominator Tree Construction
80 ; CHECK-NEXT: Natural Loop Information
81 ; CHECK-NEXT: Canonicalize natural loops
82 ; CHECK-NEXT: LCSSA Verifier
83 ; CHECK-NEXT: Loop-Closed SSA Form Pass
84 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
85 ; CHECK-NEXT: Function Alias Analysis Results
86 ; CHECK-NEXT: Scalar Evolution Analysis
87 ; CHECK-NEXT: Loop Pass Manager
88 ; CHECK-NEXT: Rotate Loops
89 ; CHECK-NEXT: Loop Invariant Code Motion
90 ; CHECK-NEXT: Unswitch loops
91 ; CHECK-NEXT: Simplify the CFG
92 ; CHECK-NEXT: Dominator Tree Construction
93 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
94 ; CHECK-NEXT: Function Alias Analysis Results
95 ; CHECK-NEXT: Natural Loop Information
96 ; CHECK-NEXT: Lazy Branch Probability Analysis
97 ; CHECK-NEXT: Lazy Block Frequency Analysis
98 ; CHECK-NEXT: Optimization Remark Emitter
99 ; CHECK-NEXT: Combine redundant instructions
100 ; CHECK-NEXT: Canonicalize natural loops
101 ; CHECK-NEXT: LCSSA Verifier
102 ; CHECK-NEXT: Loop-Closed SSA Form Pass
103 ; CHECK-NEXT: Scalar Evolution Analysis
104 ; CHECK-NEXT: Loop Pass Manager
105 ; CHECK-NEXT: Induction Variable Simplification
106 ; CHECK-NEXT: Recognize loop idioms
107 ; CHECK-NEXT: Delete dead loops
108 ; CHECK-NEXT: Unroll loops
109 ; CHECK-NEXT: MergedLoadStoreMotion
110 ; CHECK-NEXT: Phi Values Analysis
111 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
112 ; CHECK-NEXT: Function Alias Analysis Results
113 ; CHECK-NEXT: Memory Dependence Analysis
114 ; CHECK-NEXT: Lazy Branch Probability Analysis
115 ; CHECK-NEXT: Lazy Block Frequency Analysis
116 ; CHECK-NEXT: Optimization Remark Emitter
117 ; CHECK-NEXT: Global Value Numbering
118 ; CHECK-NEXT: Phi Values Analysis
119 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
120 ; CHECK-NEXT: Function Alias Analysis Results
121 ; CHECK-NEXT: Memory Dependence Analysis
122 ; CHECK-NEXT: MemCpy Optimization
123 ; CHECK-NEXT: Sparse Conditional Constant Propagation
124 ; CHECK-NEXT: Demanded bits analysis
125 ; CHECK-NEXT: Bit-Tracking Dead Code Elimination
126 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
127 ; CHECK-NEXT: Function Alias Analysis Results
128 ; CHECK-NEXT: Natural Loop Information
129 ; CHECK-NEXT: Lazy Branch Probability Analysis
130 ; CHECK-NEXT: Lazy Block Frequency Analysis
131 ; CHECK-NEXT: Optimization Remark Emitter
132 ; CHECK-NEXT: Combine redundant instructions
133 ; CHECK-NEXT: Lazy Value Information Analysis
134 ; CHECK-NEXT: Jump Threading
135 ; CHECK-NEXT: Value Propagation
136 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
137 ; CHECK-NEXT: Function Alias Analysis Results
138 ; CHECK-NEXT: Phi Values Analysis
139 ; CHECK-NEXT: Memory Dependence Analysis
140 ; CHECK-NEXT: Dead Store Elimination
141 ; CHECK-NEXT: Natural Loop Information
142 ; CHECK-NEXT: Canonicalize natural loops
143 ; CHECK-NEXT: LCSSA Verifier
144 ; CHECK-NEXT: Loop-Closed SSA Form Pass
145 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
146 ; CHECK-NEXT: Function Alias Analysis Results
147 ; CHECK-NEXT: Scalar Evolution Analysis
148 ; CHECK-NEXT: Loop Pass Manager
149 ; CHECK-NEXT: Loop Invariant Code Motion
150 ; CHECK-NEXT: Post-Dominator Tree Construction
151 ; CHECK-NEXT: Aggressive Dead Code Elimination
152 ; CHECK-NEXT: Simplify the CFG
153 ; CHECK-NEXT: Dominator Tree Construction
154 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
155 ; CHECK-NEXT: Function Alias Analysis Results
156 ; CHECK-NEXT: Natural Loop Information
157 ; CHECK-NEXT: Lazy Branch Probability Analysis
158 ; CHECK-NEXT: Lazy Block Frequency Analysis
159 ; CHECK-NEXT: Optimization Remark Emitter
160 ; CHECK-NEXT: Combine redundant instructions
161 ; CHECK-NEXT: A No-Op Barrier Pass
162 ; CHECK-NEXT: Eliminate Available Externally Globals
163 ; CHECK-NEXT: CallGraph Construction
164 ; CHECK-NEXT: Deduce function attributes in RPO
165 ; CHECK-NEXT: Global Variable Optimizer
166 ; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
167 ; CHECK-NEXT: Dead Global Elimination
168 ; CHECK-NEXT: CallGraph Construction
169 ; CHECK-NEXT: Globals Alias Analysis
170 ; CHECK-NEXT: FunctionPass Manager
171 ; CHECK-NEXT: Float to int
172 ; CHECK-NEXT: Dominator Tree Construction
173 ; CHECK-NEXT: Natural Loop Information
174 ; CHECK-NEXT: Canonicalize natural loops
175 ; CHECK-NEXT: LCSSA Verifier
176 ; CHECK-NEXT: Loop-Closed SSA Form Pass
177 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
178 ; CHECK-NEXT: Function Alias Analysis Results
179 ; CHECK-NEXT: Scalar Evolution Analysis
180 ; CHECK-NEXT: Loop Pass Manager
181 ; CHECK-NEXT: Rotate Loops
182 ; CHECK-NEXT: Loop Access Analysis
183 ; CHECK-NEXT: Lazy Branch Probability Analysis
184 ; CHECK-NEXT: Lazy Block Frequency Analysis
185 ; CHECK-NEXT: Optimization Remark Emitter
186 ; CHECK-NEXT: Loop Distribution
187 ; CHECK-NEXT: Branch Probability Analysis
188 ; CHECK-NEXT: Block Frequency Analysis
189 ; CHECK-NEXT: Scalar Evolution Analysis
190 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
191 ; CHECK-NEXT: Function Alias Analysis Results
192 ; CHECK-NEXT: Loop Access Analysis
193 ; CHECK-NEXT: Demanded bits analysis
194 ; CHECK-NEXT: Lazy Branch Probability Analysis
195 ; CHECK-NEXT: Lazy Block Frequency Analysis
196 ; CHECK-NEXT: Optimization Remark Emitter
197 ; CHECK-NEXT: Loop Vectorization
198 ; CHECK-NEXT: Canonicalize natural loops
199 ; CHECK-NEXT: Scalar Evolution Analysis
200 ; CHECK-NEXT: Function Alias Analysis Results
201 ; CHECK-NEXT: Loop Access Analysis
202 ; CHECK-NEXT: Loop Load Elimination
203 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
204 ; CHECK-NEXT: Function Alias Analysis Results
205 ; CHECK-NEXT: Lazy Branch Probability Analysis
206 ; CHECK-NEXT: Lazy Block Frequency Analysis
207 ; CHECK-NEXT: Optimization Remark Emitter
208 ; CHECK-NEXT: Combine redundant instructions
209 ; CHECK-NEXT: Simplify the CFG
210 ; CHECK-NEXT: Dominator Tree Construction
211 ; CHECK-NEXT: Natural Loop Information
212 ; CHECK-NEXT: Scalar Evolution Analysis
213 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
214 ; CHECK-NEXT: Function Alias Analysis Results
215 ; CHECK-NEXT: Demanded bits analysis
216 ; CHECK-NEXT: Lazy Branch Probability Analysis
217 ; CHECK-NEXT: Lazy Block Frequency Analysis
218 ; CHECK-NEXT: Optimization Remark Emitter
219 ; CHECK-NEXT: SLP Vectorizer
220 ; CHECK-NEXT: Optimization Remark Emitter
221 ; CHECK-NEXT: Combine redundant instructions
222 ; CHECK-NEXT: Canonicalize natural loops
223 ; CHECK-NEXT: LCSSA Verifier
224 ; CHECK-NEXT: Loop-Closed SSA Form Pass
225 ; CHECK-NEXT: Scalar Evolution Analysis
226 ; CHECK-NEXT: Loop Pass Manager
227 ; CHECK-NEXT: Unroll loops
228 ; CHECK-NEXT: Lazy Branch Probability Analysis
229 ; CHECK-NEXT: Lazy Block Frequency Analysis
230 ; CHECK-NEXT: Optimization Remark Emitter
231 ; CHECK-NEXT: Combine redundant instructions
232 ; CHECK-NEXT: Canonicalize natural loops
233 ; CHECK-NEXT: LCSSA Verifier
234 ; CHECK-NEXT: Loop-Closed SSA Form Pass
235 ; CHECK-NEXT: Scalar Evolution Analysis
236 ; CHECK-NEXT: Loop Pass Manager
237 ; CHECK-NEXT: Loop Invariant Code Motion
238 ; CHECK-NEXT: Lazy Branch Probability Analysis
239 ; CHECK-NEXT: Lazy Block Frequency Analysis
240 ; CHECK-NEXT: Optimization Remark Emitter
241 ; CHECK-NEXT: Warn about non-applied transformations
242 ; CHECK-NEXT: Alignment from assumptions
243 ; CHECK-NEXT: Strip Unused Function Prototypes
244 ; CHECK-NEXT: Dead Global Elimination
245 ; CHECK-NEXT: Merge Duplicate Global Constants
246 ; CHECK-NEXT: FunctionPass Manager
247 ; CHECK-NEXT: Dominator Tree Construction
248 ; CHECK-NEXT: Natural Loop Information
249 ; CHECK-NEXT: Branch Probability Analysis
250 ; CHECK-NEXT: Block Frequency Analysis
251 ; CHECK-NEXT: Canonicalize natural loops
252 ; CHECK-NEXT: LCSSA Verifier
253 ; CHECK-NEXT: Loop-Closed SSA Form Pass
254 ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl)
255 ; CHECK-NEXT: Function Alias Analysis Results
256 ; CHECK-NEXT: Scalar Evolution Analysis
257 ; CHECK-NEXT: Branch Probability Analysis
258 ; CHECK-NEXT: Block Frequency Analysis
259 ; CHECK-NEXT: Loop Pass Manager
260 ; CHECK-NEXT: Loop Sink
261 ; CHECK-NEXT: Lazy Branch Probability Analysis
262 ; CHECK-NEXT: Lazy Block Frequency Analysis
263 ; CHECK-NEXT: Optimization Remark Emitter
264 ; CHECK-NEXT: Remove redundant instructions
265 ; CHECK-NEXT: Hoist/decompose integer division and remainder
266 ; CHECK-NEXT: Simplify the CFG
267 ; CHECK-NEXT: Hot Cold Splitting
268 ; CHECK-NEXT: Unnamed pass: implement Pass::getPassName()
269 ; CHECK-NEXT: FunctionPass Manager
270 ; CHECK-NEXT: Module Verifier
271 ; CHECK-NEXT: Bitcode Writer
272 ; CHECK-NEXT: Pass Arguments: -domtree
273 ; CHECK-NEXT: FunctionPass Manager
274 ; CHECK-NEXT: Dominator Tree Construction
275 ; CHECK-NEXT: Pass Arguments: -targetlibinfo -domtree -loops -branch-prob -block-freq
276 ; CHECK-NEXT: Target Library Information
277 ; CHECK-NEXT: FunctionPass Manager
278 ; CHECK-NEXT: Dominator Tree Construction
279 ; CHECK-NEXT: Natural Loop Information
280 ; CHECK-NEXT: Branch Probability Analysis
281 ; CHECK-NEXT: Block Frequency Analysis
282 ; CHECK-NEXT: Pass Arguments: -targetlibinfo -domtree -loops -branch-prob -block-freq
283 ; CHECK-NEXT: Target Library Information
284 ; CHECK-NEXT: FunctionPass Manager
285 ; CHECK-NEXT: Dominator Tree Construction
286 ; CHECK-NEXT: Natural Loop Information
287 ; CHECK-NEXT: Branch Probability Analysis
288 ; CHECK-NEXT: Block Frequency Analysis
289 ; CHECK-NEXT: Pass Arguments: -targetlibinfo -domtree -loops -branch-prob -block-freq
290 ; CHECK-NEXT: Target Library Information
291 ; CHECK-NEXT: FunctionPass Manager
292 ; CHECK-NEXT: Dominator Tree Construction
293 ; CHECK-NEXT: Natural Loop Information
294 ; CHECK-NEXT: Branch Probability Analysis
295 ; CHECK-NEXT: Block Frequency Analysis
7 ; Splitting should occur after Mem2Reg and should be followed by InstCombine.
8
9 ; DEFAULT-Os: Promote Memory to Register
10 ; DEFAULT-Os: Hot Cold Splitting
11 ; DEFAULT-Os: Combine redundant instructions
12
13 ; LTO-PRELINK-Os-LABEL: Starting llvm::Module pass manager run.
14 ; LTO-PRELINK-Os: Running pass: ModuleToFunctionPassAdaptor
15 ; LTO-PRELINK-Os: Running pass: HotColdSplittingPass
16 ; LTO-PRELINK-Os: Running pass: ModuleToFunctionPassAdaptor >
17
18 ; THINLTO-PRELINK-Os-LABEL: Running analysis: PassInstrumentationAnalysis
19 ; THINLTO-PRELINK-Os: Running pass: ModuleToFunctionPassAdaptor
20 ; THINLTO-PRELINK-Os: Running pass: HotColdSplittingPass
21 ; THINLTO-PRELINK-Os: Running pass: ModuleToFunctionPassAdaptor >
22
23 ; THINLTO-POSTLINK-Os-NOT: HotColdSplitting