If constrained intrinsic is replaced, remove its side effect

[sepavloff]

Summary

Constrained intrinsics are declared as having side effect. During
constant folding it can be found that actually the operation does not
raise floating-point exceptions and may be eliminated. With this change
such instruction is marked as not having side effect, so that
subsequent DCE pass may remove it.

[nikic]

This is likely not going to be particularly useful, as the InstSimplifyPass is not really used outside of testing. To be generally applicable, this logic would have to be in wouldInstructionBeTriviallyDead().

[nikic]

Marking as changes requested per above comment -- really don't think this is the right place to address this, since it will just create an incorrect picture of what LLVM can optimize in practice. Usually, this fold will happen via InstCombine rather than InstSimplifyPass. But I don't think changing InstCombine is the right solution either, as any number of passes do this kind of "simplify and DCE" pattern.

[kpn]

Well, the problem is more widespread than that. IPSCCP can create instructions where it knows the result, and it knows the instruction will never trap. Consider how it can propagate two constants into a compare instruction. It knows the values are constants, it knows they are not undef, poison, NaN, Inf, it knows the value of the compare, and it uses that knowledge to further propagate constants and simplify the code. But it can't remove the constrained compare instruction because we don't have a good way to tell it the instruction has no side effects. It does call Instruction::isSafeToRemove(), and it does _not_ call wouldInstructionBeTriviallyDead(). A more centralized approach would be helpful.

Perhaps a way of asking the constrained intrinsic if it has a side effect? Then we can even eliminate constrained intrinsics that are "fpexcept.strict" but are known to never trap. This isn't ideal, either, but it's my current line of thinking, anyway. I don't have a really good solution.

[sepavloff]

In D114766#3160877, @nikic wrote:

This is likely not going to be particularly useful, as the InstSimplifyPass is not really used outside of testing. To be generally applicable, this logic would have to be in wouldInstructionBeTriviallyDead().

Why? This pass is run when clang is executed. Due to it the source file:

double func() {
  return 1.0 + 2.0;
}

compiled with:

clang -target x86_64-linux -S -O2 -ftrapping-math const-10.c

produces code:

	movsd	.LCPI0_0(%rip), %xmm0           # xmm0 = mem[0],zero
	retq

If setting attribute ReadNone in mayFoldConstrained is commented out, the resulting code contains add instruction:

	movsd	.LCPI0_0(%rip), %xmm0           # xmm0 = mem[0],zero
	addsd	.LCPI0_1(%rip), %xmm0
	movsd	.LCPI0_2(%rip), %xmm0           # xmm0 = mem[0],zero
	retq

But, as you noted in D110322, ConstantFolding.cpp is not right place for changing attributes. This patch just moves this change to more appropriate place.

Moving this logic to wouldInstructionBeTriviallyDead() does not seem right, because the decision about removing side effect comes from constant evaluation and not from the state of call object.

In D114766#3161426, @nikic wrote:

Marking as changes requested per above comment -- really don't think this is the right place to address this, since it will just create an incorrect picture of what LLVM can optimize in practice. Usually, this fold will happen via InstCombine rather than InstSimplifyPass. But I don't think changing InstCombine is the right solution either, as any number of passes do this kind of "simplify and DCE" pattern.

Sorry, I don't understand why this is not the right place. This pass makes constant folding and it is natural to fix attributes here, isn't it? What is wrong?

[kpn]

In D114766#3161680, @sepavloff wrote:

Moving this logic to wouldInstructionBeTriviallyDead() does not seem right, because the decision about removing side effect comes from constant evaluation and not from the state of call object.

I'm sympathetic to this argument. If a transformation pass determines that a constrained intrinsic can be removed then it would be helpful if that pass could note that fact. This doesn't help us with analysis passes, though. And I'm a little worried about having to explicitly mark constrained intrinsics as removable since I don't know that we do that for any other instruction. If constrained intrinsics are the only time we do this then it seems error prone. Maybe I'm wrong?

[nikic]

In D114766#3161680, @sepavloff wrote:

In D114766#3160877, @nikic wrote:

This is likely not going to be particularly useful, as the InstSimplifyPass is not really used outside of testing. To be generally applicable, this logic would have to be in wouldInstructionBeTriviallyDead().

Why? This pass is run when clang is executed. [...]

