[NewPM] Run the Speculative Execution Pass only if the target has divergent branches

[leonardchan]

Summary

The SpeculativeExecutionPass was running under the new PM for non-GPU targets. It appears that the pass would run regardless as long as speed optimizations were available. Run the Speculative Execution Pass only if the target has divergent branches.

[arsenm]

Commit message should say only if?

[leonardchan]

In D76389#1951135, @arsenm wrote:

Commit message should say only if?

Updated

[arsenm]

clang/test/CodeGen/thinlto-distributed-newpm.ll

110

The pass name shouldn't change here?

llvm/lib/Passes/PassBuilder.cpp

435

I don't expect this to be a separate pass, just added based on a divergent target

[leonardchan]

llvm/lib/Passes/PassBuilder.cpp

435

Updated such that the current pass is used, although it's a bit more difficult to test since the same pass name will appear when dumping the passes.

[arsenm]

llvm/include/llvm/Transforms/Scalar/SpeculativeExecution.h

97

Still define a second pass

llvm/lib/Passes/PassBuilder.cpp

435

There's a check for divergent branches in the builder so you don't need to run the pass at all

[arsenm]

This seems like it covers a different case than D82735?

[leonardchan]

In D76389#2120868, @arsenm wrote:

This seems like it covers a different case than D82735?

I haven't rebased in a while, but D82735 covers this. Abandoning since this is addressed in that patch.

clang/test/CodeGen/thinlto-distributed-newpm.ll

 ; CHECK-O: Running analysis: TargetLibraryAnalysis on main
 ; CHECK-O2: Running analysis: TargetIRAnalysis on main
 ; CHECK-O: Running analysis: MemorySSAAnalysis on main
 ; CHECK-O: Running analysis: AAManager on main
 ; CHECK-O: Running analysis: BasicAA on main
 ; CHECK-O: Running analysis: ScopedNoAliasAA on main
 ; CHECK-O: Running analysis: TypeBasedAA on main
 ; CHECK-O: Running analysis: OuterAnalysisManagerProxy
-; CHECK-O: Running pass: SpeculativeExecutionPass on main
+; CHECK-O: Running pass: SpeculativeExecutionIfHasBranchDivergencePass on main
 ; CHECK-O: Running pass: JumpThreadingPass on main
 ; CHECK-O: Running analysis: LazyValueAnalysis on main
 ; CHECK-O: Running pass: CorrelatedValuePropagationPass on main
 ; CHECK-O: Running pass: SimplifyCFGPass on main
 ; CHECK-O3: Running pass: AggressiveInstCombinePass on main
 ; CHECK-O: Running pass: InstCombinePass on main
 ; CHECK-O: Running analysis: OptimizationRemarkEmitterAnalysis on main
 ; CHECK-O: Running pass: LibCallsShrinkWrapPass on main

llvm/include/llvm/Transforms/Scalar/SpeculativeExecution.h

 //===----------------------------------------------------------------------===//
 #ifndef LLVM_TRANSFORMS_SCALAR_SPECULATIVEEXECUTION_H
 #define LLVM_TRANSFORMS_SCALAR_SPECULATIVEEXECUTION_H
 
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
-class SpeculativeExecutionPass
-    : public PassInfoMixin<SpeculativeExecutionPass> {
+class SpeculativeExecutionPassImpl {
 public:
-  SpeculativeExecutionPass(bool OnlyIfDivergentTarget = false);
+  SpeculativeExecutionPassImpl(bool OnlyIfDivergentTarget = false);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   // Glue for old PM
   bool runImpl(Function &F, TargetTransformInfo *TTI);
 
 private:
   bool runOnBasicBlock(BasicBlock &B);
   bool considerHoistingFromTo(BasicBlock &FromBlock, BasicBlock &ToBlock);
 
   // If true, this pass is a nop unless the target architecture has branch
   // divergence.
   const bool OnlyIfDivergentTarget = false;
 
   TargetTransformInfo *TTI = nullptr;
 };
+
+class SpeculativeExecutionPass
+    : public SpeculativeExecutionPassImpl,
+      public PassInfoMixin<SpeculativeExecutionPass> {
+public:
+  SpeculativeExecutionPass(bool OnlyIfDivergentTarget = false)
+      : SpeculativeExecutionPassImpl(OnlyIfDivergentTarget) {}
+};
+
+class SpeculativeExecutionIfHasBranchDivergencePass
+    : public SpeculativeExecutionPassImpl,
+      public PassInfoMixin<SpeculativeExecutionIfHasBranchDivergencePass> {
+public:
+  SpeculativeExecutionIfHasBranchDivergencePass()
+      : SpeculativeExecutionPassImpl(/*OnlyIfDivergentTarget=*/true) {}
+};
 }
 
 #endif //LLVM_TRANSFORMS_SCALAR_SPECULATIVEEXECUTION_H

llvm/lib/Passes/PassBuilder.cpp

