[FPEnv][InstSimplify] Constrained FP support for NaN

[kpn]

Summary

Currently InstructionSimplify.cpp knows how to simplify floating point instructions that have a NaN operand. It does not know how to handle the matching constrained FP intrinsic.

This patch teaches it how to simplify so long as the exception handling is not "fpexcept.strict".

[spatel]

There's a lot going on here. I think we need to break this up to make sure we're testing the corner cases.

What if we start with plain constant folding? I don't see any existing tests for these intrinsics in llvm/test/Transforms/InstSimplify/ConstProp. See fp-undef.ll in that dir for test ideas.
For example, what can we do with this set of tests:

define float @fadd_undef_strict(float %x) #0 {
  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
  ret float %r
}

define float @fadd_undef_maytrap(float %x) #0 {
  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
  ret float %r
}

define float @fadd_undef_upward(float %x) #0 {
  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #0
  ret float %r
}

define float @fadd_undef_defaultfp(float %x) #0 {
  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float undef, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
  ret float %r
}

What should happen if we replace each of those undef values with a constant number, NaN, etc?

[kpn]

In D103169#2782902, @spatel wrote:

There's a lot going on here. I think we need to break this up to make sure we're testing the corner cases.

What if we start with plain constant folding? I don't see any existing tests for these intrinsics in llvm/test/Transforms/InstSimplify/ConstProp. See fp-undef.ll in that dir for test ideas.
For example, what can we do with this set of tests:

define float @fadd_undef_strict(float %x) #0 {
  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
  ret float %r
}

define float @fadd_undef_maytrap(float %x) #0 {
  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
  ret float %r
}

define float @fadd_undef_upward(float %x) #0 {
  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #0
  ret float %r
}

define float @fadd_undef_defaultfp(float %x) #0 {
  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float undef, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
  ret float %r
}

What should happen if we replace each of those undef values with a constant number, NaN, etc?

Most of the changes are to thread exception behavior through functions that normally work with the normal FP instructions like fadd, fsub, etc.

The constrained intrinsics are then using the same code paths as those normal instructions. Which means that if the exception behavior isn't "fpexcept.strict" then with regards to undef, poison, and NaN you'll get identical results to using the regular FP instructions with identical first two operands. Some optimizations are disabled for non-default FP modes for now at least.

The constrained intrinsics with the _default_ FP mode will give you identical results to the regular instructions _including_ constant folding. At least through InstructionSimplify.cpp, anyway, with this patch.

I started where I did because InstructionSimplify.cpp's foldOrCommuteConstant() function calls into Analysis/ConstantFolding.cpp, but it doesn't yet pass through the rounding mode or exception behavior. So this actually seemed like it would be a smaller, more contained patch than jumping straight to InstSimplify's use of constant folding.

Serge Pavlov has a constant folding patch up as D102673.

I'm off the rest of the week and will be back on Tuesday, June 1.

[sepavloff]

llvm/include/llvm/Analysis/InstructionSimplify.h

160–164

Does it make sense to pass rounding mode instead of IsDefaultFPEnv and deduce if environment is default inside the function? Could it be useful for other foldings?

llvm/lib/Analysis/InstructionSimplify.cpp

4827–4828

Even if the exception behavior is ebStrict NaN propagation is not allowed only for signaling NaN, quiet NaN propagates quietly, without setting FP exceptions. Does it make sense to distinguish SNaNs and drop NaN propagation only for them?

4853–4854

With the exception of fadd X, -0, which may produce different results for different rounding modes, other simplifications seem to be useful in non-default environment. Which of the cases cannot be made in such environment?

llvm/test/Transforms/InstSimplify/fp-undef-poison-strictfp.ll

22

Should this call produce undef value instead?

46