Yes, because we do happen to have a single InstSimplifyPass run at the very end of the pipeline (in https://github.com/llvm/llvm-project/blob/98dbcff19cfedb4e27d267310a76d616cd435447/llvm/lib/Passes/PassBuilderPipelines.cpp#L1194). However, mostly InstSimplify is only used as an analysis, with the most important consumer being InstCombine, which uses InstSimplify (the analysis, not the pass) and runs many times during the optimization pipeline. So while your code is indeed getting optimized, it is optimized very late, and you would likely see phase-ordering issues in a more practical example.

[sepavloff]

In D114766#3161688, @kpn wrote:

In D114766#3161680, @sepavloff wrote:

Moving this logic to wouldInstructionBeTriviallyDead() does not seem right, because the decision about removing side effect comes from constant evaluation and not from the state of call object.

I'm sympathetic to this argument. If a transformation pass determines that a constrained intrinsic can be removed then it would be helpful if that pass could note that fact. This doesn't help us with analysis passes, though. And I'm a little worried about having to explicitly mark constrained intrinsics as removable since I don't know that we do that for any other instruction. If constrained intrinsics are the only time we do this then it seems error prone. Maybe I'm wrong?

The ability to remove side effect is vital for the implementation of floating point arithmetic. There are several possible optimization techniques, which depend on this possibility. For example, if FP operations in a function have attributes "round.dynamic" and "fpexcept.ignore" and we know that rounding mode is not changed in this function, we could remove side effect of all the operations, which can give performance of non-constrained operations. As we cannot mix ordinary and constrained operation in the same function, the only way is to control side effect.

[lebedev.ri]

In D114766#3161737, @sepavloff wrote:

In D114766#3161688, @kpn wrote:

In D114766#3161680, @sepavloff wrote:

Moving this logic to wouldInstructionBeTriviallyDead() does not seem right, because the decision about removing side effect comes from constant evaluation and not from the state of call object.

I'm sympathetic to this argument. If a transformation pass determines that a constrained intrinsic can be removed then it would be helpful if that pass could note that fact. This doesn't help us with analysis passes, though. And I'm a little worried about having to explicitly mark constrained intrinsics as removable since I don't know that we do that for any other instruction. If constrained intrinsics are the only time we do this then it seems error prone. Maybe I'm wrong?

The ability to remove side effect is vital for the implementation of floating point arithmetic. There are several possible optimization techniques, which depend on this possibility. For example, if FP operations in a function have attributes "round.dynamic" and "fpexcept.ignore" and we know that rounding mode is not changed in this function, we could remove side effect of all the operations, which can give performance of non-constrained operations. As we cannot mix ordinary and constrained operation in the same function, the only way is to control side effect.

We aren't saying that the ocean isn't full of water, we are only saying that you are looking at the pond while thinking it's an ocean.
We are talking about different things here. Fixing InstSimplify pass will not do any good, because it's effectively not used.

[kpn]

In D114766#3161749, @lebedev.ri wrote:

In D114766#3161737, @sepavloff wrote:

In D114766#3161688, @kpn wrote:

In D114766#3161680, @sepavloff wrote:

Moving this logic to wouldInstructionBeTriviallyDead() does not seem right, because the decision about removing side effect comes from constant evaluation and not from the state of call object.

I'm sympathetic to this argument. If a transformation pass determines that a constrained intrinsic can be removed then it would be helpful if that pass could note that fact. This doesn't help us with analysis passes, though. And I'm a little worried about having to explicitly mark constrained intrinsics as removable since I don't know that we do that for any other instruction. If constrained intrinsics are the only time we do this then it seems error prone. Maybe I'm wrong?

The ability to remove side effect is vital for the implementation of floating point arithmetic. There are several possible optimization techniques, which depend on this possibility. For example, if FP operations in a function have attributes "round.dynamic" and "fpexcept.ignore" and we know that rounding mode is not changed in this function, we could remove side effect of all the operations, which can give performance of non-constrained operations. As we cannot mix ordinary and constrained operation in the same function, the only way is to control side effect.

We aren't saying that the ocean isn't full of water, we are only saying that you are looking at the pond while thinking it's an ocean.
We are talking about different things here. Fixing InstSimplify pass will not do any good, because it's effectively not used.

A solution that works for all transformation passes would be quite useful indeed.

[sepavloff]

In D114766#3161692, @nikic wrote:

In D114766#3161680, @sepavloff wrote:

In D114766#3160877, @nikic wrote:

This is likely not going to be particularly useful, as the InstSimplifyPass is not really used outside of testing. To be generally applicable, this logic would have to be in wouldInstructionBeTriviallyDead().

Why? This pass is run when clang is executed. [...]

Yes, because we do happen to have a single InstSimplifyPass run at the very end of the pipeline (in https://github.com/llvm/llvm-project/blob/98dbcff19cfedb4e27d267310a76d616cd435447/llvm/lib/Passes/PassBuilderPipelines.cpp#L1194). However, mostly InstSimplify is only used as an analysis, with the most important consumer being InstCombine, which uses InstSimplify (the analysis, not the pass) and runs many times during the optimization pipeline. So while your code is indeed getting optimized, it is optimized very late, and you would likely see phase-ordering issues in a more practical example.

Probably the pass should run earlier, it is hard to reason without analyzing practical cases. If it is indeed so, we could move the pass or run it several times. Tuning pipeline is not unique for constant folding only. But without ability to remove instructions many optimizations do not make sense.

[sepavloff]

In D114766#3161749, @lebedev.ri wrote:

In D114766#3161737, @sepavloff wrote:

In D114766#3161688, @kpn wrote:

In D114766#3161680, @sepavloff wrote:

Moving this logic to wouldInstructionBeTriviallyDead() does not seem right, because the decision about removing side effect comes from constant evaluation and not from the state of call object.

I'm sympathetic to this argument. If a transformation pass determines that a constrained intrinsic can be removed then it would be helpful if that pass could note that fact. This doesn't help us with analysis passes, though. And I'm a little worried about having to explicitly mark constrained intrinsics as removable since I don't know that we do that for any other instruction. If constrained intrinsics are the only time we do this then it seems error prone. Maybe I'm wrong?

The ability to remove side effect is vital for the implementation of floating point arithmetic. There are several possible optimization techniques, which depend on this possibility. For example, if FP operations in a function have attributes "round.dynamic" and "fpexcept.ignore" and we know that rounding mode is not changed in this function, we could remove side effect of all the operations, which can give performance of non-constrained operations. As we cannot mix ordinary and constrained operation in the same function, the only way is to control side effect.

We aren't saying that the ocean isn't full of water, we are only saying that you are looking at the pond while thinking it's an ocean.
We are talking about different things here. Fixing InstSimplify pass will not do any good, because it's effectively not used.

It is used and does its job, as experiments demonstrate. Probably it is not the right place, but until we didn't met its limitations or elaborate a better way we could use this imperfect solution. Moving with small steps toward the perfect implementation.

[kpn]

In D114766#3161806, @sepavloff wrote:

Probably the pass should run earlier, it is hard to reason without analyzing practical cases. If it is indeed so, we could move the pass or run it several times. Tuning pipeline is not unique for constant folding only. But without ability to remove instructions many optimizations do not make sense.

But InstSimplify is used for analysis long before it is run for transformations. Other passes just call into InstSimplify and bypass InstSimplify's transformation pass machinery. Meaning, parts of InstSimplify do run earlier in the pipeline _already_. And many if not most transformation passes eliminate instructions without going through InstSimplify. So tuning the pipeline is not the answer.

Coming up with a more general solution that can be used by multiple transformation passes is what we need.

[sepavloff]

In D114766#3161851, @kpn wrote:

In D114766#3161806, @sepavloff wrote:

Probably the pass should run earlier, it is hard to reason without analyzing practical cases. If it is indeed so, we could move the pass or run it several times. Tuning pipeline is not unique for constant folding only. But without ability to remove instructions many optimizations do not make sense.

But InstSimplify is used for analysis long before it is run for transformations. Other passes just call into InstSimplify and bypass InstSimplify's transformation pass machinery. Meaning, parts of InstSimplify do run earlier in the pipeline _already_.

As @nikic pointer out (https://reviews.llvm.org/D114766#3161692):

However, mostly InstSimplify is only used as an analysis, with the most important consumer being InstCombine, which uses InstSimplify (the analysis, not the pass) and runs many times during the optimization pipeline.

Call attribute fixing occurs only in the pass, which runs once.

And many if not most transformation passes eliminate instructions without going through InstSimplify. So tuning the pipeline is not the answer.

We do not eliminate instructions in InstSimplify. We mark them available for elimination. The elimination itself occurs in dedicated passes designed for just this purpose. So the question is only whether we may remove side effect from some calls.

Coming up with a more general solution that can be used by multiple transformation passes is what we need.

The solution actually is the call CI->addFnAttr(Attribute::ReadNone). Hardly there is a simpler or more general solution. We apply it when we know that the instruction is not needed anymore, also quite reasonable, why postpone this? The only possible concern is when we do the actions like constant folding, which may result in the attribute change. Does it occur too late? Or maybe it takes place at right moment? We do not know now. So I would propose to use with current state and change it when we found that there is a better solution.

[sepavloff]

Let me summarize some points of the solution:

1. Changing call site attributes is safe. It is equivalent to the creation of a new call site, with new set of attributes, and then replacing the old one with it, an ubiquitous operation in LLVM.
2. The attribute adjustment can be made as soon as the possibility of constant folding is detected.
3. The place where constant evaluation occurs is a subject of pipeline tuning. It is obvious that it should not run too early because the frontend already makes constant expression evaluation, so the constant evaluation in IR pipeline mainly evaluates constants formed by previous passes. Current point where InstSimplify is run probably is not the best, but it must be good enough.

[lebedev.ri]

This is starting to sound like the isnan threads all over again. I don't envision making much progress with this approach...

[kpn]

In D114766#3161426, @nikic wrote:

Marking as changes requested per above comment -- really don't think this is the right place to address this, since it will just create an incorrect picture of what LLVM can optimize in practice. Usually, this fold will happen via InstCombine rather than InstSimplifyPass. But I don't think changing InstCombine is the right solution either, as any number of passes do this kind of "simplify and DCE" pattern.

Let's back up. If we try and move logic into wouldInstructionBeTriviallyDead() then what would that look like? Transform and analysis passes both have loads of information that is not available to wouldInstructionBeTriviallyDead(). Trying to gather that information again would be non-trivial and wouldn't scale since it would be a layering violation if wouldInstructionBeTriviallyDead() tried to gather it. So information about whether or not a constrained intrinsic can be eliminated would need to be passed into wouldInstructionBeTriviallyDead(). And we'll have to go pass by pass implementing this passing around of information. What would or should that look like?

Let me float this idea: Would a bool passed in as an argument be sufficient? As in "I, an arbitrary transform pass, think this instruction is dead, but what does wouldInstructionBeTriviallyDead() say about it?"

@nikic, @lebedev.ri: Is there another approach that makes more sense?

[nikic]

In D114766#3164792, @kpn wrote:

In D114766#3161426, @nikic wrote:

Marking as changes requested per above comment -- really don't think this is the right place to address this, since it will just create an incorrect picture of what LLVM can optimize in practice. Usually, this fold will happen via InstCombine rather than InstSimplifyPass. But I don't think changing InstCombine is the right solution either, as any number of passes do this kind of "simplify and DCE" pattern.

Let's back up. If we try and move logic into wouldInstructionBeTriviallyDead() then what would that look like? Transform and analysis passes both have loads of information that is not available to wouldInstructionBeTriviallyDead(). Trying to gather that information again would be non-trivial and wouldn't scale since it would be a layering violation if wouldInstructionBeTriviallyDead() tried to gather it. So information about whether or not a constrained intrinsic can be eliminated would need to be passed into wouldInstructionBeTriviallyDead(). And we'll have to go pass by pass implementing this passing around of information. What would or should that look like?

Let me float this idea: Would a bool passed in as an argument be sufficient? As in "I, an arbitrary transform pass, think this instruction is dead, but what does wouldInstructionBeTriviallyDead() say about it?"

@nikic, @lebedev.ri: Is there another approach that makes more sense?

I think constrained FP intrinsics are basically in the same situation as math libcalls with errno. These get constant folded, and removal is handled via isMathLibCallNoop() in wouldInstructionBeTriviallyDead(). I would expected constrained FP intrinsics to basically work the same way. Of course, the implementation can be shared with the actual folding code, so for example wouldInstructionBeTriviallyDead() could check whether all intrinsic args are constant, if they are call the constrained FP folding function internally, and then say that it is trivially dead if it folds. (Or something more nuanced -- presumably there are cases where it's possible to determine the result but not drop, or maybe drop but not fold. Not familiar with the details here.)

Changing the infrastructure so that InstSimplify/ConstantFolding could report that the instruction is in fact dead (and not just the result known) is certainly also a possibility, but it's likely not the path of least resistance.

[sepavloff]

In D114766#3165135, @nikic wrote:

I think constrained FP intrinsics are basically in the same situation as math libcalls with errno. These get constant folded, and removal is handled via isMathLibCallNoop() in wouldInstructionBeTriviallyDead(). I would expected constrained FP intrinsics to basically work the same way. Of course, the implementation can be shared with the actual folding code, so for example wouldInstructionBeTriviallyDead() could check whether all intrinsic args are constant, if they are call the constrained FP folding function internally, and then say that it is trivially dead if it folds. (Or something more nuanced -- presumably there are cases where it's possible to determine the result but not drop, or maybe drop but not fold. Not familiar with the details here.)

Changing the infrastructure so that InstSimplify/ConstantFolding could report that the instruction is in fact dead (and not just the result known) is certainly also a possibility, but it's likely not the path of least resistance.

Removal of constrained intrinsic calls is not limited by constant folding. InstSimplify can make replacement of calls with non-const arguments, like the transformation 'x * 0 -> 0' in fast-math mode. Other similar transformations would be added in future. Recognition if all these cases in wouldInstructionBeTriviallyDead would make it too large.

[sepavloff]

The problem was solved in D118426.

llvm/lib/Analysis/ConstantFolding.cpp

static bool getConstIntOrUndef(Value *Op, const APInt *&C) {
   return false;
 }
 
 /// Checks if the given intrinsic call, which evaluates to constant, is allowed
 /// to be folded.
 ///
 /// \param CI Constrained intrinsic call.
 /// \param St Exception flags raised during constant evaluation.
-static bool mayFoldConstrained(ConstrainedFPIntrinsic *CI,
+static bool mayFoldConstrained(const ConstrainedFPIntrinsic *CI,
                                APFloat::opStatus St) {
   Optional<RoundingMode> ORM = CI->getRoundingMode();
   Optional<fp::ExceptionBehavior> EB = CI->getExceptionBehavior();
 
   // If the operation does not change exception status flags, it is safe
   // to fold.
-  if (St == APFloat::opStatus::opOK) {
-    // When FP exceptions are not ignored, intrinsic call will not be
-    // eliminated, because it is considered as having side effect. But we
-    // know that its evaluation does not raise exceptions, so side effect
-    // is absent. To allow removing the call, mark it as not accessing memory.
-    if (EB && *EB != fp::ExceptionBehavior::ebIgnore)
-      CI->addFnAttr(Attribute::ReadNone);
+  if (St == APFloat::opStatus::opOK)
     return true;
-  }
 
   // If evaluation raised FP exception, the result can depend on rounding
   // mode. If the latter is unknown, folding is not possible.
   if (!ORM || *ORM == RoundingMode::Dynamic)
     return false;
 
   // If FP exceptions are ignored, fold the call, even if such exception is
   // raised.
if (const auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
           break;
         case Intrinsic::experimental_constrained_fdiv:
           St = Res.divide(Op2V, RM);
           break;
         case Intrinsic::experimental_constrained_frem:
           St = Res.mod(Op2V);
           break;
         }
-        if (mayFoldConstrained(const_cast<ConstrainedFPIntrinsic *>(ConstrIntr),
-                               St))
+        if (mayFoldConstrained(ConstrIntr, St))
           return ConstantFP::get(Ty->getContext(), Res);
         return nullptr;
       }
 
       switch (IntrinsicID) {
       default:
         break;
       case Intrinsic::copysign:
if (const auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
           switch (IntrinsicID) {
           default:
             return nullptr;
           case Intrinsic::experimental_constrained_fma:
           case Intrinsic::experimental_constrained_fmuladd:
             St = Res.fusedMultiplyAdd(C2, C3, RM);
             break;
           }
-          if (mayFoldConstrained(
-                  const_cast<ConstrainedFPIntrinsic *>(ConstrIntr), St))
+          if (mayFoldConstrained(ConstrIntr, St))
             return ConstantFP::get(Ty->getContext(), Res);
           return nullptr;
         }
 
         switch (IntrinsicID) {
         default: break;
         case Intrinsic::amdgcn_fma_legacy: {
           // The legacy behaviour is that multiplying +/- 0.0 by anything, even

llvm/lib/Transforms/Scalar/InstSimplifyPass.cpp

 #include "llvm/Transforms/Utils/Local.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "instsimplify"
 
 STATISTIC(NumSimplified, "Number of redundant instructions removed");
 
+static bool isReplacedInstructionDead(Instruction *I) {
+  if (!I->use_empty())
+    return false;
+  if (wouldInstructionBeTriviallyDead(I))
+    return true;
+  // Constrained intrinsics usually are marked as having side effect to indicate
+  // possible effect on floating point environment. If however such instruction
+  // is replaced, it is assumed that the environment is actually is not changed,
+  // the change is ignored, or the replacement has the same effect. In this case
+  // remove the side effect and consider the instruction as dead.
+  if (auto *CI = dyn_cast<ConstrainedFPIntrinsic>(I)) {
+    CI->addFnAttr(Attribute::ReadNone);
+    return true;
+  }
+  return false;
+}
+
 static bool runImpl(Function &F, const SimplifyQuery &SQ,
                     OptimizationRemarkEmitter *ORE) {
   SmallPtrSet<const Instruction *, 8> S1, S2, *ToSimplify = &S1, *Next = &S2;
   bool Changed = false;
 
   do {
     for (BasicBlock &BB : F) {
       // Unreachable code can take on strange forms that we are not prepared to
       // handle. For example, an instruction may have itself as an operand.
       if (!SQ.DT->isReachableFromEntry(&BB))
         continue;
 
       SmallVector<WeakTrackingVH, 8> DeadInstsInBB;
       for (Instruction &I : BB) {
         // The first time through the loop, ToSimplify is empty and we try to
         // simplify all instructions. On later iterations, ToSimplify is not
         // empty and we only bother simplifying instructions that are in it.
         if (!ToSimplify->empty() && !ToSimplify->count(&I))
           continue;
 
         // Don't waste time simplifying dead/unused instructions.
-        if (isInstructionTriviallyDead(&I)) {
+        if (isReplacedInstructionDead(&I)) {
           DeadInstsInBB.push_back(&I);
           Changed = true;
         } else if (!I.use_empty()) {
           if (Value *V = SimplifyInstruction(&I, SQ, ORE)) {
             // Mark all uses for resimplification next time round the loop.
             for (User *U : I.users())
               Next->insert(cast<Instruction>(U));
             I.replaceAllUsesWith(V);
             ++NumSimplified;
             Changed = true;
-            // A call can get simplified, but it may not be trivially dead.
-            if (isInstructionTriviallyDead(&I))
+            // A call can get simplified, but it may not be dead.
+            if (isReplacedInstructionDead(&I))
               DeadInstsInBB.push_back(&I);
           }
         }
       }
       RecursivelyDeleteTriviallyDeadInstructions(DeadInstsInBB, SQ.TLI);
     }
 
     // Place the list of instructions to simplify on the next loop iteration

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

entry:
   %result = call double @llvm.experimental.constrained.floor.f64(double 1.010000e+01, metadata !"fpexcept.ignore") #0
   ret double %result
 }
 
 ; Verify that floor(-10.1) is folded to -11.0 when the exception behavior is not 'ignore'.
 define double @floor_02() #0 {
 ; CHECK-LABEL: @floor_02(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.floor.f64(double -1.010000e+01, metadata !"fpexcept.strict") #[[ATTR0:[0-9]+]]
 ; CHECK-NEXT:    ret double -1.100000e+01
 ;
 entry:
   %result = call double @llvm.experimental.constrained.floor.f64(double -1.010000e+01, metadata !"fpexcept.strict") #0
   ret double %result
 }
 
 ; Verify that ceil(10.1) is folded to 11.0 when the exception behavior is 'ignore'.
 define double @ceil_01() #0 {
 ; CHECK-LABEL: @ceil_01(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret double 1.100000e+01
 ;
 entry:
   %result = call double @llvm.experimental.constrained.ceil.f64(double 1.010000e+01, metadata !"fpexcept.ignore") #0
   ret double %result
 }
 
 ; Verify that ceil(-10.1) is folded to -10.0 when the exception behavior is not 'ignore'.
 define double @ceil_02() #0 {
 ; CHECK-LABEL: @ceil_02(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.ceil.f64(double -1.010000e+01, metadata !"fpexcept.strict") #[[ATTR0]]
 ; CHECK-NEXT:    ret double -1.000000e+01
 ;
 entry:
   %result = call double @llvm.experimental.constrained.ceil.f64(double -1.010000e+01, metadata !"fpexcept.strict") #0
   ret double %result
 }
 
 ; Verify that trunc(10.1) is folded to 10.0 when the exception behavior is 'ignore'.
 define double @trunc_01() #0 {
 ; CHECK-LABEL: @trunc_01(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret double 1.000000e+01
 ;
 entry:
   %result = call double @llvm.experimental.constrained.trunc.f64(double 1.010000e+01, metadata !"fpexcept.ignore") #0
   ret double %result
 }
 
 ; Verify that trunc(-10.1) is folded to -10.0 when the exception behavior is NOT 'ignore'.
 define double @trunc_02() #0 {
 ; CHECK-LABEL: @trunc_02(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.trunc.f64(double -1.010000e+01, metadata !"fpexcept.strict") #[[ATTR0]]
 ; CHECK-NEXT:    ret double -1.000000e+01
 ;
 entry:
   %result = call double @llvm.experimental.constrained.trunc.f64(double -1.010000e+01, metadata !"fpexcept.strict") #0
   ret double %result
 }
 
 ; Verify that round(10.5) is folded to 11.0 when the exception behavior is 'ignore'.
 define double @round_01() #0 {
 ; CHECK-LABEL: @round_01(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret double 1.100000e+01
 ;
 entry:
   %result = call double @llvm.experimental.constrained.round.f64(double 1.050000e+01, metadata !"fpexcept.ignore") #0
   ret double %result
 }
 
 ; Verify that floor(-10.5) is folded to -11.0 when the exception behavior is NOT 'ignore'.
 define double @round_02() #0 {
 ; CHECK-LABEL: @round_02(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.round.f64(double -1.050000e+01, metadata !"fpexcept.strict") #[[ATTR0]]
 ; CHECK-NEXT:    ret double -1.100000e+01
 ;
 entry:
   %result = call double @llvm.experimental.constrained.round.f64(double -1.050000e+01, metadata !"fpexcept.strict") #0
   ret double %result
 }
 
 ; Verify that nearbyint(10.5) is folded to 11.0 when the rounding mode is 'upward'.
entry:
   %result = call double @llvm.experimental.constrained.nearbyint.f64(double 1.050000e+01, metadata !"round.downward", metadata !"fpexcept.maytrap") #0
   ret double %result
 }
 
 ; Verify that nearbyint(10.5) is folded to 10.0 when the rounding mode is 'towardzero'.
 define double @nearbyint_03() #0 {
 ; CHECK-LABEL: @nearbyint_03(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.nearbyint.f64(double 1.050000e+01, metadata !"round.towardzero", metadata !"fpexcept.strict") #[[ATTR0]]
 ; CHECK-NEXT:    ret double 1.000000e+01
 ;
 entry:
   %result = call double @llvm.experimental.constrained.nearbyint.f64(double 1.050000e+01, metadata !"round.towardzero", metadata !"fpexcept.strict") #0
   ret double %result
 }
 
 ; Verify that nearbyint(10.5) is folded to 10.0 when the rounding mode is 'tonearest'.
 define double @nearbyint_04() #0 {
 ; CHECK-LABEL: @nearbyint_04(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.nearbyint.f64(double 1.050000e+01, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 ; CHECK-NEXT:    ret double 1.000000e+01
 ;
 entry:
   %result = call double @llvm.experimental.constrained.nearbyint.f64(double 1.050000e+01, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
   ret double %result
 }
 
 ; Verify that nearbyint(10.5) is NOT folded if the rounding mode is 'dynamic'.
 define double @nearbyint_05() #0 {
 ; CHECK-LABEL: @nearbyint_05(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.nearbyint.f64(double 1.050000e+01, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.nearbyint.f64(double 1.050000e+01, metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0:[0-9]+]]
 ; CHECK-NEXT:    ret double [[RESULT]]
 ;
 entry:
   %result = call double @llvm.experimental.constrained.nearbyint.f64(double 1.050000e+01, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
   ret double %result
 }
 
 ; Verify that trunc(SNAN) is NOT folded if the exception behavior mode is not 'ignore'.
entry:
   %result = call double @llvm.experimental.constrained.trunc.f64(double 0x7ff4000000000000, metadata !"fpexcept.ignore") #0
   ret double %result
 }
 
 ; Verify that trunc(QNAN) is folded even if the exception behavior mode is not 'ignore'.
 define double @nonfinite_03() #0 {
 ; CHECK-LABEL: @nonfinite_03(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.trunc.f64(double 0x7FF8000000000000, metadata !"fpexcept.strict") #[[ATTR0]]
 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
 entry:
   %result = call double @llvm.experimental.constrained.trunc.f64(double 0x7ff8000000000000, metadata !"fpexcept.strict") #0
   ret double %result
 }
 
 ; Verify that trunc(+Inf) is folded even if the exception behavior mode is not 'ignore'.
 define double @nonfinite_04() #0 {
 ; CHECK-LABEL: @nonfinite_04(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.trunc.f64(double 0x7FF0000000000000, metadata !"fpexcept.strict") #[[ATTR0]]
 ; CHECK-NEXT:    ret double 0x7FF0000000000000
 ;
 entry:
   %result = call double @llvm.experimental.constrained.trunc.f64(double 0x7ff0000000000000, metadata !"fpexcept.strict") #0
   ret double %result
 }
 
 ; Verify that rint(10) is folded to 10.0 when the rounding mode is 'tonearest'.
 define double @rint_01() #0 {
 ; CHECK-LABEL: @rint_01(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RESULT:%.*]] = call double @llvm.experimental.constrained.rint.f64(double 1.000000e+01, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 ; CHECK-NEXT:    ret double 1.000000e+01
 ;
 entry:
   %result = call double @llvm.experimental.constrained.rint.f64(double 1.000000e+01, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
   ret double %result
 }
 
 ; Verify that rint(10.1) is NOT folded to 10.0 when the exception behavior is 'strict'.

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

 ; 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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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:    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 poison
 ;
   %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(

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

 ; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
 ;
   %ret = call nnan <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
   ret <2 x float> %ret
 }
 
 define float @fadd_nnan_x_n0_ebstrict(float %a) #0 {
 ; CHECK-LABEL: @fadd_nnan_x_n0_ebstrict(
-; CHECK-NEXT:    [[RET:%.*]] = call nnan float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float -0.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
-; CHECK-NEXT:    ret float [[A]]
+; CHECK-NEXT:    ret float [[A:%.*]]
 ;
   %ret = call nnan float @llvm.experimental.constrained.fadd.f32(float %a, float -0.0, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
   ret float %ret
 }
 
 define <2 x float> @fadd_vec_nnan_x_n0_ebstrict(<2 x float> %a) #0 {
 ; CHECK-LABEL: @fadd_vec_nnan_x_n0_ebstrict(
-; CHECK-NEXT:    [[RET:%.*]] = call nnan <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> <float -0.000000e+00, float -0.000000e+00>, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
-; CHECK-NEXT:    ret <2 x float> [[A]]
+; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
 ;
   %ret = call nnan <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
   ret <2 x float> %ret
 }
 
 ; Test with a fast math flag set but that flag is not "nnan".
 define float @fadd_ninf_x_n0_ebstrict(float %a) #0 {
 ; CHECK-LABEL: @fadd_ninf_x_n0_ebstrict(

 ; CHECK-NEXT:    ret <2 x float> [[ADD]]
 ;
   %add = call nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
   ret <2 x float> %add
 }
 
 define float @fold_fadd_nsz_nnan_x_0_ebstrict(float %a) #0 {
 ; CHECK-LABEL: @fold_fadd_nsz_nnan_x_0_ebstrict(
-; CHECK-NEXT:    [[ADD:%.*]] = call nnan nsz float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float 0.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
-; CHECK-NEXT:    ret float [[A]]
+; CHECK-NEXT:    ret float [[A:%.*]]
 ;
   %add = call nsz nnan float @llvm.experimental.constrained.fadd.f32(float %a, float 0.0, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
   ret float %add
 }
 
 define <2 x float> @fold_fadd_vec_nsz_nnan_x_0_ebstrict(<2 x float> %a) #0 {
 ; CHECK-LABEL: @fold_fadd_vec_nsz_nnan_x_0_ebstrict(
-; CHECK-NEXT:    [[ADD:%.*]] = call nnan nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
-; CHECK-NEXT:    ret <2 x float> [[A]]
+; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
 ;
   %add = call nsz nnan <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
   ret <2 x float> %add
 }
 
 define float @fold_fadd_nsz_0_x_defaultenv(float %a) #0 {
 ; CHECK-LABEL: @fold_fadd_nsz_0_x_defaultenv(
 ; CHECK-NEXT:    ret float [[A:%.*]]