[llvm] [llubi] Initial support for floating-point numbers (PR #188453)

[Yingwei Zheng via llvm-commits]

================
@@ -81,6 +83,165 @@ class InstExecutor : public InstVisitor<InstExecutor, void>,
     CurrentFrame->ValueMap.insert_or_assign(&I, std::move(V));
   }
 
+  APFloat handleDenormal(APFloat Val, DenormalMode::DenormalModeKind Mode,
+                         bool NonDet = false) {
+    if (!Val.isDenormal())
+      return Val;
+    if (NonDet) {
+      // Non-deterministically choose between flushing or preserving the
+      // denormal value.
+      if (Ctx.getRandomBool())
+        return Val;
+    }
+    if (Mode == DenormalMode::PositiveZero)
+      return APFloat::getZero(Val.getSemantics(), false);
+    if (Mode == DenormalMode::PreserveSign)
+      return APFloat::getZero(Val.getSemantics(), Val.isNegative());
+    // Default case for IEEE, Dynamic, and Invalid
+    // Currently we treat Dynamic the same as IEEE, since we don't support
+    // changing the mode at this point.
+    return Val;
+  }
+
+  AnyValue handleFMFFlags(AnyValue Val, FastMathFlags FMF) {
+    if (Val.isPoison())
+      return AnyValue::poison();
+
+    if (Val.isAggregate()) {
+      std::vector<AnyValue> ResVec;
+      ResVec.reserve(Val.asAggregate().size());
+      for (const auto &A : Val.asAggregate())
+        ResVec.push_back(handleFMFFlags(A, FMF));
+      return AnyValue(ResVec);
+    }
+
+    const APFloat &APVal = Val.asFloat();
+    if (FMF.noNaNs() && APVal.isNaN())
+      return AnyValue::poison();
+    if (FMF.noInfs() && APVal.isInfinity())
+      return AnyValue::poison();
+    if (FMF.noSignedZeros() && APVal.isZero())
+      return AnyValue(APFloat::getZero(
+          APVal.getSemantics(), APVal.isNegative() ^ Ctx.getRandomBool()));
+    return Val;
+  }
+
+  enum class NaNPayloadCastMode {
+    None,
+    FPExt,
+    FPTrunc,
+  };
+
+  static unsigned getNaNPayloadBitWidth(const fltSemantics &Sem) {
+    unsigned Precision = APFloat::semanticsPrecision(Sem);
+    return Precision > 2 ? Precision - 2 : 0;
+  }
+
+  NaNPropagationBehavior resolveNaNPropagationBehavior() {
+    NaNPropagationBehavior Choice = Ctx.getNaNPropagationBehavior();
+    if (Choice == NaNPropagationBehavior::NonDeterministic) {
+      uint64_t NonDetChoice = Ctx.getRandomUInt64() % 4 + 1;
+      Choice = static_cast<NaNPropagationBehavior>(NonDetChoice);
+    }
+    return Choice;
+  }
+
+  const APFloat &pickNaNSource(ArrayRef<const APFloat *> Inputs,
+                               const APFloat &Fallback) {
+    for (const APFloat *Input : Inputs) {
+      if (Input && Input->isNaN())
+        return *Input;
+    }
+    return Fallback;
+  }
+
+  APInt getNaNPayload(const APFloat &NaNVal) {
+    unsigned PayloadBits = getNaNPayloadBitWidth(NaNVal.getSemantics());
+    if (!PayloadBits)
+      return APInt(1, 0);
+    return NaNVal.bitcastToAPInt().extractBits(PayloadBits, 0);
+  }
+
+  APInt castNaNPayload(const APInt &SrcPayload, unsigned SrcPayloadBits,
+                       unsigned DstPayloadBits, NaNPayloadCastMode CastMode) {
+    if (!DstPayloadBits)
+      return APInt(1, 0);
+
+    APInt CanonicalSrc = SrcPayload.zextOrTrunc(SrcPayloadBits);
+    if (CastMode == NaNPayloadCastMode::FPExt &&
----------------
dtcxzyw wrote:

Any findings?

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