According to documentation (https://llvm.org/docs/LangRef.html#poison-values) "An instruction that depends on a poison value, produces a poison value itself". So making call here is incorrect, it would result in lost of poison.

[kpn]

In D103169#2782902, @spatel wrote:

There's a lot going on here. I think we need to break this up to make sure we're testing the corner cases.

The meat of this is in InstructionSimplify.cpp's simplifyFPOp() and propagateNaN(). I don't see how we can split this up on the undef/poison/NaN axis without complicating those functions.

I could split this up on the fadd/fsub/fmul/etc axis and only handle constrained fadd, for example. Would that be helpful? Your current thoughts, @spatel?

llvm/include/llvm/Analysis/InstructionSimplify.h

160–164

I believe you are correct. I'm passing the bool IsDefaultFPEnv here because the current easy way to check for the default environment is to ask the ConstrainedIntrinsic about the environment. One can just look at the rounding mode and exception handling oneself, but that check is a little too complicated for my taste to have littered all over the place.

How about a llvm::fp::IsDefaultFPEnv() function that takes the rounding mode and exception behavior and does the check itself? It's more readable to someone who hasn't been following along for the past three years. It's more concise. And it would let us replace this bool with an actual rounding mode argument.

llvm/lib/Analysis/InstructionSimplify.cpp

4827–4828

For ebStrict we leave the instruction alone and let the run-time environment handle it.

A check of IEEE 754 seems to say that, when given an SNaN, an operation that produces a result will produce a QNaN. But I'm not a 754 expert. Anyone else? Please?

If you look above at the propagateNaN() function you'll see that someone thought of this and didn't have an answer. They left a comment asking the question. Was that @spatel?

I don't think a conversion to QNaN should be confined to the constrained intrinsics. It would be surprising if, for example, someone changed to a different rounding mode and suddenly NaN handling changed. So I think we should keep the codepath here the same for constrained and regular floating point. And changing propagateNaN() should be left for a later patch. Does that sound reasonable?

4853–4854

I don't know. I didn't want to put too much into one patch so I just took the conservative approach and bailed out here. If I made an error with these optimizations then a straight revert of the patch would make a mess.

I figure we can revisit later?

llvm/test/Transforms/InstSimplify/fp-undef-poison-strictfp.ll

22

This comes from propagateNaN(), which spins up a NaN if handed a value that is not a NaN. That's where the undef is changed into a NaN.

Since an undef is the set of all possible bit patterns then that set includes NaN. If I understand undef correctly we're allowed to pick a value from that set and use it. So the conversion of undef into NaN is allowed.

Plus, the current code does this already. So I'm inclined to leave it alone and have this conversion produce NaN.

46

Yes, but the very next sentence is "A poison value may be relaxed into an undef value, ...".

Using the regular instructions we have this difference:
add x, poison -> poison
fadd x, poison -> NaN

I don't know exactly why, but that's the existing practice. The constrained intrinsics should be the same as the regular FP instructions.

[spatel]

In D103169#2797205, @kpn wrote:

I could split this up on the fadd/fsub/fmul/etc axis and only handle constrained fadd, for example. Would that be helpful? Your current thoughts, @spatel?

Yes, that would help me understand more of the patterns at least. But if other reviewers are comfortable with the all-in-one patch, then I won't hold this up.

[sepavloff]

Could you please split this patch so that folding Nans would be separated from treatment of poison and undefs?

In contrast to poison and undef, Nan is a real value, which has definite representation in runtime, it is clear how to process it. Poison value is a way to propagate errors such as undefined behavior. It exists only in compile time. Of course, lowering it to NaN in instruction selector is natural, but conversion of poison into NaN in IR transformation looks like incorrect decision except some cases (like NaN*poison -> NaN). Yes, the documentation mentions that "A poison value may be relaxed into an undef value", but it is unclear when it is allowed. Undefs are even more obscure. The use case of input data, which should not influence result of an operation is clear but undefs are used in much more cases. I feel review of such transformation could be more complex.

As for Nans, such transformation is useful and anticipated.

llvm/include/llvm/Analysis/InstructionSimplify.h

160–164

How about a llvm::fp::IsDefaultFPEnv() function that takes the rounding mode and exception behavior and does the check itself?

I like this idea. In general it is profitable to have interface that can be extended.

llvm/lib/Analysis/InstructionSimplify.cpp

4853–4854

It is Ok to postpone this issue.

[kpn]

Update for review comments and reduce to just operating on NaN.

[sepavloff]

llvm/lib/Analysis/InstructionSimplify.cpp

4900

Is default environment is necessary to make constant folding? "fpexcept.maytrap" also allows constant evaluation and any rounding except dynamic does not prevent the evaluation. Maybe check only for ExBehavior != fp::ebStrict?

4951

In contrast to other Simplify* functions there is no call to foldOrCommuteConstant. May it be put here?

llvm/test/Transforms/InstSimplify/X86/fp-nan-strictfp.ll

305

Calculation of remainder does not depend on rounding mode, so this test is identical to the next.

[spatel]

llvm/test/Transforms/InstSimplify/fp-undef-poison-strictfp.ll

46

Sorry for not seeing this and possibly other inline comments sooner.

The lack of poison propagation here is a TODO item (inconsistency bug), so let's try to get this out of the way before it gets more complicated. I'll post a patch for review shortly.

The history is that poison did not exist when I added the fold for undef. Undef behavior is more complicated than poison, (and that's why we're phasing it out).

We can't do "fadd x, undef --> undef" because if we deduce something about the variable input x, the result may not take on *any* possible FP value. This is similar to why "and x, undef --> 0" (not undef).

[spatel]

Please see D104383 for an update to regular FP instruction simplification.

[kpn]

llvm/lib/Analysis/InstructionSimplify.cpp

4900

Well, we'd also need to pass down the exception behavior because it'd be a shame to not fold 2.0+2.0, but we do want to avoid folding to (for example) infinity in the ebStrict case. So constant folding is something I'm hoping to put off for a later patch. This patch is intended to be restricted to NaN.

The codepath for the normal fsub and other normal FP instructions don't have any metadata to pass in. Thus they will pick up the default arguments in this function which is for the default FP environment. So the call to IsDefaultFPEnvironment() is a check for either the normal FP instruction or a constrained instruction that is supposed to behave the same as the normal FP instruction. Put another way, this check for the default FP environment preserves the existing behavior and avoids risking another source of bugs that could trigger a revert.

4951

This function only gets called from SimplifyFMulInst(), and that function does have the call to foldOrCommuteConstant(). I'm guessing that's why this code doesn't already have the call in it. Since adding it wouldn't change anything I think we should leave it alone, at least in this patch.

llvm/test/Transforms/InstSimplify/fp-undef-poison-strictfp.ll

46

I'll change this patch when D104383 lands.

[kpn]

Phab just lost a comment of mine. Weird.

llvm/test/Transforms/InstSimplify/X86/fp-nan-strictfp.ll

305

Changing the rounding mode means we're no longer in the default FP environment. This then changes the codepath through SimplifyFRemInst(). That's why I put this test here.

[spatel]

llvm/test/Transforms/InstSimplify/fp-undef-poison-strictfp.ll

46

Thanks - ce95200b7942
Can you also pre-commit the tests with the baseline CHECK lines? That would make it easier to see what is (and what is not) changing with this patch.

[spatel]

llvm/lib/Analysis/InstructionSimplify.cpp

4827–4828

Yes, I left that comment. That was partly discussed in D44521.
I still don't know what we want to do about SNaN. If we can make a stand-alone patch to answer just that question for the constrained intrinsics, that would be nice.

[kpn]

llvm/lib/Analysis/InstructionSimplify.cpp

4827–4828

You want the regular FP instructions to be different from the constrained intrinsics? What about the rounding mode example above? Perhaps have NaN be handled differently for maytrap or strict exception handling? Still, I'm pretty sure we should keep the regular and constrained FP operations behaving the same whenever possible.

I think I can have a new patch up for discussion not too long after this patch lands.

[spatel]

llvm/lib/Analysis/InstructionSimplify.cpp

4827–4828

If we can make the behavior consistent across regular and intrinsics, that would be good. Start an llvm-dev thread to discuss different examples? I don't know if anything has changed in the more recent IEEE-754 specs.

[kpn]

Rebase after a precommit of the tests.

[spatel]

llvm/lib/Analysis/InstructionSimplify.cpp

5043–5045

This and similar changes are opening the door to every existing FP fold. That seems safe enough given that we're in the default environment, but there are no tests for this unless I've missed it?

Can we make that a small follow-on patch with some test coverage that includes FMF, so we know it's all getting piped through as expected.

[kpn]

llvm/lib/Analysis/InstructionSimplify.cpp

5043–5045

You want some tests to verify that the below folds work correctly when given constrained intrinsics with FMF? I think that's what you are asking. Since we have no tests for that currently, yes, we can do that. Unless I misunderstood?

[spatel]

llvm/lib/Analysis/InstructionSimplify.cpp

5043–5045

Yes, I'd add at least 1 test for each intrinsic, and sprinkle some FMF-required folds for more better coverage. For example, I think we want these to fold?

define float @fdiv_by 1(float %x) {
  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float 1.0, metadata !"round.tonearest", metadata !"fpexcept.ignore")
  ret float %r
}

