[llvm] [SimplifyCFG] Treat umul + extract pattern as cheap single instruction. (PR #124933)

[Antonio Frighetto via llvm-commits]

=?utf-8?q?Gábor?= Spaits <gaborspaits1 at gmail.com>,
=?utf-8?q?Gábor?= Spaits <gaborspaits1 at gmail.com>,
=?utf-8?q?Gábor?= Spaits <gaborspaits1 at gmail.com>,
=?utf-8?q?Gábor?= Spaits <gaborspaits1 at gmail.com>,Gabor Spaits
 <gaborspaits1 at gmail.com>
Message-ID:
In-Reply-To: <llvm.org/llvm/llvm-project/pull/124933 at github.com>


================
@@ -3316,34 +3333,45 @@ bool SimplifyCFGOpt::speculativelyExecuteBB(BranchInst *BI,
     if (EphTracker.track(&I))
       continue;
 
-    // Only speculatively execute a single instruction (not counting the
-    // terminator) for now.
     bool IsSafeCheapLoadStore = HoistLoadsStores &&
                                 isSafeCheapLoadStore(&I, TTI) &&
                                 SpeculatedConditionalLoadsStores.size() <
                                     HoistLoadsStoresWithCondFaultingThreshold;
+
+    // Overflow arithmetic instruction plus extract value are usually generated
+    // when a division is being replaced, but the zero check may still be there.
+    // In that case hoist these two instructions out of this basic block, and
+    // let later optimizations take care of the unnecessary zero checks.
+    WithOverflowInst *OverflowI;
+    if (match(&I, m_ExtractValue<1>(m_OneUse(m_WithOverflowInst(OverflowI))))) {
+      MaxSpeculatedInstructionsToHoist = 2;
+      PartialInst = true;
+    }
     // Not count load/store into cost if target supports conditional faulting
     // b/c it's cheap to speculate it.
     if (IsSafeCheapLoadStore)
       SpeculatedConditionalLoadsStores.push_back(&I);
     else
       ++SpeculatedInstructions;
 
-    if (SpeculatedInstructions > 1)
-      return false;
-
     // Don't hoist the instruction if it's unsafe or expensive.
     if (!IsSafeCheapLoadStore &&
         !isSafeToSpeculativelyExecute(&I, BI, Options.AC) &&
         !(HoistCondStores && !SpeculatedStoreValue &&
           (SpeculatedStoreValue =
                isSafeToSpeculateStore(&I, BB, ThenBB, EndBB))))
       return false;
-    if (!IsSafeCheapLoadStore && !SpeculatedStoreValue &&
+
+    if (!PartialInst && !IsSafeCheapLoadStore && !SpeculatedStoreValue &&
         computeSpeculationCost(&I, TTI) >
             PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic)
       return false;
 
+    // The number of instructions to be speculatively executed is limited.
+    // This limit is dependent on the found patterns.
+    if (SpeculatedInstructions > MaxSpeculatedInstructionsToHoist)
+      return false;
----------------
antoniofrighetto wrote:

It may feel like we'd need more of a cl::opt here, if we were to maintain a threshold of this kind. I wonder if dropping MaxSpeculatedInstructionsToHoist and have this doesn't look too contrived for now:
```cpp
if (SpeculatedInstructions > (PartialInst ? 2 : 1))
  return false;
```

https://github.com/llvm/llvm-project/pull/124933