[ConstantFolding] Fold constrained arithmetic intrinsics

[sepavloff]

Summary

Constfold constrained variants of operations fadd, fsub, fmul, fdiv,
frem, fma and fmuladd.

The change also sets up some means to support for removal of unused
constrained intrinsics. They are declared as accessing memory to model
interaction with floating point environment, so they were not removed,
as they have side effect. Now constrained intrinsics that have
"fpexcept.ignore" as exception behavior are removed if they have no uses.
As for intrinsics that have exception behavior other than "fpexcept.ignore",
they can be removed if it is known that they do not raise floating point
exceptions. It happens when doing constant folding, attributes of such
intrinsic are changed so that the intrinsic is not claimed as accessing
memory.

[sepavloff]

Rebased

[kpn]

llvm/lib/Transforms/Utils/Local.cpp

497

What about "maytrap"? The language reference explicitly calls out constant folding as allowed under "maytrap" since it doesn't introduce any new exceptions.

llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll

240 ↗

(On Diff #347343)

I hate to lose the testing we're currently doing with this file. Can you split out from this file the tests that these changes hit, and then change this existing test to take arguments instead of constants? That way we preserve testing the SDAG but also test that your constant folding works correctly.

[nemanjai]

llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll

240 ↗

(On Diff #347343)

I agree. I'm not sure why this test case was written to only test this with constants, but it now becomes clear that it is an unfortunate choice.

[sepavloff]

Changes to the test llvm/test/CodeGen/PowerPC/vector-constrained-fp-intrinsics.ll are presented in D103259.

[sepavloff]

Allow folding for 'maytrap'. Rebased

[sepavloff]

llvm/lib/Transforms/Utils/Local.cpp

497

I think you are right. According to the documentation, constant folding is possible in this case.

[foad]

llvm/lib/Analysis/ConstantFolding.cpp

2456

You don't need the "if", just do it unconditionally?

[spatel]

llvm/lib/Analysis/ConstantFolding.cpp

2415

From the tests, I'm assuming that this diff is here to support bfloat, but this change affects more than constrained intrinsics and more than only bfloat.

Either we need to limit this enhancement, or we need to split this into its own patch and add more tests to make sure it works as expected. I put in some basic coverage for copysign here:
8a4d05ddb3ff

I think things work as expected for simple cases like that one, but I don't know what happens if we are using the host mathlib to evaluate more complex functions (for example "pow" is in the switch under here).

[sepavloff]

Addressed reviewers' comments, rebased

[sepavloff]

llvm/lib/Analysis/ConstantFolding.cpp

2415

I put checks

if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy())
        return nullptr;

below. Constrained intrinsics have tests for bfloat type in this patch. As for other functions, test for them will be added later, and these checks will be removed.

2456

Yes, you are right. Updated.

[spatel]

llvm/lib/Analysis/ConstantFolding.cpp

2415

Thanks. I'm worried that someone could come back after this patch and add yet another if or switch and miss the differences in type handling.

How about adding a helper function to deal with ConstrainedFP and calling it from the very first clause in this function?

That also raises a question: what is the behavior of these intrinsics with undef and/or poison operands?

[sepavloff]

Move common code into separate function

[sepavloff]

llvm/lib/Analysis/ConstantFolding.cpp

2415

How about adding a helper function to deal with ConstrainedFP and calling it from the very first clause in this function?

The shared code is moved to getEvaluationRoundingMode.

That also raises a question: what is the behavior of these intrinsics with undef and/or poison operands?

Constrained intrinsics should not differ from their counterparts in handling undef/poison. @kpn is working on D103169, which eventually should implement the relevant folding.

[sepavloff]

Swap sequence of patches

[sepavloff]

Rebased

[sepavloff]

Is there anything I can do for this patch?

[spatel]

Ping @scanon to comment on whether the exception vs. fold-ability logic seems correct.

llvm/lib/Analysis/ConstantFolding.cpp

1905–1906

I think this would be easier to read if we made it more like the code above here:

Optional<RoundingMode> ORM = CI->getRoundingMode();
// If no rounding mode is specified by the intrinsic or the mode is dynamic,
// try to evaluate using the default mode. If it does not raise an inexact
// exception, rounding was not applied so the result is independent of
// rounding mode. 
if (!ORM || *ORM == RoundingMode::Dynamic) 
  return RoundingMode::NearestTiesToEven;
// Use the mode specified by the intrinsic.
return *ORM;

That's assuming I'm reading it correctly right now - are there tests with no RM specified on the intrinsic?

[sepavloff]

Addressed reviewer's note. Rebased

[sepavloff]

llvm/lib/Analysis/ConstantFolding.cpp

1905–1906

That's assuming I'm reading it correctly right now - are there tests with no RM specified on the intrinsic?

No, all affected intrinsics have such argument. Bu in other places such check is made, so I put it here also.

[spatel]

Can you fix the formatting, so we don't have clang-tidy warnings? Those pop-up boxes are getting in the way of reading the code here in Phab.

llvm/lib/Analysis/ConstantFolding.cpp

1905–1906

I am not understanding something then.
If the metadata args for rounding mode and exception behavior are required by the LangRef:
https://llvm.org/docs/LangRef.html#llvm-experimental-constrained-fadd-intrinsic
...then why is the result of getRoundingMode() or getExceptionBehavior() an Optional value? If it is not valid IR without those args, we shouldn't be adding compile-time checks for things that can't happen.

[sepavloff]

Updated patch

• Rebased,
• Get rid of some clang-tidy warnings,
• Updated test fdiv-strict.ll

[sepavloff]

llvm/lib/Analysis/ConstantFolding.cpp

1905–1906

I am not understanding something then.
If the metadata args for rounding mode and exception behavior are required by the LangRef:
https://llvm.org/docs/LangRef.html#llvm-experimental-constrained-fadd-intrinsic
...then why is the result of getRoundingMode() or getExceptionBehavior() an Optional value? If it is not valid IR without those args, we shouldn't be adding compile-time checks for things that can't happen.

This function processes any ConstrainedFPIntrinsic. Some of them do not have rounding mode arguments, like constrained variants of floor, trunc. frem also do not depend on rounding mode, although it has rounding mode argument, probably some day it would be removed.

Using Optional as return value of getRoundingMode() or getExceptionBehavior() is now a part of ConstrainedFPIntrinsic interface. It is safer to process results of these function in more general way.

[spatel]

llvm/lib/Analysis/ConstantFolding.cpp

1905–1906

Ok - thanks for explaining. I didn't think of those other intrinsics. Presumably, we'll add constant folding for those later, so this code will be shared.

1907

This code comment does not look accurate.
When we speculatively evaluate the expression, we check that *any* exception was not raised, not just the inexact exception, right?

This raises a question: if we evaluate the expression using NearestTiesToEven, then are we guaranteed that all potential exceptions (even underflow) are identical to any other rounding mode?

[sepavloff]

Rebased and reword comment

[sepavloff]

llvm/lib/Analysis/ConstantFolding.cpp

1907

This code comment does not look accurate.
When we speculatively evaluate the expression, we check that *any* exception was not raised, not just the inexact exception, right?

Yes. If exceptions are tracked and constant evaluation can raise any of them, constant expression is not folded. The relevant logic is implemented by mayFoldConstrained, which is defined above. It is necessary to set hardware state, which is expected as side effect of the evaluation.

The purpose of this rounding mode substitution is to enable constant folding of expressions like 1.0 + 1.0 even when rounding mode is dynamic, so unknown at compile time.

I tried to reword the comment to make it clearer.

This raises a question: if we evaluate the expression using NearestTiesToEven, then are we guaranteed that all potential exceptions (even underflow) are identical to any other rounding mode?

IEEE-754 compliant system evaluates an operation in two steps. First it calculates intermediate result as if both the exponent range and the precision were unbounded. Then this result is rounded if it cannot be represented in the chosen floating point format. The first step does not depend on rounding mode but the second does.

Of the five FP exception division-by-zero and invalid obviously do not depend on rounding mode. Overflow is raised when the intermediate result is too large by magnitude to be represented in the chosen floating point format. Similar considerations apply to underflow as well. As for inexact exception, if it is raised, it means the intermediate result cannot be exactly represented and the rounding step changed it to either of nearby values. The direction is determined by rounding mode but rounding is required in any rounding mode.

[spatel]

LGTM - see inline for some test file suggestions.
Might want to get a 2nd opinion though - I haven't used constrained ops or FP exceptions in C outside of toy examples.

llvm/test/Transforms/InstSimplify/constfold-constrained.ll

1

If there's not too much noise, I recommend using utils/update_test_checks.py to auto-generate the FileCheck lines in this file - it should eliminate typos and make it easier to update the file with new tests.

So (1) add new tests, (2) auto-generate the baseline CHECKs for all tests, (3) apply this patch and re-run the script, so we just have the test diffs.

llvm/test/Transforms/InstSimplify/fdiv-strictfp.ll

27 ↗

(On Diff #358919)

Fix this test to not be misleading as a preliminary/NFC commit?

[sepavloff]

Thanks!

llvm/test/Transforms/InstSimplify/constfold-constrained.ll

1

(1) and (2) are implemented in https://reviews.llvm.org/rGa0b4f424f564

llvm/test/Transforms/InstSimplify/fdiv-strictfp.ll

27 ↗

(On Diff #358919)

This typo is fixed in https://reviews.llvm.org/rG39a36999f9b4

[spatel]

I just got over to @kpn 's question on llvm-dev:
https://lists.llvm.org/pipermail/llvm-dev/2021-July/151727.html

And this patch should have tests with SNaN and QNaN inputs, so we have coverage for those cases (let me know if they are/were here, but I missed it).

define float @fadd.except.strict_qnan_qnan(float %x) {
  %r = call float @llvm.experimental.constrained.fadd.f32(float 0x7ff8000000000000, float 0x7ff8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret float %r

}

define float @fadd.except.strict_snan_qnan(float %x) {
  %r = call float @llvm.experimental.constrained.fadd.f32(float 0x7ff4000000000000, float 0x7ff8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret float %r

}

[sepavloff]

In D102673#2892961, @spatel wrote:

I just got over to @kpn 's question on llvm-dev:
https://lists.llvm.org/pipermail/llvm-dev/2021-July/151727.html

And this patch should have tests with SNaN and QNaN inputs, so we have coverage for those cases (let me know if they are/were here, but I missed it).

This patch intentionally avoided checking NaN inputs because at the same time @kpn implemented https://reviews.llvm.org/D103169. That patch must have required tests.

llvm/lib/Analysis/ConstantFolding.cpp

 //===-- ConstantFolding.cpp - Fold instructions into constants ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines routines for folding instructions into constants.
bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
   case Intrinsic::floor:
   case Intrinsic::round:
   case Intrinsic::roundeven:
   case Intrinsic::trunc:
   case Intrinsic::nearbyint:
   case Intrinsic::rint:
   // Constrained intrinsics can be folded if FP environment is known
   // to compiler.
+  case Intrinsic::experimental_constrained_fma:
+  case Intrinsic::experimental_constrained_fmuladd:
+  case Intrinsic::experimental_constrained_fadd:
+  case Intrinsic::experimental_constrained_fsub:
+  case Intrinsic::experimental_constrained_fmul:
+  case Intrinsic::experimental_constrained_fdiv:
+  case Intrinsic::experimental_constrained_frem:
   case Intrinsic::experimental_constrained_ceil:
   case Intrinsic::experimental_constrained_floor:
   case Intrinsic::experimental_constrained_round:
   case Intrinsic::experimental_constrained_roundeven:
   case Intrinsic::experimental_constrained_trunc:
   case Intrinsic::experimental_constrained_nearbyint:
   case Intrinsic::experimental_constrained_rint:
     return true;
static bool getConstIntOrUndef(Value *Op, const APInt *&C) {
   }
   if (isa<UndefValue>(Op)) {
     C = nullptr;
     return true;
   }
   return false;
 }
 
+/// Checks if the given intrinsic call, which evaluates to constant, is allowed
+/// to be folded.
+///
+/// \param CI Constrained intrinsic call.
+/// \param St Exception flags raised during constant evaluation.
+static bool mayFoldConstrained(ConstrainedFPIntrinsic *CI,
+                               APFloat::opStatus St) {
+  Optional<RoundingMode> ORM = CI->getRoundingMode();
+  Optional<fp::ExceptionBehavior> EB = CI->getExceptionBehavior();
+
+  // If the operation does not change exception status flags, it is safe
+  // to fold.
+  if (St == APFloat::opStatus::opOK) {
+    // When FP exceptions are not ignored, intrinsic call will not be
+    // eliminated, because it is considered as having side effect. But we
+    // know that its evaluation does not raise exceptions, so side effect
+    // is absent. To allow removing the call, mark it as not accessing memory.
+    if (EB && *EB != fp::ExceptionBehavior::ebIgnore)
+      CI->addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
+    return true;
+  }
+
+  // If evaluation raised FP exception, the result can depend on rounding
+  // mode. If the latter is unknown, folding is not possible.
+  if (!ORM || *ORM == RoundingMode::Dynamic)
+    return false;
+
+  // If FP exceptions are ignored, fold the call, even if such exception is
+  // raised.
+  if (!EB || *EB != fp::ExceptionBehavior::ebStrict)
+    return true;
+
+  // Leave the calculation for runtime so that exception flags be correctly set
+  // in hardware.
+  return false;
+}
+
+/// Returns the rounding mode that should be used for constant evaluation.
+static RoundingMode getEvaluationRoundingMode(const ConstrainedFPIntrinsic *CI) {
+  Optional<RoundingMode> ORM = CI->getRoundingMode();
+  if (!ORM || *ORM == RoundingMode::Dynamic)
+    // Even if the rounding mode is unknown, try evaluating the operation.
+    // If it does not raise inexact exception, rounding was not applied
+    // so the result does not depend on rounding mode.
+    return RoundingMode::NearestTiesToEven;
+  return *ORM;
+}
+
 static Constant *ConstantFoldScalarCall1(StringRef Name,
                                          Intrinsic::ID IntrinsicID,
                                          Type *Ty,
                                          ArrayRef<Constant *> Operands,
                                          const TargetLibraryInfo *TLI,
                                          const CallBase *Call) {
   assert(Operands.size() == 1 && "Wrong number of operands.");
 
case Intrinsic::minimum:
         return Operands[1];
       if (IsOp1Undef)
         return Operands[0];
       break;
     }
   }
 
   if (auto *Op1 = dyn_cast<ConstantFP>(Operands[0])) {
     if (!Ty->isFloatingPointTy())
       return nullptr;
     APFloat Op1V = Op1->getValueAPF();
 
     if (auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
       if (Op2->getType() != Op1->getType())
         return nullptr;
       APFloat Op2V = Op2->getValueAPF();
 
+      if (auto ConstrIntr = dyn_cast<ConstrainedFPIntrinsic>(Call)) {
+        RoundingMode RM = getEvaluationRoundingMode(ConstrIntr);
+        APFloat Res = Op1V;
+        APFloat::opStatus St;
+        switch (IntrinsicID) {
+        default:
+          return nullptr;
+        case Intrinsic::experimental_constrained_fadd:
+          St = Res.add(Op2V, RM);
+          break;
+        case Intrinsic::experimental_constrained_fsub:
+          St = Res.subtract(Op2V, RM);
+          break;
+        case Intrinsic::experimental_constrained_fmul:
+          St = Res.multiply(Op2V, RM);
+          break;
+        case Intrinsic::experimental_constrained_fdiv:
+          St = Res.divide(Op2V, RM);
+          break;
+        case Intrinsic::experimental_constrained_frem:
+          St = Res.remainder(Op2V);
+          break;
+        }
+        if (mayFoldConstrained(const_cast<ConstrainedFPIntrinsic *>(ConstrIntr),
+                               St))
+          return ConstantFP::get(Ty->getContext(), Res);
+        return nullptr;
+      }
+
       switch (IntrinsicID) {
       default:
         break;
       case Intrinsic::copysign:
         return ConstantFP::get(Ty->getContext(), APFloat::copySign(Op1V, Op2V));
       case Intrinsic::minnum:
         return ConstantFP::get(Ty->getContext(), minnum(Op1V, Op2V));
       case Intrinsic::maxnum:
         return ConstantFP::get(Ty->getContext(), maxnum(Op1V, Op2V));
       case Intrinsic::minimum:
         return ConstantFP::get(Ty->getContext(), minimum(Op1V, Op2V));
       case Intrinsic::maximum:
if (auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
       case LibFunc_atan2f:
       case LibFunc_atan2_finite:
       case LibFunc_atan2f_finite:
         if (TLI->has(Func))
           return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);
         break;
       }
     } else if (auto *Op2C = dyn_cast<ConstantInt>(Operands[1])) {
+      if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy())
+        return nullptr;
       if (IntrinsicID == Intrinsic::powi && Ty->isHalfTy())
         return ConstantFP::get(
             Ty->getContext(),
             APFloat((float)std::pow((float)Op1V.convertToDouble(),
                                     (int)Op2C->getZExtValue())));
       if (IntrinsicID == Intrinsic::powi && Ty->isFloatTy())
         return ConstantFP::get(
             Ty->getContext(),
static Constant *ConstantFoldScalarCall3(StringRef Name,
   assert(Operands.size() == 3 && "Wrong number of operands.");
 
   if (const auto *Op1 = dyn_cast<ConstantFP>(Operands[0])) {
     if (const auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
       if (const auto *Op3 = dyn_cast<ConstantFP>(Operands[2])) {
         const APFloat &C1 = Op1->getValueAPF();
         const APFloat &C2 = Op2->getValueAPF();
         const APFloat &C3 = Op3->getValueAPF();
+
+        if (auto ConstrIntr = dyn_cast<ConstrainedFPIntrinsic>(Call)) {
+          RoundingMode RM = getEvaluationRoundingMode(ConstrIntr);
+          APFloat Res = C1;
+          APFloat::opStatus St;
+          switch (IntrinsicID) {
+          default:
+            return nullptr;
+          case Intrinsic::experimental_constrained_fma:
+          case Intrinsic::experimental_constrained_fmuladd:
+            St = Res.fusedMultiplyAdd(C2, C3, RM);
+            break;
+          }
+          if (mayFoldConstrained(
+                  const_cast<ConstrainedFPIntrinsic *>(ConstrIntr), St))
+            return ConstantFP::get(Ty->getContext(), Res);
+          return nullptr;
+        }
+
         switch (IntrinsicID) {
         default: break;
         case Intrinsic::amdgcn_fma_legacy: {
           // The legacy behaviour is that multiplying +/- 0.0 by anything, even
           // NaN or infinity, gives +0.0.
           if (C1.isZero() || C2.isZero()) {
             // It's tempting to just return C3 here, but that would give the
             // wrong result if C3 was -0.0.

llvm/lib/Transforms/Utils/Local.cpp

bool llvm::wouldInstructionBeTriviallyDead(Instruction *I,
   if (CallInst *CI = isFreeCall(I, TLI))
     if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
       return C->isNullValue() || isa<UndefValue>(C);
 
   if (auto *Call = dyn_cast<CallBase>(I))
     if (isMathLibCallNoop(Call, TLI))
       return true;
 
+  // To express possible interaction with floating point environment constrained
+  // intrinsics are described as if they access memory. So they look like having
+  // side effect but actually do not have it unless they raise floating point
+  // exception. If FP exceptions are ignored, the intrinsic may be deleted.
+  if (auto *CI = dyn_cast<ConstrainedFPIntrinsic>(I)) {
+    Optional<fp::ExceptionBehavior> EB = CI->getExceptionBehavior();
+    if (!EB || *EB == fp::ExceptionBehavior::ebIgnore)
+      return true;
+  }
+
   return false;
 }
 
 /// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
 /// trivially dead instruction, delete it.  If that makes any of its operands
 /// trivially dead, delete them too, recursively.  Return true if any
 /// instructions were deleted.
 bool llvm::RecursivelyDeleteTriviallyDeadInstructions(

llvm/test/Transforms/InstSimplify/constfold-constrained.ll

 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 
 ; Verify that floor(10.1) is folded to 10.0 when the exception behavior is 'ignore'.
 define double @floor_01() #0 {
 entry:
   %result = call double @llvm.experimental.constrained.floor.f64(
                                                double 1.010000e+01,
                                                metadata !"fpexcept.ignore") #0
%result = call double @llvm.experimental.constrained.rint.f64(
                                                double 1.010000e+01,
                                                metadata !"round.tonearest",
                                                metadata !"fpexcept.maytrap") #0
   ret double %result
   ; CHECK-LABEL: @rint_03
   ; CHECK: ret double 1.000000e+01
 }
 
+define float @fadd_01() #0 {
+entry:
+  %result = call float @llvm.experimental.constrained.fadd.f32(
+                                               float 1.000000e+01,
+                                               float 2.000000e+01,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.ignore") #0
+  ret float %result
+  ; CHECK-LABEL: @fadd_01
+  ; CHECK: ret float 3.000000e+01
+}
+
+; Inexact result does not prevent from folding if exceptions are ignored and
+; rounding mode is known.
+define double @fadd_02() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fadd.f64(
+                                               double 1.0,
+                                               double 0x3FF0000000000001,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.ignore") #0
+  ret double %result
+  ; CHECK-LABEL: @fadd_02
+  ; CHECK: ret double 2.000000e+00
+}
+
+define double @fadd_03() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fadd.f64(
+                                               double 1.0,
+                                               double 0x3FF0000000000001,
+                                               metadata !"round.upward",
+                                               metadata !"fpexcept.ignore") #0
+  ret double %result
+  ; CHECK-LABEL: @fadd_03
+  ; CHECK: ret double 0x4000000000000001
+}
+
+; Inexact result prevents from folding if exceptions may be checked.
+define double @fadd_04() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fadd.f64(
+                                               double 1.0,
+                                               double 0x3FF0000000000001,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.strict") #0
+  ret double %result
+  ; CHECK-LABEL: @fadd_04
+  ; CHECK: ret double %result
+}
+
+; If result is exact, folding is allowed even if exceptions may be checked.
+define double @fadd_05() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fadd.f64(
+                                               double 1.0,
+                                               double 2.0,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.strict") #0
+  ret double %result
+  ; CHECK-LABEL: @fadd_05
+  ; CHECK: ret double 3.000000e+00
+}
+
+; Dynamic rounding mode does not prevent from folding if the result is exact.
+define double @fadd_06() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fadd.f64(
+                                               double 1.0,
+                                               double 2.0,
+                                               metadata !"round.dynamic",
+                                               metadata !"fpexcept.strict") #0
+  ret double %result
+  ; CHECK-LABEL: @fadd_06
+  ; CHECK: ret double 3.000000e+00
+}
+
+; Inexact results prevents from folding if rounding mode is unknown.
+define double @fadd_07() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fadd.f64(
+                                               double 1.0,
+                                               double 0x3FF0000000000001,
+                                               metadata !"round.dynamic",
+                                               metadata !"fpexcept.ignore") #0
+  ret double %result
+  ; CHECK-LABEL: @fadd_07
+  ; CHECK: ret double %result
+}
+
+; Infinite result does not prevent from folding unless exceptions are tracked.
+define double @fadd_08() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fadd.f64(
+                                               double 0x7fEFFFFFFFFFFFFF,
+                                               double 0x7fEFFFFFFFFFFFFF,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.ignore") #0
+  ret double %result
+  ; CHECK-LABEL: @fadd_08
+  ; CHECK: ret double 0x7FF0000000000000
+}
+
+define double @fadd_09() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fadd.f64(
+                                               double 0x7fEFFFFFFFFFFFFF,
+                                               double 0x7fEFFFFFFFFFFFFF,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.strict") #0
+  ret double %result
+  ; CHECK-LABEL: @fadd_09
+  ; CHECK: ret double %result
+}
+
+define half @fadd_10() #0 {
+entry:
+  %result = call half @llvm.experimental.constrained.fadd.f16(
+                                               half 1.0,
+                                               half 2.0,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.ignore") #0
+  ret half %result
+  ; CHECK-LABEL: @fadd_10
+  ; CHECK: ret half 0xH4200
+}
+
+define bfloat @fadd_11() #0 {
+entry:
+  %result = call bfloat @llvm.experimental.constrained.fadd.bf16(
+                                               bfloat 1.0,
+                                               bfloat 2.0,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.ignore") #0
+  ret bfloat %result
+  ; CHECK-LABEL: @fadd_11
+  ; CHECK: ret bfloat 0xR4040
+}
+
+define double @fsub_01() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fsub.f64(
+                                               double 1.0,
+                                               double 2.0,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.ignore") #0
+  ret double %result
+  ; CHECK-LABEL: @fsub_01
+  ; CHECK: ret double -1.000000e+00
+}
+
+define double @fmul_01() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fmul.f64(
+                                               double 1.0,
+                                               double 2.0,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.ignore") #0
+  ret double %result
+  ; CHECK-LABEL: @fmul_01
+  ; CHECK: ret double 2.000000e+00
+}
+
+define double @fdiv_01() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fdiv.f64(
+                                               double 1.0,
+                                               double 2.0,
+                                               metadata !"round.tonearest",
+                                               metadata !"fpexcept.ignore") #0
+  ret double %result
+  ; CHECK-LABEL: @fdiv_01
+  ; CHECK: ret double 5.000000e-01
+}
+
+define double @frem_01() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.frem.f64(
+                                               double 1.0,
+                                               double 2.0,
+                                               metadata !"round.dynamic",
+                                               metadata !"fpexcept.ignore") #0
+  ret double %result
+  ; CHECK-LABEL: @frem_01
+  ; CHECK: ret double 1.000000e+00
+}
+
+define double @fma_01() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fma.f64(
+                                               double 1.0,
+                                               double 2.0,
+                                               double 3.0,
+                                               metadata !"round.dynamic",
+                                               metadata !"fpexcept.ignore") #0
+  ret double %result
+  ; CHECK-LABEL: @fma_01
+  ; CHECK: ret double 5.000000e+00
+}
+
+define double @fmuladd_01() #0 {
+entry:
+  %result = call double @llvm.experimental.constrained.fmuladd.f64(
+                                               double 1.0,
+                                               double 2.0,
+                                               double 3.0,
+                                               metadata !"round.dynamic",
+                                               metadata !"fpexcept.ignore") #0
+  ret double %result
+  ; CHECK-LABEL: @fmuladd_01
+  ; CHECK: ret double 5.000000e+00
+}
+
 
 attributes #0 = { strictfp }
 
 declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.floor.f64(double, metadata)
 declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
 declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
 declare double @llvm.experimental.constrained.round.f64(double, metadata)
 declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
+declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
+declare float @llvm.experimental.constrained.fadd.f32(float, float, metadata, metadata)
+declare half @llvm.experimental.constrained.fadd.f16(half, half, metadata, metadata)
+declare bfloat @llvm.experimental.constrained.fadd.bf16(bfloat, bfloat, metadata, metadata)
+declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
+declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
+declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
+declare double @llvm.experimental.constrained.frem.f64(double, double, metadata, metadata)
+declare double @llvm.experimental.constrained.fma.f64(double, double, double, metadata, metadata)
+declare double @llvm.experimental.constrained.fmuladd.f64(double, double, double, metadata, metadata)