define float @fdiv_same_op_nnan(float %x) {
  %r = call nnan float @llvm.experimental.constrained.fdiv.f32(float %x, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore")
  ret float %r
}

[kpn]

Add tests showing the folds that we are now using, and show that many of the matchers are not firing yet. Also test that the fast math flags are propagated correctly.

[spatel]

llvm/test/Transforms/InstSimplify/fast-math-strictfp.ll

65 ↗

(On Diff #355300)

Not part of this patch, but is the plan to convert the constrained op(s) into regular ops in this situation?

llvm/test/Transforms/InstSimplify/fp-undef-poison-strictfp.ll

74

There was a bug in poison propagation -- hopefully fixed with 4ec7c021970d -- but that doesn't explain why this and similar tests below are not returning poison. Update/regenerate the CHECK lines?

[kpn]

llvm/test/Transforms/InstSimplify/fast-math-strictfp.ll

65 ↗

(On Diff #355300)

No. Mixing of regular FP ops and constrained ops in a single function is not allowed since we can't prevent harmful reordering. So the only case where it might be legal is where an entire function uses the constrained intrinsics in the default FP environment. In that case ... why are the constrained intrinsics being used, anyway?

llvm/test/Transforms/InstSimplify/fp-undef-poison-strictfp.ll

74

Will do, tomorrow.

[kpn]

Update a test for changes nearby in poison handling. Now when we get poison we produce poison, so the test needed to be changed.

[spatel]

LGTM - see inline for a couple of minor points. Thanks for working on this!

llvm/include/llvm/IR/FPEnv.h

58

Nit - capitalization is opposite of current guidelines:

isDefaultFPEnvironment(fp::ExceptionBehavior EB, RoundingMode RM)

llvm/lib/Transforms/Utils/Local.cpp

478–482

Reduces to:

return FPI->getExceptionBehavior() != fp::ebStrict;

?

[qiucf]

Hi, I notice poison is generated for maytrap constrained 0 * Inf operation, but NaN for non-constrained ones. Is that expected?

define float @foo() {
entry:
  %x = tail call ninf contract afn float @llvm.experimental.constrained.fmul.f32(float 0.000000e+00, float 0x7FF0000000000000, metadata !"round.tonearest", metadata !"fpexcept.maytrap")
  ret float %x
}

# =>

define float @foo() {
entry:
  ret float poison
}

define float @foo() {
entry:
  %x = fmul ninf contract afn float 0.000000e+00, 0x7FF0000000000000
  ret float %x
}

# =>

define float @foo() {
entry:
  ret float 0x7FF8000000000000
}

Because constrained ones are handled by simplifyFPOp while non-constrained ones are handled by ConstantFoldBinaryInstruction. Should we make this consistent?

[kpn]

In D103169#2879184, @qiucf wrote:

Hi, I notice poison is generated for maytrap constrained 0 * Inf operation, but NaN for non-constrained ones. Is that expected?

define float @foo() {
entry:
  %x = tail call ninf contract afn float @llvm.experimental.constrained.fmul.f32(float 0.000000e+00, float 0x7FF0000000000000, metadata !"round.tonearest", metadata !"fpexcept.maytrap")
  ret float %x
}

# =>

define float @foo() {
entry:
  ret float poison
}

define float @foo() {
entry:
  %x = fmul ninf contract afn float 0.000000e+00, 0x7FF0000000000000
  ret float %x
}

# =>

define float @foo() {
entry:
  ret float 0x7FF8000000000000
}

Because constrained ones are handled by simplifyFPOp while non-constrained ones are handled by ConstantFoldBinaryInstruction. Should we make this consistent?

Yes, we should be consistent. The right, immediate fix for this is to have simplifyFPOp treat undef the same in the default and non-default FP environments. Right now the patch specifically excludes undef folding. This was done on purpose in this patch because of questions about how we're supposed to handle undef.

Is undef supposed to behave the same in all FP environments, default or not? I asked on llvm-dev and got no response: https://lists.llvm.org/pipermail/llvm-dev/2021-July/151727.html

[kpn]

Well, OK, partially wrong. The undef question needs to be answered, yes. But what we really need is to hook into the constant folding that we're reaching via foldOrCommuteConstant() but are currently avoiding except in the default FP environment. That'll take longer to fix, but D102673 is a step in the right direction.

[spatel]

In D103169#2880438, @kpn wrote:

Well, OK, partially wrong. The undef question needs to be answered, yes. But what we really need is to hook into the constant folding that we're reaching via foldOrCommuteConstant() but are currently avoiding except in the default FP environment. That'll take longer to fix, but D102673 is a step in the right direction.

The problem for this example is that we are not passing FMF through to constant folding. The fmul has ninf with an INF operand, so that's poison:
https://alive2.llvm.org/ce/z/DTvAX4

We get that result accidentally at the moment for constrained ops because we don't have constant folding for constrained ops. Once we land D102673, the result for constrained ops will change to NaN. So we'll be consistent, but not ideal for both cases. :)

Returning NaN is not a miscompile because we can soften poison to whatever we want, but it's not as strong an optimization as folding to poison.

llvm/include/llvm/Analysis/InstructionSimplify.h

 Value *SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
                        const SimplifyQuery &Q);
 
 /// Given operands for a Sub, fold the result or return null.
 Value *SimplifySubInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
                        const SimplifyQuery &Q);
 
 /// Given operands for an FAdd, fold the result or return null.
-Value *SimplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF,
-                        const SimplifyQuery &Q);
+Value *
+SimplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF,
+                 const SimplifyQuery &Q,
+                 fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                 RoundingMode Rounding = RoundingMode::NearestTiesToEven);
 
 /// Given operands for an FSub, fold the result or return null.
-Value *SimplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF,
-                        const SimplifyQuery &Q);
+Value *
+SimplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF,
+                 const SimplifyQuery &Q,
+                 fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                 RoundingMode Rounding = RoundingMode::NearestTiesToEven);
 
 /// Given operands for an FMul, fold the result or return null.
-Value *SimplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF,
-                        const SimplifyQuery &Q);
+Value *
+SimplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF,
+                 const SimplifyQuery &Q,
+                 fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                 RoundingMode Rounding = RoundingMode::NearestTiesToEven);
 
 /// Given operands for the multiplication of a FMA, fold the result or return
 /// null. In contrast to SimplifyFMulInst, this function will not perform
 /// simplifications whose unrounded results differ when rounded to the argument
 /// type.
 Value *SimplifyFMAFMul(Value *LHS, Value *RHS, FastMathFlags FMF,
-                       const SimplifyQuery &Q);
+                       const SimplifyQuery &Q,
+                       fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                       RoundingMode Rounding = RoundingMode::NearestTiesToEven);
 
 /// Given operands for a Mul, fold the result or return null.
 Value *SimplifyMulInst(Value *LHS, Value *RHS, const SimplifyQuery &Q);
 
 /// Given operands for an SDiv, fold the result or return null.
 Value *SimplifySDivInst(Value *LHS, Value *RHS, const SimplifyQuery &Q);
 
 /// Given operands for a UDiv, fold the result or return null.
 Value *SimplifyUDivInst(Value *LHS, Value *RHS, const SimplifyQuery &Q);
 
 /// Given operands for an FDiv, fold the result or return null.
-Value *SimplifyFDivInst(Value *LHS, Value *RHS, FastMathFlags FMF,
-                        const SimplifyQuery &Q);
+Value *
+SimplifyFDivInst(Value *LHS, Value *RHS, FastMathFlags FMF,
+                 const SimplifyQuery &Q,
+                 fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                 RoundingMode Rounding = RoundingMode::NearestTiesToEven);
 
 /// Given operands for an SRem, fold the result or return null.
 Value *SimplifySRemInst(Value *LHS, Value *RHS, const SimplifyQuery &Q);
 
 /// Given operands for a URem, fold the result or return null.
 Value *SimplifyURemInst(Value *LHS, Value *RHS, const SimplifyQuery &Q);
 
 /// Given operands for an FRem, fold the result or return null.
-Value *SimplifyFRemInst(Value *LHS, Value *RHS, FastMathFlags FMF,
-                        const SimplifyQuery &Q);
+Value *
+SimplifyFRemInst(Value *LHS, Value *RHS, FastMathFlags FMF,
+                 const SimplifyQuery &Q,
+                 fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                 RoundingMode Rounding = RoundingMode::NearestTiesToEven);
 
 /// Given operands for a Shl, fold the result or return null.
 Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
                        const SimplifyQuery &Q);
 
 /// Given operands for a LShr, fold the result or return null.
 Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
                         const SimplifyQuery &Q);

llvm/include/llvm/IR/FPEnv.h

 
 /// Returns a valid ExceptionBehavior enumerator when given a string
 /// valid as input in constrained intrinsic exception behavior metadata.
 Optional<fp::ExceptionBehavior> StrToExceptionBehavior(StringRef);
 
 /// For any ExceptionBehavior enumerator, returns a string valid as
 /// input in constrained intrinsic exception behavior metadata.
 Optional<StringRef> ExceptionBehaviorToStr(fp::ExceptionBehavior);
+
+/// Returns true if the exception handling behavior and rounding mode
+/// match what is used in the default floating point environment.
+inline bool IsDefaultFPEnvironment(fp::ExceptionBehavior eb, RoundingMode rm) {
+  return eb == fp::ebIgnore && rm == RoundingMode::NearestTiesToEven;
+}
 }
 #endif

llvm/lib/Analysis/InstructionSimplify.cpp

