llvm.org GIT mirror llvm / b2b950d
[instsimplify] Move the instsimplify pass to use more obvious file names and diretory. Also cleans up all the associated naming to be consistent and removes the public access to the pass ID which was unused in LLVM. Also runs clang-format over parts that changed, which generally cleans up a bunch of formatting. This is in preparation for doing some internal cleanups to the pass. Differential Revision: https://reviews.llvm.org/D47352 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@336028 91177308-0d34-0410-b5e6-96231b3b80d8 Chandler Carruth 1 year, 2 months ago
16 changed file(s) with 204 addition(s) and 202 deletion(s). Raw diff Collapse all Expand all
176176 void initializeInlineCostAnalysisPass(PassRegistry&);
177177 void initializeInstCountPass(PassRegistry&);
178178 void initializeInstNamerPass(PassRegistry&);
179 void initializeInstSimplifierPass(PassRegistry&);
179 void initializeInstSimplifyLegacyPassPass(PassRegistry &);
180180 void initializeInstrProfilingLegacyPassPass(PassRegistry&);
181181 void initializeInstructionCombiningPassPass(PassRegistry&);
182182 void initializeInstructionSelectPass(PassRegistry&);
4848 #include "llvm/Transforms/ObjCARC.h"
4949 #include "llvm/Transforms/Scalar.h"
5050 #include "llvm/Transforms/Scalar/GVN.h"
51 #include "llvm/Transforms/Scalar/InstSimplifyPass.h"
5152 #include "llvm/Transforms/Utils.h"
5253 #include "llvm/Transforms/Utils/SymbolRewriter.h"
5354 #include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
115116 (void) llvm::createIPSCCPPass();
116117 (void) llvm::createInductiveRangeCheckEliminationPass();
117118 (void) llvm::createIndVarSimplifyPass();
119 (void) llvm::createInstSimplifyLegacyPass();
118120 (void) llvm::createInstructionCombiningPass();
119121 (void) llvm::createInternalizePass();
120122 (void) llvm::createLCSSAPass();
199201 (void) llvm::createLowerAtomicPass();
200202 (void) llvm::createCorrelatedValuePropagationPass();
201203 (void) llvm::createMemDepPrinter();
202 (void) llvm::createInstructionSimplifierPass();
203204 (void) llvm::createLoopVectorizePass();
204205 (void) llvm::createSLPVectorizerPass();
205206 (void) llvm::createLoadStoreVectorizerPass();
0 //===- InstSimplifyPass.h ---------------------------------------*- C++ -*-===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 /// \file
9 ///
10 /// Defines passes for running instruction simplification across chunks of IR.
11 ///
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_TRANSFORMS_UTILS_INSTSIMPLIFYPASS_H
15 #define LLVM_TRANSFORMS_UTILS_INSTSIMPLIFYPASS_H
16
17 #include "llvm/IR/PassManager.h"
18
19 namespace llvm {
20
21 class FunctionPass;
22
23 /// Run instruction simplification across each instruction in the function.
24 ///
25 /// Instruction simplification has useful constraints in some contexts:
26 /// - It will never introduce *new* instructions.
27 /// - There is no need to iterate to a fixed point.
28 ///
29 /// Many passes use instruction simplification as a library facility, but it may
30 /// also be useful (in tests and other contexts) to have access to this very
31 /// restricted transform at a pass granularity. However, for a much more
32 /// powerful and comprehensive peephole optimization engine, see the
33 /// `instcombine` pass instead.
34 class InstSimplifyPass : public PassInfoMixin {
35 public:
36 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
37 };
38
39 /// Create a legacy pass that does instruction simplification on each
40 /// instruction in a function.
41 FunctionPass *createInstSimplifyLegacyPass();
42
43 } // end namespace llvm
44
45 #endif // LLVM_TRANSFORMS_UTILS_INSTSIMPLIFYPASS_H
+0
-31
include/llvm/Transforms/Utils/SimplifyInstructions.h less more
None //===- SimplifyInstructions.h - Remove redundant instructions ---*- C++ -*-===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This is a utility pass used for testing the InstructionSimplify analysis.
10 // The analysis is applied to every instruction, and if it simplifies then the
11 // instruction is replaced by the simplification. If you are looking for a pass
12 // that performs serious instruction folding, use the instcombine pass instead.
13 //
14 //===----------------------------------------------------------------------===//
15
16 #ifndef LLVM_TRANSFORMS_UTILS_SIMPLIFYINSTRUCTIONS_H
17 #define LLVM_TRANSFORMS_UTILS_SIMPLIFYINSTRUCTIONS_H
18
19 #include "llvm/IR/PassManager.h"
20
21 namespace llvm {
22
23 /// This pass removes redundant instructions.
24 class InstSimplifierPass : public PassInfoMixin {
25 public:
26 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
27 };
28 } // end namespace llvm
29
30 #endif // LLVM_TRANSFORMS_UTILS_SIMPLIFYINSTRUCTIONS_H
109109 Pass *createLoopSimplifyPass();
110110 extern char &LoopSimplifyID;
111111
112 //===----------------------------------------------------------------------===//
113 //
114 // InstructionSimplifier - Remove redundant instructions.
115 //
116 FunctionPass *createInstructionSimplifierPass();
117 extern char &InstructionSimplifierID;
118
119112 /// This function returns a new pass that downgrades the debug info in the
120113 /// module to line tables only.
121114 ModulePass *createStripNonLineTableDebugInfoPass();
6060 #include "llvm/Support/Regex.h"
6161 #include "llvm/Target/TargetMachine.h"
6262 #include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h"
63 #include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
6463 #include "llvm/Transforms/IPO/AlwaysInliner.h"
6564 #include "llvm/Transforms/IPO/ArgumentPromotion.h"
6665 #include "llvm/Transforms/IPO/CalledValuePropagation.h"
8584 #include "llvm/Transforms/IPO/SyntheticCountsPropagation.h"
8685 #include "llvm/Transforms/IPO/WholeProgramDevirt.h"
8786 #include "llvm/Transforms/InstCombine/InstCombine.h"
87 #include "llvm/Transforms/Instrumentation/BoundsChecking.h"
88 #include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
8889 #include "llvm/Transforms/Instrumentation/InstrProfiling.h"
89 #include "llvm/Transforms/Instrumentation/BoundsChecking.h"
9090 #include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
9191 #include "llvm/Transforms/Scalar/ADCE.h"
9292 #include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h"
104104 #include "llvm/Transforms/Scalar/IVUsersPrinter.h"
105105 #include "llvm/Transforms/Scalar/IndVarSimplify.h"
106106 #include "llvm/Transforms/Scalar/InductiveRangeCheckElimination.h"
107 #include "llvm/Transforms/Scalar/InstSimplifyPass.h"
107108 #include "llvm/Transforms/Scalar/JumpThreading.h"
108109 #include "llvm/Transforms/Scalar/LICM.h"
109110 #include "llvm/Transforms/Scalar/LoopAccessAnalysisPrinter.h"
147148 #include "llvm/Transforms/Utils/LowerInvoke.h"
148149 #include "llvm/Transforms/Utils/Mem2Reg.h"
149150 #include "llvm/Transforms/Utils/NameAnonGlobals.h"
150 #include "llvm/Transforms/Utils/SimplifyInstructions.h"
151151 #include "llvm/Transforms/Utils/SymbolRewriter.h"
152152 #include "llvm/Transforms/Vectorize/LoopVectorize.h"
153153 #include "llvm/Transforms/Vectorize/SLPVectorizer.h"
813813 OptimizePM.addPass(LoopSinkPass());
814814
815815 // And finally clean up LCSSA form before generating code.
816 OptimizePM.addPass(InstSimplifierPass());
816 OptimizePM.addPass(InstSimplifyPass());
817817
818818 // This hoists/decomposes div/rem ops. It should run after other sink/hoist
819819 // passes to avoid re-sinking, but before SimplifyCFG because it can allow
158158 FUNCTION_PASS("post-inline-ee-instrument", EntryExitInstrumenterPass(/*PostInlining=*/true))
159159 FUNCTION_PASS("gvn-hoist", GVNHoistPass())
160160 FUNCTION_PASS("instcombine", InstCombinePass())
161 FUNCTION_PASS("instsimplify", InstSimplifierPass())
161 FUNCTION_PASS("instsimplify", InstSimplifyPass())
162162 FUNCTION_PASS("invalidate", InvalidateAllAnalysesPass())
163163 FUNCTION_PASS("float2int", Float2IntPass())
164164 FUNCTION_PASS("no-op-function", NoOpFunctionPass())
3737 #include "llvm/Transforms/Instrumentation.h"
3838 #include "llvm/Transforms/Scalar.h"
3939 #include "llvm/Transforms/Scalar/GVN.h"
40 #include "llvm/Transforms/Scalar/InstSimplifyPass.h"
4041 #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
4142 #include "llvm/Transforms/Utils.h"
4243 #include "llvm/Transforms/Vectorize.h"
702703 // result too early.
703704 MPM.add(createLoopSinkPass());
704705 // Get rid of LCSSA nodes.
705 MPM.add(createInstructionSimplifierPass());
706 MPM.add(createInstSimplifyLegacyPass());
706707
707708 // This hoists/decomposes div/rem ops. It should run after other sink/hoist
708709 // passes to avoid re-sinking, but before SimplifyCFG because it can allow
1919 InductiveRangeCheckElimination.cpp
2020 IndVarSimplify.cpp
2121 InferAddressSpaces.cpp
22 InstSimplifyPass.cpp
2223 JumpThreading.cpp
2324 LICM.cpp
2425 LoopAccessAnalysisPrinter.cpp
0 //===- InstSimplifyPass.cpp -----------------------------------------------===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/Transforms/Scalar/InstSimplifyPass.h"
10 #include "llvm/ADT/DepthFirstIterator.h"
11 #include "llvm/ADT/SmallPtrSet.h"
12 #include "llvm/ADT/Statistic.h"
13 #include "llvm/Analysis/AssumptionCache.h"
14 #include "llvm/Analysis/InstructionSimplify.h"
15 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
16 #include "llvm/Analysis/TargetLibraryInfo.h"
17 #include "llvm/IR/DataLayout.h"
18 #include "llvm/IR/Dominators.h"
19 #include "llvm/IR/Function.h"
20 #include "llvm/IR/Type.h"
21 #include "llvm/Pass.h"
22 #include "llvm/Transforms/Utils.h"
23 #include "llvm/Transforms/Utils/Local.h"
24 using namespace llvm;
25
26 #define DEBUG_TYPE "instsimplify"
27
28 STATISTIC(NumSimplified, "Number of redundant instructions removed");
29
30 static bool runImpl(Function &F, const SimplifyQuery &SQ,
31 OptimizationRemarkEmitter *ORE) {
32 SmallPtrSet S1, S2, *ToSimplify = &S1, *Next = &S2;
33 bool Changed = false;
34
35 do {
36 for (BasicBlock *BB : depth_first(&F.getEntryBlock())) {
37 // Here be subtlety: the iterator must be incremented before the loop
38 // body (not sure why), so a range-for loop won't work here.
39 for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
40 Instruction *I = &*BI++;
41 // The first time through the loop ToSimplify is empty and we try to
42 // simplify all instructions. On later iterations ToSimplify is not
43 // empty and we only bother simplifying instructions that are in it.
44 if (!ToSimplify->empty() && !ToSimplify->count(I))
45 continue;
46
47 // Don't waste time simplifying unused instructions.
48 if (!I->use_empty()) {
49 if (Value *V = SimplifyInstruction(I, SQ, ORE)) {
50 // Mark all uses for resimplification next time round the loop.
51 for (User *U : I->users())
52 Next->insert(cast(U));
53 I->replaceAllUsesWith(V);
54 ++NumSimplified;
55 Changed = true;
56 }
57 }
58 if (RecursivelyDeleteTriviallyDeadInstructions(I, SQ.TLI)) {
59 // RecursivelyDeleteTriviallyDeadInstruction can remove more than one
60 // instruction, so simply incrementing the iterator does not work.
61 // When instructions get deleted re-iterate instead.
62 BI = BB->begin();
63 BE = BB->end();
64 Changed = true;
65 }
66 }
67 }
68
69 // Place the list of instructions to simplify on the next loop iteration
70 // into ToSimplify.
71 std::swap(ToSimplify, Next);
72 Next->clear();
73 } while (!ToSimplify->empty());
74
75 return Changed;
76 }
77
78 namespace {
79 struct InstSimplifyLegacyPass : public FunctionPass {
80 static char ID; // Pass identification, replacement for typeid
81 InstSimplifyLegacyPass() : FunctionPass(ID) {
82 initializeInstSimplifyLegacyPassPass(*PassRegistry::getPassRegistry());
83 }
84
85 void getAnalysisUsage(AnalysisUsage &AU) const override {
86 AU.setPreservesCFG();
87 AU.addRequired();
88 AU.addRequired();
89 AU.addRequired();
90 AU.addRequired();
91 }
92
93 /// runOnFunction - Remove instructions that simplify.
94 bool runOnFunction(Function &F) override {
95 if (skipFunction(F))
96 return false;
97
98 const DominatorTree *DT =
99 &getAnalysis().getDomTree();
100 const TargetLibraryInfo *TLI =
101 &getAnalysis().getTLI();
102 AssumptionCache *AC =
103 &getAnalysis().getAssumptionCache(F);
104 OptimizationRemarkEmitter *ORE =
105 &getAnalysis().getORE();
106 const DataLayout &DL = F.getParent()->getDataLayout();
107 const SimplifyQuery SQ(DL, TLI, DT, AC);
108 return runImpl(F, SQ, ORE);
109 }
110 };
111 } // namespace
112
113 char InstSimplifyLegacyPass::ID = 0;
114 INITIALIZE_PASS_BEGIN(InstSimplifyLegacyPass, "instsimplify",
115 "Remove redundant instructions", false, false)
116 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
117 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
118 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
119 INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass)
120 INITIALIZE_PASS_END(InstSimplifyLegacyPass, "instsimplify",
121 "Remove redundant instructions", false, false)
122
123 // Public interface to the simplify instructions pass.
124 FunctionPass *llvm::createInstSimplifyLegacyPass() {
125 return new InstSimplifyLegacyPass();
126 }
127
128 PreservedAnalyses InstSimplifyPass::run(Function &F,
129 FunctionAnalysisManager &AM) {
130 auto &DT = AM.getResult(F);
131 auto &TLI = AM.getResult(F);
132 auto &AC = AM.getResult(F);
133 auto &ORE = AM.getResult(F);
134 const DataLayout &DL = F.getParent()->getDataLayout();
135 const SimplifyQuery SQ(DL, &TLI, &DT, &AC);
136 bool Changed = runImpl(F, SQ, &ORE);
137 if (!Changed)
138 return PreservedAnalyses::all();
139
140 PreservedAnalyses PA;
141 PA.preserveSet();
142 return PA;
143 }
5555 initializeIRCELegacyPassPass(Registry);
5656 initializeIndVarSimplifyLegacyPassPass(Registry);
5757 initializeInferAddressSpacesPass(Registry);
58 initializeInstSimplifyLegacyPassPass(Registry);
5859 initializeJumpThreadingPass(Registry);
5960 initializeLegacyLICMPassPass(Registry);
6061 initializeLegacyLoopSinkPassPass(Registry);
4747 SanitizerStats.cpp
4848 SimplifyCFG.cpp
4949 SimplifyIndVar.cpp
50 SimplifyInstructions.cpp
5150 SimplifyLibCalls.cpp
5251 SplitModule.cpp
5352 StripNonLineTableDebugInfo.cpp
+0
-152
lib/Transforms/Utils/SimplifyInstructions.cpp less more
None //===------ SimplifyInstructions.cpp - Remove redundant instructions ------===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This is a utility pass used for testing the InstructionSimplify analysis.
10 // The analysis is applied to every instruction, and if it simplifies then the
11 // instruction is replaced by the simplification. If you are looking for a pass
12 // that performs serious instruction folding, use the instcombine pass instead.
13 //
14 //===----------------------------------------------------------------------===//
15
16 #include "llvm/Transforms/Utils/SimplifyInstructions.h"
17 #include "llvm/ADT/DepthFirstIterator.h"
18 #include "llvm/ADT/SmallPtrSet.h"
19 #include "llvm/ADT/Statistic.h"
20 #include "llvm/Analysis/AssumptionCache.h"
21 #include "llvm/Analysis/InstructionSimplify.h"
22 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
23 #include "llvm/Analysis/TargetLibraryInfo.h"
24 #include "llvm/Transforms/Utils/Local.h"
25 #include "llvm/IR/DataLayout.h"
26 #include "llvm/IR/Dominators.h"
27 #include "llvm/IR/Function.h"
28 #include "llvm/IR/Type.h"
29 #include "llvm/Pass.h"
30 #include "llvm/Transforms/Utils.h"
31 using namespace llvm;
32
33 #define DEBUG_TYPE "instsimplify"
34
35 STATISTIC(NumSimplified, "Number of redundant instructions removed");
36
37 static bool runImpl(Function &F, const SimplifyQuery &SQ,
38 OptimizationRemarkEmitter *ORE) {
39 SmallPtrSet S1, S2, *ToSimplify = &S1, *Next = &S2;
40 bool Changed = false;
41
42 do {
43 for (BasicBlock *BB : depth_first(&F.getEntryBlock())) {
44 // Here be subtlety: the iterator must be incremented before the loop
45 // body (not sure why), so a range-for loop won't work here.
46 for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
47 Instruction *I = &*BI++;
48 // The first time through the loop ToSimplify is empty and we try to
49 // simplify all instructions. On later iterations ToSimplify is not
50 // empty and we only bother simplifying instructions that are in it.
51 if (!ToSimplify->empty() && !ToSimplify->count(I))
52 continue;
53
54 // Don't waste time simplifying unused instructions.
55 if (!I->use_empty()) {
56 if (Value *V = SimplifyInstruction(I, SQ, ORE)) {
57 // Mark all uses for resimplification next time round the loop.
58 for (User *U : I->users())
59 Next->insert(cast(U));
60 I->replaceAllUsesWith(V);
61 ++NumSimplified;
62 Changed = true;
63 }
64 }
65 if (RecursivelyDeleteTriviallyDeadInstructions(I, SQ.TLI)) {
66 // RecursivelyDeleteTriviallyDeadInstruction can remove more than one
67 // instruction, so simply incrementing the iterator does not work.
68 // When instructions get deleted re-iterate instead.
69 BI = BB->begin();
70 BE = BB->end();
71 Changed = true;
72 }
73 }
74 }
75
76 // Place the list of instructions to simplify on the next loop iteration
77 // into ToSimplify.
78 std::swap(ToSimplify, Next);
79 Next->clear();
80 } while (!ToSimplify->empty());
81
82 return Changed;
83 }
84
85 namespace {
86 struct InstSimplifier : public FunctionPass {
87 static char ID; // Pass identification, replacement for typeid
88 InstSimplifier() : FunctionPass(ID) {
89 initializeInstSimplifierPass(*PassRegistry::getPassRegistry());
90 }
91
92 void getAnalysisUsage(AnalysisUsage &AU) const override {
93 AU.setPreservesCFG();
94 AU.addRequired();
95 AU.addRequired();
96 AU.addRequired();
97 AU.addRequired();
98 }
99
100 /// runOnFunction - Remove instructions that simplify.
101 bool runOnFunction(Function &F) override {
102 if (skipFunction(F))
103 return false;
104
105 const DominatorTree *DT =
106 &getAnalysis().getDomTree();
107 const TargetLibraryInfo *TLI =
108 &getAnalysis().getTLI();
109 AssumptionCache *AC =
110 &getAnalysis().getAssumptionCache(F);
111 OptimizationRemarkEmitter *ORE =
112 &getAnalysis().getORE();
113 const DataLayout &DL = F.getParent()->getDataLayout();
114 const SimplifyQuery SQ(DL, TLI, DT, AC);
115 return runImpl(F, SQ, ORE);
116 }
117 };
118 }
119
120 char InstSimplifier::ID = 0;
121 INITIALIZE_PASS_BEGIN(InstSimplifier, "instsimplify",
122 "Remove redundant instructions", false, false)
123 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
124 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
125 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
126 INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass)
127 INITIALIZE_PASS_END(InstSimplifier, "instsimplify",
128 "Remove redundant instructions", false, false)
129 char &llvm::InstructionSimplifierID = InstSimplifier::ID;
130
131 // Public interface to the simplify instructions pass.
132 FunctionPass *llvm::createInstructionSimplifierPass() {
133 return new InstSimplifier();
134 }
135
136 PreservedAnalyses InstSimplifierPass::run(Function &F,
137 FunctionAnalysisManager &AM) {
138 auto &DT = AM.getResult(F);
139 auto &TLI = AM.getResult(F);
140 auto &AC = AM.getResult(F);
141 auto &ORE = AM.getResult(F);
142 const DataLayout &DL = F.getParent()->getDataLayout();
143 const SimplifyQuery SQ(DL, &TLI, &DT, &AC);
144 bool Changed = runImpl(F, SQ, &ORE);
145 if (!Changed)
146 return PreservedAnalyses::all();
147
148 PreservedAnalyses PA;
149 PA.preserveSet();
150 return PA;
151 }
3535 initializePromoteLegacyPassPass(Registry);
3636 initializeStripNonLineTableDebugInfoPass(Registry);
3737 initializeUnifyFunctionExitNodesPass(Registry);
38 initializeInstSimplifierPass(Registry);
3938 initializeMetaRenamerPass(Registry);
4039 initializeStripGCRelocatesPass(Registry);
4140 initializePredicateInfoPrinterLegacyPassPass(Registry);
240240 ; CHECK-O-NEXT: Finished llvm::Function pass manager run.
241241 ; CHECK-O-NEXT: Running pass: AlignmentFromAssumptionsPass
242242 ; CHECK-O-NEXT: Running pass: LoopSinkPass
243 ; CHECK-O-NEXT: Running pass: InstSimplifierPass
243 ; CHECK-O-NEXT: Running pass: InstSimplifyPass
244244 ; CHECK-O-NEXT: Running pass: DivRemPairsPass
245245 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
246246 ; CHECK-O-NEXT: Running pass: SpeculateAroundPHIsPass
218218 ; CHECK-POSTLINK-O-NEXT: Finished llvm::Function pass manager run
219219 ; CHECK-POSTLINK-O-NEXT: Running pass: AlignmentFromAssumptionsPass
220220 ; CHECK-POSTLINK-O-NEXT: Running pass: LoopSinkPass
221 ; CHECK-POSTLINK-O-NEXT: Running pass: InstSimplifierPass
221 ; CHECK-POSTLINK-O-NEXT: Running pass: InstSimplifyPass
222222 ; CHECK-POSTLINK-O-NEXT: Running pass: DivRemPairsPass
223223 ; CHECK-POSTLINK-O-NEXT: Running pass: SimplifyCFGPass
224224 ; CHECK-POSTLINK-O-NEXT: Running pass: SpeculateAroundPHIsPass