if (Level.getSpeedupLevel() > 1) {
     if (EnableGVNSink) {
       FPM.addPass(GVNSinkPass());
       FPM.addPass(SimplifyCFGPass());
     }
   }
 
   // Speculative execution if the target has divergent branches; otherwise nop.
   if (Level.getSpeedupLevel() > 1) {
-    FPM.addPass(SpeculativeExecutionPass());
+    FPM.addPass(SpeculativeExecutionIfHasBranchDivergencePass());
 
     // Optimize based on known information about branches, and cleanup afterward.
     FPM.addPass(JumpThreadingPass());
     FPM.addPass(CorrelatedValuePropagationPass());
   }
   FPM.addPass(SimplifyCFGPass());
   if (Level == OptimizationLevel::O3)
     FPM.addPass(AggressiveInstCombinePass());

llvm/lib/Transforms/Scalar/SpeculativeExecution.cpp

if (OnlyIfDivergentTarget)
              "branches";
     return "Speculatively execute instructions";
   }
 
 private:
   // Variable preserved purely for correct name printing.
   const bool OnlyIfDivergentTarget;
 
-  SpeculativeExecutionPass Impl;
+  SpeculativeExecutionPassImpl Impl;
 };
 } // namespace
 
 char SpeculativeExecutionLegacyPass::ID = 0;
 INITIALIZE_PASS_BEGIN(SpeculativeExecutionLegacyPass, "speculative-execution",
                       "Speculatively execute instructions", false, false)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_END(SpeculativeExecutionLegacyPass, "speculative-execution",
if (skipFunction(F))
     return false;
 
   auto *TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
   return Impl.runImpl(F, TTI);
 }
 
 namespace llvm {
 
-bool SpeculativeExecutionPass::runImpl(Function &F, TargetTransformInfo *TTI) {
+bool SpeculativeExecutionPassImpl::runImpl(Function &F,
+                                           TargetTransformInfo *TTI) {
   if (OnlyIfDivergentTarget && !TTI->hasBranchDivergence()) {
     LLVM_DEBUG(dbgs() << "Not running SpeculativeExecution because "
                          "TTI->hasBranchDivergence() is false.\n");
     return false;
   }
 
   this->TTI = TTI;
   bool Changed = false;
   for (auto& B : F) {
     Changed |= runOnBasicBlock(B);
   }
   return Changed;
 }
 
-bool SpeculativeExecutionPass::runOnBasicBlock(BasicBlock &B) {
+bool SpeculativeExecutionPassImpl::runOnBasicBlock(BasicBlock &B) {
   BranchInst *BI = dyn_cast<BranchInst>(B.getTerminator());
   if (BI == nullptr)
     return false;
 
   if (BI->getNumSuccessors() != 2)
     return false;
   BasicBlock &Succ0 = *BI->getSuccessor(0);
   BasicBlock &Succ1 = *BI->getSuccessor(1);
switch (Operator::getOpcode(I)) {
     case Instruction::FCmp:
       return TTI.getUserCost(I);
 
     default:
       return UINT_MAX; // Disallow anything not whitelisted.
   }
 }
 
-bool SpeculativeExecutionPass::considerHoistingFromTo(
-    BasicBlock &FromBlock, BasicBlock &ToBlock) {
+bool SpeculativeExecutionPassImpl::considerHoistingFromTo(BasicBlock &FromBlock,
+                                                          BasicBlock &ToBlock) {
   SmallPtrSet<const Instruction *, 8> NotHoisted;
   const auto AllPrecedingUsesFromBlockHoisted = [&NotHoisted](User *U) {
     for (Value* V : U->operand_values()) {
       if (Instruction *I = dyn_cast<Instruction>(V)) {
         if (NotHoisted.count(I) > 0)
           return false;
       }
     }

 FunctionPass *createSpeculativeExecutionPass() {
   return new SpeculativeExecutionLegacyPass();
 }
 
 FunctionPass *createSpeculativeExecutionIfHasBranchDivergencePass() {
   return new SpeculativeExecutionLegacyPass(/* OnlyIfDivergentTarget = */ true);
 }
 
-SpeculativeExecutionPass::SpeculativeExecutionPass(bool OnlyIfDivergentTarget)
+SpeculativeExecutionPassImpl::SpeculativeExecutionPassImpl(
+    bool OnlyIfDivergentTarget)
     : OnlyIfDivergentTarget(OnlyIfDivergentTarget ||
                             SpecExecOnlyIfDivergentTarget) {}
 
-PreservedAnalyses SpeculativeExecutionPass::run(Function &F,
-                                                FunctionAnalysisManager &AM) {
+PreservedAnalyses
+SpeculativeExecutionPassImpl::run(Function &F, FunctionAnalysisManager &AM) {
   auto *TTI = &AM.getResult<TargetIRAnalysis>(F);
 
   bool Changed = runImpl(F, TTI);
 
   if (!Changed)
     return PreservedAnalyses::all();
   PreservedAnalyses PA;
   PA.preserve<GlobalsAA>();
   PA.preserveSet<CFGAnalyses>();
   return PA;
 }
 }  // namespace llvm

llvm/test/Other/new-pm-defaults.ll

 ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass
 ; CHECK-O2-NEXT: Running pass: OpenMPOptPass on (foo)
 ; CHECK-O3-NEXT: Running pass: OpenMPOptPass on (foo)
 ; CHECK-O-NEXT: Running pass: CGSCCToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
 ; CHECK-O-NEXT: Starting llvm::Function pass manager run.
 ; CHECK-O-NEXT: Running pass: SROA
 ; CHECK-O-NEXT: Running pass: EarlyCSEPass
 ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis
-; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
+; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionIfHasBranchDivergencePass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O3-NEXT: AggressiveInstCombinePass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O1-NEXT: Running pass: LibCallsShrinkWrapPass
 ; CHECK-O2-NEXT: Running pass: LibCallsShrinkWrapPass

llvm/test/Other/new-pm-thinlto-defaults.ll

 ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass
 ; CHECK-O2-NEXT: Running pass: OpenMPOptPass on (foo)
 ; CHECK-O3-NEXT: Running pass: OpenMPOptPass on (foo)
 ; CHECK-O-NEXT: Running pass: CGSCCToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
 ; CHECK-O-NEXT: Starting llvm::Function pass manager run.
 ; CHECK-O-NEXT: Running pass: SROA
 ; CHECK-O-NEXT: Running pass: EarlyCSEPass
 ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis
-; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
+; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionIfHasBranchDivergencePass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O3-NEXT: Running pass: AggressiveInstCombinePass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O1-NEXT: Running pass: LibCallsShrinkWrapPass
 ; CHECK-O2-NEXT: Running pass: LibCallsShrinkWrapPass

llvm/test/Other/new-pm-thinlto-postlink-pgo-defaults.ll

 ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass
 ; CHECK-O2-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O3-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O-NEXT: Running pass: CGSCCToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
 ; CHECK-O-NEXT: Starting {{.*}}Function pass manager run.
 ; CHECK-O-NEXT: Running pass: SROA
 ; CHECK-O-NEXT: Running pass: EarlyCSEPass
 ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis
-; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
+; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionIfHasBranchDivergencePass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O3-NEXT: Running pass: AggressiveInstCombinePass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O1-NEXT: Running pass: LibCallsShrinkWrapPass
 ; CHECK-O2-NEXT: Running pass: LibCallsShrinkWrapPass

llvm/test/Other/new-pm-thinlto-postlink-samplepgo-defaults.ll

 ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass
 ; CHECK-O2-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O3-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O-NEXT: Running pass: CGSCCToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
 ; CHECK-O-NEXT: Starting {{.*}}Function pass manager run.
 ; CHECK-O-NEXT: Running pass: SROA
 ; CHECK-O-NEXT: Running pass: EarlyCSEPass
 ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis
-; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
+; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionIfHasBranchDivergencePass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O3-NEXT: Running pass: AggressiveInstCombinePass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O1-NEXT: Running pass: LibCallsShrinkWrapPass
 ; CHECK-O2-NEXT: Running pass: LibCallsShrinkWrapPass

llvm/test/Other/new-pm-thinlto-prelink-pgo-defaults.ll

 ; CHECK-O-DAG: Running analysis: DominatorTreeAnalysis on foo
 ; CHECK-O-DAG: Running analysis: AssumptionAnalysis on foo
 ; CHECK-O-NEXT: Running pass: EarlyCSEPass
 ; CHECK-O1-NEXT: Running analysis: TargetIRAnalysis on foo
 ; CHECK-O2-NEXT: Running analysis: TargetIRAnalysis on foo
 ; CHECK-Os-NEXT: Running analysis: TargetIRAnalysis on foo
 ; CHECK-Oz-NEXT: Running analysis: TargetIRAnalysis on foo
 ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis
-; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
+; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionIfHasBranchDivergencePass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O3-NEXT: Running pass: AggressiveInstCombinePass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: BlockFrequencyAnalysis on foo

llvm/test/Other/new-pm-thinlto-prelink-samplepgo-defaults.ll

 ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass
 ; CHECK-O2-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O3-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O-NEXT: Running pass: CGSCCToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
 ; CHECK-O-NEXT: Starting {{.*}}Function pass manager run.
 ; CHECK-O-NEXT: Running pass: SROA
 ; CHECK-O-NEXT: Running pass: EarlyCSEPass
 ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis
-; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
+; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionIfHasBranchDivergencePass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O3-NEXT: Running pass: AggressiveInstCombinePass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O1-NEXT: Running pass: LibCallsShrinkWrapPass
 ; CHECK-O2-NEXT: Running pass: LibCallsShrinkWrapPass