static Constant *propagateNaN(Constant *In) {
   // Propagate the existing NaN constant when possible.
   // TODO: Should we quiet a signaling NaN?
   return In;
 }
 
 /// Perform folds that are common to any floating-point operation. This implies
 /// transforms based on undef/NaN because the operation itself makes no
 /// difference to the result.
-static Constant *simplifyFPOp(ArrayRef<Value *> Ops,
-                              FastMathFlags FMF,
-                              const SimplifyQuery &Q) {
+static Constant *simplifyFPOp(ArrayRef<Value *> Ops, FastMathFlags FMF,
+                              const SimplifyQuery &Q,
+                              fp::ExceptionBehavior ExBehavior,
+                              RoundingMode Rounding) {
   for (Value *V : Ops) {
     bool IsNan = match(V, m_NaN());
     bool IsInf = match(V, m_Inf());
     bool IsUndef = Q.isUndefValue(V);
 
     // If this operation has 'nnan' or 'ninf' and at least 1 disallowed operand
     // (an undef operand can be chosen to be Nan/Inf), then the result of
     // this operation is poison.
     if (FMF.noNaNs() && (IsNan || IsUndef))
       return PoisonValue::get(V->getType());
     if (FMF.noInfs() && (IsInf || IsUndef))
       return PoisonValue::get(V->getType());
 
+    if (IsDefaultFPEnvironment(ExBehavior, Rounding)) {
       if (IsUndef || IsNan)
         return propagateNaN(cast<Constant>(V));
+    } else if (ExBehavior != fp::ebStrict) {
+      if (IsNan)
+        return propagateNaN(cast<Constant>(V));
+    }
   }
   return nullptr;
 }
 
 /// Given operands for an FAdd, see if we can fold the result.  If not, this
 /// returns null.
-static Value *SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
-                               const SimplifyQuery &Q, unsigned MaxRecurse) {
+static Value *
+SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
+                 const SimplifyQuery &Q, unsigned MaxRecurse,
+                 fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
+  if (IsDefaultFPEnvironment(ExBehavior, Rounding))
     if (Constant *C = foldOrCommuteConstant(Instruction::FAdd, Op0, Op1, Q))
       return C;
 
-  if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q))
+  if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
     return C;
 
+  if (!IsDefaultFPEnvironment(ExBehavior, Rounding))
+    return nullptr;
+
   // fadd X, -0 ==> X
   if (match(Op1, m_NegZeroFP()))
     return Op0;
 
   // fadd X, 0 ==> X, when we know X is not -0
   if (match(Op1, m_PosZeroFP()) &&
       (FMF.noSignedZeros() || CannotBeNegativeZero(Op0, Q.TLI)))
     return Op0;
if (FMF.noSignedZeros() && FMF.allowReassoc() &&
        match(Op1, m_FSub(m_Value(X), m_Specific(Op0)))))
     return X;
 
   return nullptr;
 }
 
 /// Given operands for an FSub, see if we can fold the result.  If not, this
 /// returns null.
-static Value *SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
-                               const SimplifyQuery &Q, unsigned MaxRecurse) {
+static Value *
+SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
+                 const SimplifyQuery &Q, unsigned MaxRecurse,
+                 fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
+  if (IsDefaultFPEnvironment(ExBehavior, Rounding))
     if (Constant *C = foldOrCommuteConstant(Instruction::FSub, Op0, Op1, Q))
       return C;
 
-  if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q))
+  if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
     return C;
 
+  if (!IsDefaultFPEnvironment(ExBehavior, Rounding))
+    return nullptr;
+
   // fsub X, +0 ==> X
   if (match(Op1, m_PosZeroFP()))
     return Op0;
 
   // fsub X, -0 ==> X, when we know X is not -0
   if (match(Op1, m_NegZeroFP()) &&
       (FMF.noSignedZeros() || CannotBeNegativeZero(Op0, Q.TLI)))
     return Op0;
if (FMF.noSignedZeros() && FMF.allowReassoc() &&
       (match(Op1, m_FSub(m_Specific(Op0), m_Value(X))) ||
        match(Op0, m_c_FAdd(m_Specific(Op1), m_Value(X)))))
     return X;
 
   return nullptr;
 }
 
 static Value *SimplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
-                              const SimplifyQuery &Q, unsigned MaxRecurse) {
-  if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q))
+                              const SimplifyQuery &Q, unsigned MaxRecurse,
+                              fp::ExceptionBehavior ExBehavior,
+                              RoundingMode Rounding) {
+  if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
     return C;
 
+  if (!IsDefaultFPEnvironment(ExBehavior, Rounding))
+    return nullptr;
+
   // fmul X, 1.0 ==> X
   if (match(Op1, m_FPOne()))
     return Op0;
 
   // fmul 1.0, X ==> X
   if (match(Op0, m_FPOne()))
     return Op1;
 
static Value *SimplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
   if (Op0 == Op1 && match(Op0, m_Intrinsic<Intrinsic::sqrt>(m_Value(X))) &&
       FMF.allowReassoc() && FMF.noNaNs() && FMF.noSignedZeros())
     return X;
 
   return nullptr;
 }
 
 /// Given the operands for an FMul, see if we can fold the result
-static Value *SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
-                               const SimplifyQuery &Q, unsigned MaxRecurse) {
+static Value *
+SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
+                 const SimplifyQuery &Q, unsigned MaxRecurse,
+                 fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
+  if (IsDefaultFPEnvironment(ExBehavior, Rounding))
     if (Constant *C = foldOrCommuteConstant(Instruction::FMul, Op0, Op1, Q))
       return C;
 
   // Now apply simplifications that do not require rounding.
-  return SimplifyFMAFMul(Op0, Op1, FMF, Q, MaxRecurse);
+  return SimplifyFMAFMul(Op0, Op1, FMF, Q, MaxRecurse, ExBehavior, Rounding);
 }
 
 Value *llvm::SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
-                              const SimplifyQuery &Q) {
-  return ::SimplifyFAddInst(Op0, Op1, FMF, Q, RecursionLimit);
+                              const SimplifyQuery &Q,
+                              fp::ExceptionBehavior ExBehavior,
+                              RoundingMode Rounding) {
+  return ::SimplifyFAddInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
+                            Rounding);
 }
 
-
 Value *llvm::SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
-                              const SimplifyQuery &Q) {
-  return ::SimplifyFSubInst(Op0, Op1, FMF, Q, RecursionLimit);
+                              const SimplifyQuery &Q,
+                              fp::ExceptionBehavior ExBehavior,
+                              RoundingMode Rounding) {
+  return ::SimplifyFSubInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
+                            Rounding);
 }
 
 Value *llvm::SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
-                              const SimplifyQuery &Q) {
-  return ::SimplifyFMulInst(Op0, Op1, FMF, Q, RecursionLimit);
+                              const SimplifyQuery &Q,
+                              fp::ExceptionBehavior ExBehavior,
+                              RoundingMode Rounding) {
+  return ::SimplifyFMulInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
+                            Rounding);
 }
 
 Value *llvm::SimplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
-                             const SimplifyQuery &Q) {
-  return ::SimplifyFMAFMul(Op0, Op1, FMF, Q, RecursionLimit);
+                             const SimplifyQuery &Q,
+                             fp::ExceptionBehavior ExBehavior,
+                             RoundingMode Rounding) {
+  return ::SimplifyFMAFMul(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
+                           Rounding);
 }
 
