[llvm] Optimize fptrunc(x)>=C1 --> x>=C2 (PR #99475)

[Matt Arsenault via llvm-commits]

================
@@ -7882,6 +7892,93 @@ static Instruction *foldFCmpReciprocalAndZero(FCmpInst &I, Instruction *LHSI,
   return new FCmpInst(Pred, LHSI->getOperand(1), RHSC, "", &I);
 }
 
+// Fold fptrunc(x) < constant --> x < constant if possible.
+static Instruction *foldFCmpFpTrunc(FCmpInst &I, Instruction *LHSI,
+                                    Constant *RHSC) {
+  FCmpInst::Predicate Pred = I.getPredicate();
+  bool RoundDown = false;
+
+  if (Pred == FCmpInst::FCMP_OGE || Pred == FCmpInst::FCMP_UGE ||
+      Pred == FCmpInst::FCMP_OLT || Pred == FCmpInst::FCMP_ULT)
+    RoundDown = true;
+  else if (Pred == FCmpInst::FCMP_OGT || Pred == FCmpInst::FCMP_UGT ||
+           Pred == FCmpInst::FCMP_OLE || Pred == FCmpInst::FCMP_ULE)
+    RoundDown = false;
+  else
+    return nullptr;
+
+  const APFloat *RValue;
+  if (!match(RHSC, m_APFloat(RValue)))
+    return nullptr;
+
+  // RHSC should not be nan or infinity.
+  if (RValue->isNaN() || RValue->isInfinity())
+    return nullptr;
+
+  Type *LType = LHSI->getOperand(0)->getType();
+  Type *RType = RHSC->getType();
+  Type *LEleType = LType->getScalarType();
+  Type *REleType = RType->getScalarType();
+
+  APFloat NextRValue = *RValue;
+  NextRValue.next(RoundDown);
+
+  // Round RValue to suitable value
+  APFloat ExtRValue = *RValue;
+  APFloat ExtNextRValue = NextRValue;
+  bool lossInfo;
+  ExtRValue.convert(LEleType->getFltSemantics(), APFloat::rmNearestTiesToEven,
+                    &lossInfo);
+  ExtNextRValue.convert(LEleType->getFltSemantics(),
+                        APFloat::rmNearestTiesToEven, &lossInfo);
+
+  // Binary search to find the maximal (or minimal) value after RValue promotion.
+  // RValue can't have special comparison rules, which means nan or inf is not
+  // allowed here.
+  APFloat RoundValue{LEleType->getFltSemantics()};
+  {
+    APFloat Two{LEleType->getFltSemantics(), 2};
+
+    // The (negative) maximum of RValue will become infinity when rounded up (down).
+    // Set the limit of ExtNextRValue.
+    if (NextRValue.isInfinity()) {
+      ExtNextRValue = ExtRValue * Two;
+    }
----------------
arsenm wrote:

No braces. Can also defer construction of the 2 constant (or avoid it by using scalbn instead) 

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