-static Value *SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
-                               const SimplifyQuery &Q, unsigned) {
+static Value *
+SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
+                 const SimplifyQuery &Q, unsigned,
+                 fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
+  if (IsDefaultFPEnvironment(ExBehavior, Rounding))
     if (Constant *C = foldOrCommuteConstant(Instruction::FDiv, Op0, Op1, Q))
       return C;
 
-  if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q))
+  if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
     return C;
 
+  if (!IsDefaultFPEnvironment(ExBehavior, Rounding))
+    return nullptr;
+
   // X / 1.0 -> X
   if (match(Op1, m_FPOne()))
     return Op0;
 
   // 0 / X -> 0
   // Requires that NaNs are off (X could be zero) and signed zeroes are
   // ignored (X could be positive or negative, so the output sign is unknown).
   if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZeroFP()))
if (match(Op0, m_FNegNSZ(m_Specific(Op1))) ||
         match(Op1, m_FNegNSZ(m_Specific(Op0))))
       return ConstantFP::get(Op0->getType(), -1.0);
   }
 
   return nullptr;
 }
 
 Value *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
-                              const SimplifyQuery &Q) {
-  return ::SimplifyFDivInst(Op0, Op1, FMF, Q, RecursionLimit);
+                              const SimplifyQuery &Q,
+                              fp::ExceptionBehavior ExBehavior,
+                              RoundingMode Rounding) {
+  return ::SimplifyFDivInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
+                            Rounding);
 }
 
-static Value *SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
-                               const SimplifyQuery &Q, unsigned) {
+static Value *
+SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
+                 const SimplifyQuery &Q, unsigned,
+                 fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
+                 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
+  if (IsDefaultFPEnvironment(ExBehavior, Rounding))
     if (Constant *C = foldOrCommuteConstant(Instruction::FRem, Op0, Op1, Q))
       return C;
 
-  if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q))
+  if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
     return C;
 
+  if (!IsDefaultFPEnvironment(ExBehavior, Rounding))
+    return nullptr;
+
   // Unlike fdiv, the result of frem always matches the sign of the dividend.
   // The constant match may include undef elements in a vector, so return a full
   // zero constant as the result.
   if (FMF.noNaNs()) {
     // +0 % X -> 0
     if (match(Op0, m_PosZeroFP()))
       return ConstantFP::getNullValue(Op0->getType());
     // -0 % X -> -0
     if (match(Op0, m_NegZeroFP()))
       return ConstantFP::getNegativeZero(Op0->getType());
   }
 
   return nullptr;
 }
 
 Value *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
-                              const SimplifyQuery &Q) {
-  return ::SimplifyFRemInst(Op0, Op1, FMF, Q, RecursionLimit);
+                              const SimplifyQuery &Q,
+                              fp::ExceptionBehavior ExBehavior,
+                              RoundingMode Rounding) {
+  return ::SimplifyFRemInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
+                            Rounding);
 }
 
 //=== Helper functions for higher up the class hierarchy.
 
 /// Given the operand for a UnaryOperator, see if we can fold the result.
 /// If not, this returns null.
 static Value *simplifyUnOp(unsigned Opcode, Value *Op, const SimplifyQuery &Q,
                            unsigned MaxRecurse) {
case Intrinsic::fshr: {
     if (match(ShAmtArg, m_APInt(ShAmtC))) {
       // If there's effectively no shift, return the 1st arg or 2nd arg.
       APInt BitWidth = APInt(ShAmtC->getBitWidth(), ShAmtC->getBitWidth());
       if (ShAmtC->urem(BitWidth).isNullValue())
         return Call->getArgOperand(IID == Intrinsic::fshl ? 0 : 1);
     }
     return nullptr;
   }
+  case Intrinsic::experimental_constrained_fma: {
+    Value *Op0 = Call->getArgOperand(0);
+    Value *Op1 = Call->getArgOperand(1);
+    Value *Op2 = Call->getArgOperand(2);
+    auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
+    if (Value *V = simplifyFPOp({Op0, Op1, Op2}, {}, Q,
+                                FPI->getExceptionBehavior().getValue(),
+                                FPI->getRoundingMode().getValue()))
+      return V;
+    return nullptr;
+  }
   case Intrinsic::fma:
   case Intrinsic::fmuladd: {
     Value *Op0 = Call->getArgOperand(0);
     Value *Op1 = Call->getArgOperand(1);
     Value *Op2 = Call->getArgOperand(2);
-    if (Value *V = simplifyFPOp({ Op0, Op1, Op2 }, {}, Q))
+    if (Value *V = simplifyFPOp({Op0, Op1, Op2}, {}, Q, fp::ebIgnore,
+                                RoundingMode::NearestTiesToEven))
       return V;
     return nullptr;
   }
   case Intrinsic::smul_fix:
   case Intrinsic::smul_fix_sat: {
     Value *Op0 = Call->getArgOperand(0);
     Value *Op1 = Call->getArgOperand(1);
     Value *Op2 = Call->getArgOperand(2);
case Intrinsic::experimental_vector_insert: {
     if (match(SubVec, m_Intrinsic<Intrinsic::experimental_vector_extract>(
                           m_Value(X), m_Zero())) &&
         (Q.isUndefValue(Vec) || Vec == X) && IdxN == 0 &&
         X->getType() == ReturnType)
       return X;
 
     return nullptr;
   }
+  case Intrinsic::experimental_constrained_fadd: {
+    auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
+    return SimplifyFAddInst(FPI->getArgOperand(0), FPI->getArgOperand(1),
+                            FPI->getFastMathFlags(), Q,
+                            FPI->getExceptionBehavior().getValue(),
+                            FPI->getRoundingMode().getValue());
+    break;
+  }
+  case Intrinsic::experimental_constrained_fsub: {
+    auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
+    return SimplifyFSubInst(FPI->getArgOperand(0), FPI->getArgOperand(1),
+                            FPI->getFastMathFlags(), Q,
+                            FPI->getExceptionBehavior().getValue(),
+                            FPI->getRoundingMode().getValue());
+    break;
+  }
+  case Intrinsic::experimental_constrained_fmul: {
+    auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
+    return SimplifyFMulInst(FPI->getArgOperand(0), FPI->getArgOperand(1),
+                            FPI->getFastMathFlags(), Q,
+                            FPI->getExceptionBehavior().getValue(),
+                            FPI->getRoundingMode().getValue());
+    break;
+  }
+  case Intrinsic::experimental_constrained_fdiv: {
+    auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
+    return SimplifyFDivInst(FPI->getArgOperand(0), FPI->getArgOperand(1),
+                            FPI->getFastMathFlags(), Q,
+                            FPI->getExceptionBehavior().getValue(),
+                            FPI->getRoundingMode().getValue());
+    break;
+  }
+  case Intrinsic::experimental_constrained_frem: {
+    auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
+    return SimplifyFRemInst(FPI->getArgOperand(0), FPI->getArgOperand(1),
+                            FPI->getFastMathFlags(), Q,
+                            FPI->getExceptionBehavior().getValue(),
+                            FPI->getRoundingMode().getValue());
+    break;
+  }
   default:
     return nullptr;
   }
 }
 
 static Value *tryConstantFoldCall(CallBase *Call, const SimplifyQuery &Q) {
   auto *F = dyn_cast<Function>(Call->getCalledOperand());
   if (!F || !canConstantFoldCallTo(Call, F))

llvm/lib/Transforms/Utils/Local.cpp

if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
     if ((II->getIntrinsicID() == Intrinsic::assume &&
          isAssumeWithEmptyBundle(cast<AssumeInst>(*II))) ||
         II->getIntrinsicID() == Intrinsic::experimental_guard) {
       if (ConstantInt *Cond = dyn_cast<ConstantInt>(II->getArgOperand(0)))
         return !Cond->isZero();
 
       return false;
     }
+
+    if (auto *FPI = dyn_cast<ConstrainedFPIntrinsic>(I)) {
+      Optional<fp::ExceptionBehavior> ExBehavior = FPI->getExceptionBehavior();
+      if (ExBehavior.hasValue())
+        return (ExBehavior.getValue() != fp::ebStrict);
+      else
+        return true;
+    }
   }
 
   if (isAllocLikeFn(I, TLI))
     return true;
 
   if (CallInst *CI = isFreeCall(I, TLI))
     if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
       return C->isNullValue() || isa<UndefValue>(C);

llvm/test/Transforms/InstSimplify/X86/fp-nan-strictfp.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -mtriple=x86_64-- -instsimplify -S | FileCheck %s
+
+;
+; constrained fadd
+;
+
+define float @fadd_nan_op0_strict(float %x) #0 {
+; CHECK-LABEL: @fadd_nan_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float 0x7FF8000000000000, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0:[0-9]+]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float 0x7FF8000000000000, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fadd_nan_op0_maytrap(float %x) #0 {
+; CHECK-LABEL: @fadd_nan_op0_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float 0x7FF8000000000000, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fadd_nan_op0_upward(float %x) #0 {
+; CHECK-LABEL: @fadd_nan_op0_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float 0x7FF8000000000000, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fadd_nan_op0_defaultfp(float %x) #0 {
+; CHECK-LABEL: @fadd_nan_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float 0x7FF8000000000000, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fadd_nan_op1_strict(float %x) #0 {
+; CHECK-LABEL: @fadd_nan_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[X:%.*]], float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fadd_nan_op1_maytrap(float %x) #0 {
+; CHECK-LABEL: @fadd_nan_op1_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fadd_nan_op1_upward(float %x) #0 {
+; CHECK-LABEL: @fadd_nan_op1_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float 0x7FF8000000000000, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fadd_nan_op1_defaultfp(float %x) #0 {
+; CHECK-LABEL: @fadd_nan_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float 0x7FF8000000000000, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+;
+; constrained fsub
+;
+
+define float @fsub_nan_op0_strict(float %x) {
+; CHECK-LABEL: @fsub_nan_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float 0x7FF8000000000000, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float 0x7FF8000000000000, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fsub_nan_op0_maytrap(float %x) {
+; CHECK-LABEL: @fsub_nan_op0_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float 0x7FF8000000000000, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fsub_nan_op0_upward(float %x) {
+; CHECK-LABEL: @fsub_nan_op0_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float 0x7FF8000000000000, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fsub_nan_op0_defaultfp(float %x) {
+; CHECK-LABEL: @fsub_nan_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float 0x7FF8000000000000, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fsub_nan_op1_strict(float %x) {
+; CHECK-LABEL: @fsub_nan_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[X:%.*]], float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fsub_nan_op1_maytrap(float %x) {
+; CHECK-LABEL: @fsub_nan_op1_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fsub_nan_op1_upward(float %x) {
+; CHECK-LABEL: @fsub_nan_op1_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float 0x7FF8000000000000, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fsub_nan_op1_defaultfp(float %x) {
+; CHECK-LABEL: @fsub_nan_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float 0x7FF8000000000000, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+;
+; constrained fmul
+;
+
+define float @fmul_nan_op0_strict(float %x) {
+; CHECK-LABEL: @fmul_nan_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float 0x7FF8000000000000, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float 0x7FF8000000000000, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fmul_nan_op0_maytrap(float %x) {
+; CHECK-LABEL: @fmul_nan_op0_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float 0x7FF8000000000000, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fmul_nan_op0_upward(float %x) {
+; CHECK-LABEL: @fmul_nan_op0_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float 0x7FF8000000000000, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fmul_nan_op0_defaultfp(float %x) {
+; CHECK-LABEL: @fmul_nan_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float 0x7FF8000000000000, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fmul_nan_op1_strict(float %x) {
+; CHECK-LABEL: @fmul_nan_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float [[X:%.*]], float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fmul_nan_op1_maytrap(float %x) {
+; CHECK-LABEL: @fmul_nan_op1_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fmul_nan_op1_upward(float %x) {
+; CHECK-LABEL: @fmul_nan_op1_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float 0x7FF8000000000000, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fmul_nan_op1_defaultfp(float %x) {
+; CHECK-LABEL: @fmul_nan_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float 0x7FF8000000000000, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+;
+; constrained fdiv
+;
+
+define float @fdiv_nan_op0_strict(float %x) {
+; CHECK-LABEL: @fdiv_nan_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float 0x7FF8000000000000, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float 0x7FF8000000000000, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fdiv_nan_op0_maytrap(float %x) {
+; CHECK-LABEL: @fdiv_nan_op0_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float 0x7FF8000000000000, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fdiv_nan_op0_upward(float %x) {
+; CHECK-LABEL: @fdiv_nan_op0_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float 0x7FF8000000000000, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fdiv_nan_op0_defaultfp(float %x) {
+; CHECK-LABEL: @fdiv_nan_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float 0x7FF8000000000000, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fdiv_nan_op1_strict(float %x) {
+; CHECK-LABEL: @fdiv_nan_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float [[X:%.*]], float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fdiv_nan_op1_maytrap(float %x) {
+; CHECK-LABEL: @fdiv_nan_op1_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fdiv_nan_op1_upward(float %x) {
+; CHECK-LABEL: @fdiv_nan_op1_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float 0x7FF8000000000000, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fdiv_nan_op1_defaultfp(float %x) {
+; CHECK-LABEL: @fdiv_nan_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float 0x7FF8000000000000, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+;
+; constrained frem
+;
+
+define float @frem_nan_op0_strict(float %x) {
+; CHECK-LABEL: @frem_nan_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float 0x7FF8000000000000, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float 0x7FF8000000000000, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @frem_nan_op0_maytrap(float %x) {
+; CHECK-LABEL: @frem_nan_op0_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float 0x7FF8000000000000, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @frem_nan_op0_upward(float %x) {
+; CHECK-LABEL: @frem_nan_op0_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float 0x7FF8000000000000, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @frem_nan_op0_defaultfp(float %x) {
+; CHECK-LABEL: @frem_nan_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float 0x7FF8000000000000, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @frem_nan_op1_strict(float %x) {
+; CHECK-LABEL: @frem_nan_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float [[X:%.*]], float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @frem_nan_op1_maytrap(float %x) {
+; CHECK-LABEL: @frem_nan_op1_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @frem_nan_op1_upward(float %x) {
+; CHECK-LABEL: @frem_nan_op1_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float 0x7FF8000000000000, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @frem_nan_op1_defaultfp(float %x) {
+; CHECK-LABEL: @frem_nan_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float 0x7FF8000000000000, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+;
+; constrained fma
+;
+
+define float @fma_nan_op0_strict(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float 0x7FF8000000000000, float [[X:%.*]], float [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float 0x7FF8000000000000, float %x, float %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fma_nan_op0_maytrap(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op0_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float 0x7FF8000000000000, float %x, float %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fma_nan_op0_upward(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op0_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float 0x7FF8000000000000, float %x, float %y, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_nan_op0_defaultfp(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float 0x7FF8000000000000, float %x, float %y, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_nan_op1_strict(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float 0x7FF8000000000000, float [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float 0x7FF8000000000000, float %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fma_nan_op1_maytrap(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op1_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float 0x7FF8000000000000, float %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fma_nan_op1_upward(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op1_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float 0x7FF8000000000000, float %y, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_nan_op1_defaultfp(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float 0x7FF8000000000000, float %y, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_nan_op2_strict(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op2_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float [[Y:%.*]], float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fma_nan_op2_maytrap(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op2_maytrap(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float 0x7FF8000000000000, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fma_nan_op2_upward(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op2_upward(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float 0x7FF8000000000000, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_nan_op2_defaultfp(float %x, float %y) {
+; CHECK-LABEL: @fma_nan_op2_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float 0x7FF8000000000000, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+declare float @llvm.experimental.constrained.fadd.f32(float, float, metadata, metadata) #0
+declare float @llvm.experimental.constrained.fsub.f32(float, float, metadata, metadata) #0
+declare float @llvm.experimental.constrained.fmul.f32(float, float, metadata, metadata) #0
+declare float @llvm.experimental.constrained.fdiv.f32(float, float, metadata, metadata) #0
+declare float @llvm.experimental.constrained.frem.f32(float, float, metadata, metadata) #0
+declare float @llvm.experimental.constrained.fma.f32(float, float, float, metadata, metadata) #0
+
+attributes #0 = { strictfp }

llvm/test/Transforms/InstSimplify/fp-undef-poison-strictfp.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -instsimplify -S | FileCheck %s
+
+; TODO: the instructions with poison operands should return poison
+
+;
+; constrained fadd
+;
+
+define float @fadd_undef_op0_strict(float %x) #0 {
+; CHECK-LABEL: @fadd_undef_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float undef, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0:[0-9]+]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fadd_undef_op0_maytrap(float %x) #0 {
+; CHECK-LABEL: @fadd_undef_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float undef, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fadd_undef_op0_upward(float %x) #0 {
+; CHECK-LABEL: @fadd_undef_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float undef, float [[X:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fadd_undef_op0_defaultfp(float %x) #0 {
+; CHECK-LABEL: @fadd_undef_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float undef, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fadd_poison_op0_strict(float %x) #0 {
+; CHECK-LABEL: @fadd_poison_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float poison, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float poison, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fadd_poison_op0_maytrap(float %x) #0 {
+; CHECK-LABEL: @fadd_poison_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float poison, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float poison, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fadd_poison_op0_upward(float %x) #0 {
+; CHECK-LABEL: @fadd_poison_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float poison, float [[X:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float poison, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fadd_poison_op0_defaultfp(float %x) #0 {
+; CHECK-LABEL: @fadd_poison_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float poison, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fadd_undef_op1_strict(float %x) #0 {
+; CHECK-LABEL: @fadd_undef_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[X:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fadd_undef_op1_maytrap(float %x) #0 {
+; CHECK-LABEL: @fadd_undef_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[X:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fadd_undef_op1_upward(float %x) #0 {
+; CHECK-LABEL: @fadd_undef_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[X:%.*]], float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fadd_undef_op1_defaultfp(float %x) #0 {
+; CHECK-LABEL: @fadd_undef_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float undef, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fadd_poison_op1_strict(float %x) #0 {
+; CHECK-LABEL: @fadd_poison_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[X:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fadd_poison_op1_maytrap(float %x) #0 {
+; CHECK-LABEL: @fadd_poison_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[X:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fadd_poison_op1_upward(float %x) #0 {
+; CHECK-LABEL: @fadd_poison_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[X:%.*]], float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fadd_poison_op1_defaultfp(float %x) #0 {
+; CHECK-LABEL: @fadd_poison_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fadd.f32(float %x, float poison, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+;
+; constrained fsub
+;
+
+define float @fsub_undef_op0_strict(float %x) {
+; CHECK-LABEL: @fsub_undef_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float undef, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float undef, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fsub_undef_op0_maytrap(float %x) {
+; CHECK-LABEL: @fsub_undef_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float undef, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float undef, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fsub_undef_op0_upward(float %x) {
+; CHECK-LABEL: @fsub_undef_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float undef, float [[X:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float undef, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fsub_undef_op0_defaultfp(float %x) {
+; CHECK-LABEL: @fsub_undef_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float undef, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fsub_poison_op0_strict(float %x) {
+; CHECK-LABEL: @fsub_poison_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float poison, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float poison, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fsub_poison_op0_maytrap(float %x) {
+; CHECK-LABEL: @fsub_poison_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float poison, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float poison, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fsub_poison_op0_upward(float %x) {
+; CHECK-LABEL: @fsub_poison_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float poison, float [[X:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float poison, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fsub_poison_op0_defaultfp(float %x) {
+; CHECK-LABEL: @fsub_poison_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float poison, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fsub_undef_op1_strict(float %x) {
+; CHECK-LABEL: @fsub_undef_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[X:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fsub_undef_op1_maytrap(float %x) {
+; CHECK-LABEL: @fsub_undef_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[X:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fsub_undef_op1_upward(float %x) {
+; CHECK-LABEL: @fsub_undef_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[X:%.*]], float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fsub_undef_op1_defaultfp(float %x) {
+; CHECK-LABEL: @fsub_undef_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float undef, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fsub_poison_op1_strict(float %x) {
+; CHECK-LABEL: @fsub_poison_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[X:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fsub_poison_op1_maytrap(float %x) {
+; CHECK-LABEL: @fsub_poison_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[X:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fsub_poison_op1_upward(float %x) {
+; CHECK-LABEL: @fsub_poison_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float [[X:%.*]], float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fsub_poison_op1_defaultfp(float %x) {
+; CHECK-LABEL: @fsub_poison_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fsub.f32(float %x, float poison, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+;
+; constrained fmul
+;
+
+define float @fmul_undef_op0_strict(float %x) {
+; CHECK-LABEL: @fmul_undef_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float undef, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float undef, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fmul_undef_op0_maytrap(float %x) {
+; CHECK-LABEL: @fmul_undef_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float undef, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float undef, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fmul_undef_op0_upward(float %x) {
+; CHECK-LABEL: @fmul_undef_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float undef, float [[X:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float undef, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fmul_undef_op0_defaultfp(float %x) {
+; CHECK-LABEL: @fmul_undef_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float undef, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fmul_poison_op0_strict(float %x) {
+; CHECK-LABEL: @fmul_poison_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float poison, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float poison, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fmul_poison_op0_maytrap(float %x) {
+; CHECK-LABEL: @fmul_poison_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float poison, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float poison, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fmul_poison_op0_upward(float %x) {
+; CHECK-LABEL: @fmul_poison_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float poison, float [[X:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float poison, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fmul_poison_op0_defaultfp(float %x) {
+; CHECK-LABEL: @fmul_poison_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float poison, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fmul_undef_op1_strict(float %x) {
+; CHECK-LABEL: @fmul_undef_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float [[X:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fmul_undef_op1_maytrap(float %x) {
+; CHECK-LABEL: @fmul_undef_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float [[X:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fmul_undef_op1_upward(float %x) {
+; CHECK-LABEL: @fmul_undef_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float [[X:%.*]], float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fmul_undef_op1_defaultfp(float %x) {
+; CHECK-LABEL: @fmul_undef_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float undef, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fmul_poison_op1_strict(float %x) {
+; CHECK-LABEL: @fmul_poison_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float [[X:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fmul_poison_op1_maytrap(float %x) {
+; CHECK-LABEL: @fmul_poison_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float [[X:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fmul_poison_op1_upward(float %x) {
+; CHECK-LABEL: @fmul_poison_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fmul.f32(float [[X:%.*]], float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fmul_poison_op1_defaultfp(float %x) {
+; CHECK-LABEL: @fmul_poison_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fmul.f32(float %x, float poison, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+;
+; constrained fdiv
+;
+
+define float @fdiv_undef_op0_strict(float %x) {
+; CHECK-LABEL: @fdiv_undef_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float undef, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float undef, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fdiv_undef_op0_maytrap(float %x) {
+; CHECK-LABEL: @fdiv_undef_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float undef, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float undef, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fdiv_undef_op0_upward(float %x) {
+; CHECK-LABEL: @fdiv_undef_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float undef, float [[X:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float undef, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fdiv_undef_op0_defaultfp(float %x) {
+; CHECK-LABEL: @fdiv_undef_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float undef, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fdiv_poison_op0_strict(float %x) {
+; CHECK-LABEL: @fdiv_poison_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float poison, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float poison, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fdiv_poison_op0_maytrap(float %x) {
+; CHECK-LABEL: @fdiv_poison_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float poison, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float poison, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fdiv_poison_op0_upward(float %x) {
+; CHECK-LABEL: @fdiv_poison_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float poison, float [[X:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float poison, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fdiv_poison_op0_defaultfp(float %x) {
+; CHECK-LABEL: @fdiv_poison_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float poison, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fdiv_undef_op1_strict(float %x) {
+; CHECK-LABEL: @fdiv_undef_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float [[X:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fdiv_undef_op1_maytrap(float %x) {
+; CHECK-LABEL: @fdiv_undef_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float [[X:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fdiv_undef_op1_upward(float %x) {
+; CHECK-LABEL: @fdiv_undef_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float [[X:%.*]], float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fdiv_undef_op1_defaultfp(float %x) {
+; CHECK-LABEL: @fdiv_undef_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float undef, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fdiv_poison_op1_strict(float %x) {
+; CHECK-LABEL: @fdiv_poison_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float [[X:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fdiv_poison_op1_maytrap(float %x) {
+; CHECK-LABEL: @fdiv_poison_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float [[X:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fdiv_poison_op1_upward(float %x) {
+; CHECK-LABEL: @fdiv_poison_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fdiv.f32(float [[X:%.*]], float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fdiv_poison_op1_defaultfp(float %x) {
+; CHECK-LABEL: @fdiv_poison_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fdiv.f32(float %x, float poison, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+;
+; constrained frem
+;
+
+define float @frem_undef_op0_strict(float %x) {
+; CHECK-LABEL: @frem_undef_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float undef, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float undef, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @frem_undef_op0_maytrap(float %x) {
+; CHECK-LABEL: @frem_undef_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float undef, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float undef, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @frem_undef_op0_upward(float %x) {
+; CHECK-LABEL: @frem_undef_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float undef, float [[X:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float undef, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @frem_undef_op0_defaultfp(float %x) {
+; CHECK-LABEL: @frem_undef_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float undef, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @frem_poison_op0_strict(float %x) {
+; CHECK-LABEL: @frem_poison_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float poison, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float poison, float %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @frem_poison_op0_maytrap(float %x) {
+; CHECK-LABEL: @frem_poison_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float poison, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float poison, float %x, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @frem_poison_op0_upward(float %x) {
+; CHECK-LABEL: @frem_poison_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float poison, float [[X:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float poison, float %x, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @frem_poison_op0_defaultfp(float %x) {
+; CHECK-LABEL: @frem_poison_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float poison, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @frem_undef_op1_strict(float %x) {
+; CHECK-LABEL: @frem_undef_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float [[X:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @frem_undef_op1_maytrap(float %x) {
+; CHECK-LABEL: @frem_undef_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float [[X:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @frem_undef_op1_upward(float %x) {
+; CHECK-LABEL: @frem_undef_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float [[X:%.*]], float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @frem_undef_op1_defaultfp(float %x) {
+; CHECK-LABEL: @frem_undef_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float undef, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @frem_poison_op1_strict(float %x) {
+; CHECK-LABEL: @frem_poison_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float [[X:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @frem_poison_op1_maytrap(float %x) {
+; CHECK-LABEL: @frem_poison_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float [[X:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @frem_poison_op1_upward(float %x) {
+; CHECK-LABEL: @frem_poison_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.frem.f32(float [[X:%.*]], float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @frem_poison_op1_defaultfp(float %x) {
+; CHECK-LABEL: @frem_poison_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.frem.f32(float %x, float poison, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+;
+; constrained fma
+;
+
+define float @fma_undef_op0_strict(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float undef, float [[X:%.*]], float [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float undef, float %x, float %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fma_undef_op0_maytrap(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float undef, float [[X:%.*]], float [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float undef, float %x, float %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fma_undef_op0_upward(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float undef, float [[X:%.*]], float [[Y:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float undef, float %x, float %y, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_undef_op0_defaultfp(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float undef, float %x, float %y, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_poison_op0_strict(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float poison, float [[X:%.*]], float [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float poison, float %x, float %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fma_poison_op0_maytrap(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float poison, float [[X:%.*]], float [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float poison, float %x, float %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fma_poison_op0_upward(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op0_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float poison, float [[X:%.*]], float [[Y:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float poison, float %x, float %y, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_poison_op0_defaultfp(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op0_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float poison, float %x, float %y, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_undef_op1_strict(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float undef, float [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float undef, float %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fma_undef_op1_maytrap(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float undef, float [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float undef, float %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fma_undef_op1_upward(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float undef, float [[Y:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float undef, float %y, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_undef_op1_defaultfp(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float undef, float %y, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_poison_op1_strict(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float poison, float [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float poison, float %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fma_poison_op1_maytrap(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op1_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float poison, float [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float poison, float %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fma_poison_op1_upward(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op1_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float poison, float [[Y:%.*]], metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float poison, float %y, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_poison_op1_defaultfp(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op1_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float poison, float %y, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_undef_op2_strict(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op2_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float [[Y:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float undef, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fma_undef_op2_maytrap(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op2_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float [[Y:%.*]], float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fma_undef_op2_upward(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op2_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float [[Y:%.*]], float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float undef, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_undef_op2_defaultfp(float %x, float %y) {
+; CHECK-LABEL: @fma_undef_op2_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float undef, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_poison_op2_strict(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op2_strict(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float [[Y:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float poison, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  ret float %r
+}
+
+define float @fma_poison_op2_maytrap(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op2_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float [[Y:%.*]], float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  ret float %r
+}
+
+define float @fma_poison_op2_upward(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op2_upward(
+; CHECK-NEXT:    [[R:%.*]] = call float @llvm.experimental.constrained.fma.f32(float [[X:%.*]], float [[Y:%.*]], float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float poison, metadata !"round.upward", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+define float @fma_poison_op2_defaultfp(float %x, float %y) {
+; CHECK-LABEL: @fma_poison_op2_defaultfp(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %r = call float @llvm.experimental.constrained.fma.f32(float %x, float %y, float poison, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret float %r
+}
+
+declare float @llvm.experimental.constrained.fadd.f32(float, float, metadata, metadata) #0
+declare float @llvm.experimental.constrained.fsub.f32(float, float, metadata, metadata) #0
+declare float @llvm.experimental.constrained.fmul.f32(float, float, metadata, metadata) #0
+declare float @llvm.experimental.constrained.fdiv.f32(float, float, metadata, metadata) #0
+declare float @llvm.experimental.constrained.frem.f32(float, float, metadata, metadata) #0
+declare float @llvm.experimental.constrained.fma.f32(float, float, float, metadata, metadata) #0
+
+attributes #0 = { strictfp }