ValueTracking: Teach canCreateUndefOrPoison about FP ops

[arsenm]

Summary

Probably could replace the switch by marking the intrinsic definitions
with NoUndef<RetIndex>.

[aqjune]

llvm/lib/Analysis/ValueTracking.cpp

5250

Actually this part is slightly tricky, I think.
In C++ an unspecified value is a well-defined value meaning that its usage does not introduce UB unless the operation is supposed to do so.
This is different from undefined value or poison value because their usage may introduce UB.
Therefore, I think we can say that canCreateUndefOrPoison can return false for these ops.
I would like to cross-check my understanding with clang - @aaron.ballman May I ask whether my understanding is correct please?

[aaron.ballman]

llvm/lib/Analysis/ValueTracking.cpp

5250

I would like to cross-check my understanding with clang - @aaron.ballman May I ask whether my understanding is correct please?

You're correct.

C2x 7.12.9.5p2: The lrint and llrint functions round their argument to the nearest integer value, rounding according to the current rounding direction. If the rounded value is outside the range of the return type, the numeric result is unspecified and a domain error or range error may occur.

C2x 3.19.3p1: unspecified value -- valid value of the relevant type where this document imposes no requirements on which value is chosen in any instance.

C2x 3.4.4p1: unspecified behavior -- behavior, that results from the use of an unspecified value, or other behavior upon which this
document provides two or more possibilities and imposes no further requirements on which is chosen in any instance.

The only assumption the optimizer is allowed to make about an unspecified value is that the object holds an arbitrary value that may change on any given access.

[nlopes]

llvm/lib/Analysis/ValueTracking.cpp

5250

the numeric result is unspecified

Doesn't say unspecified value, only unspecified.
Are we sure that means the same?

Alive2 models this condition as poison FWIW, and I'm afraid LLVM might be taking advantage of that.

[aaron.ballman]

llvm/lib/Analysis/ValueTracking.cpp

5250

the numeric result is unspecified

Doesn't say unspecified value, only unspecified.
Are we sure that means the same?

Yes, they mean the same thing. Functions return values, this returned value is unspecified, so it's an unspecified value.

[arsenm]

Should I mention this doesn't produce poison in LangRef?

I also think it's extremely broken that we have both lround and llround (same with rint). Why isn't this one overloaded intrinsic? Why did it blindly copy the libm's i-don't-know-how-big-integers-are naming?

[arsenm]

In D139314#3971547, @arsenm wrote:

Should I mention this doesn't produce poison in LangRef?

https://reviews.llvm.org/D139349

[arsenm]

Change handling of lround/lrint

[arsenm]

ping

[aqjune]

I checked the updated instructions' LLVM LangRef documentation as well as cppreference.com description and they looked good to me

[arsenm]

28e3220a5cb4194399c25a17281cc18f19b3fd3c

llvm/lib/Analysis/ValueTracking.cpp

if (auto *II = dyn_cast<IntrinsicInst>(Op)) {
       case Intrinsic::fptoui_sat:
       case Intrinsic::fptosi_sat:
       case Intrinsic::sadd_with_overflow:
       case Intrinsic::ssub_with_overflow:
       case Intrinsic::smul_with_overflow:
       case Intrinsic::uadd_with_overflow:
       case Intrinsic::usub_with_overflow:
       case Intrinsic::umul_with_overflow:
+      case Intrinsic::fma:
+      case Intrinsic::fmuladd:
+      case Intrinsic::sqrt:
+      case Intrinsic::powi:
+      case Intrinsic::sin:
+      case Intrinsic::cos:
+      case Intrinsic::pow:
+      case Intrinsic::log:
+      case Intrinsic::log10:
+      case Intrinsic::log2:
+      case Intrinsic::exp:
+      case Intrinsic::exp2:
+      case Intrinsic::fabs:
+      case Intrinsic::copysign:
+      case Intrinsic::floor:
+      case Intrinsic::ceil:
+      case Intrinsic::trunc:
+      case Intrinsic::rint:
+      case Intrinsic::nearbyint:
+      case Intrinsic::round:
+      case Intrinsic::roundeven:
+      case Intrinsic::fptrunc_round:
+      case Intrinsic::canonicalize:
+      case Intrinsic::arithmetic_fence:
+      case Intrinsic::minnum:
+      case Intrinsic::maxnum:
+      case Intrinsic::minimum:
+      case Intrinsic::maximum:
+      case Intrinsic::is_fpclass:
+        return false;
+      case Intrinsic::lround:
+      case Intrinsic::llround:
+      case Intrinsic::lrint:
+      case Intrinsic::llrint:
+        // If the value doesn't fit an unspecified value is returned (but this
+        // is not poison).
         return false;
       }
     }
     [[fallthrough]];
   case Instruction::CallBr:
   case Instruction::Invoke: {
     const auto *CB = cast<CallBase>(Op);
     return !CB->hasRetAttr(Attribute::NoUndef);
   }
   case Instruction::InsertElement:
   case Instruction::ExtractElement: {
     // If index exceeds the length of the vector, it returns poison
     auto *VTy = cast<VectorType>(Op->getOperand(0)->getType());
     unsigned IdxOp = Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
static bool canCreateUndefOrPoison(const Operator *Op, bool PoisonOnly,
   case Instruction::Select:
   case Instruction::URem:
   case Instruction::SRem:
   case Instruction::ExtractValue:
   case Instruction::InsertValue:
   case Instruction::Freeze:
   case Instruction::ICmp:
   case Instruction::FCmp:
+  case Instruction::FAdd:
+  case Instruction::FSub:
+  case Instruction::FMul:
+  case Instruction::FDiv:
+  case Instruction::FRem:
     return false;
   case Instruction::GetElementPtr:
     // inbounds is handled above
     // TODO: what about inrange on constexpr?
     return false;
   default: {
     const auto *CE = dyn_cast<ConstantExpr>(Op);
     if (isa<CastInst>(Op) || (CE && CE->isCast()))

llvm/test/Transforms/InstCombine/freeze-fp-ops.ll

 ;
   %op = uitofp i32 %arg to float
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_fma(float %arg0, float noundef %arg1, float noundef %arg2) {
 ; CHECK-LABEL: @freeze_fma(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.fma.f32(float [[ARG0:%.*]], float noundef [[ARG1:%.*]], float noundef [[ARG2:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze float [[ARG0:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.fma.f32(float [[ARG0_FR]], float noundef [[ARG1:%.*]], float noundef [[ARG2:%.*]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.fma.f32(float %arg0, float noundef %arg1, float noundef %arg2)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_fmuladd(float %arg0, float noundef %arg1, float noundef %arg2) {
 ; CHECK-LABEL: @freeze_fmuladd(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.fmuladd.f32(float [[ARG0:%.*]], float noundef [[ARG1:%.*]], float noundef [[ARG2:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze float [[ARG0:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.fmuladd.f32(float [[ARG0_FR]], float noundef [[ARG1:%.*]], float noundef [[ARG2:%.*]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.fmuladd.f32(float %arg0, float noundef %arg1, float noundef %arg2)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_sqrt(float %arg) {
 ; CHECK-LABEL: @freeze_sqrt(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.sqrt.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.sqrt.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.sqrt.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_powi(float %arg0, i32 %arg1) {
 ; CHECK-LABEL: @freeze_powi(
 ; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.powi.f32.i32(float [[ARG0:%.*]], i32 [[ARG1:%.*]])
 ; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
 ; CHECK-NEXT:    ret float [[FREEZE]]
 ;
   %op = call float @llvm.powi.f32.i32(float %arg0, i32 %arg1)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_sin(float %arg) {
 ; CHECK-LABEL: @freeze_sin(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.sin.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.sin.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.sin.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_cos(float %arg) {
 ; CHECK-LABEL: @freeze_cos(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.cos.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.cos.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.cos.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_pow(float %arg0, float noundef %arg1) {
 ; CHECK-LABEL: @freeze_pow(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.pow.f32(float [[ARG0:%.*]], float noundef [[ARG1:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze float [[ARG0:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.pow.f32(float [[ARG0_FR]], float noundef [[ARG1:%.*]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.pow.f32(float %arg0, float noundef %arg1)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_log(float %arg) {
 ; CHECK-LABEL: @freeze_log(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.log.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.log.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.log.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_log10(float %arg) {
 ; CHECK-LABEL: @freeze_log10(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.log10.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.log10.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.log10.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_log2(float %arg) {
 ; CHECK-LABEL: @freeze_log2(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.log2.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.log2.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.log2.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_exp(float %arg) {
 ; CHECK-LABEL: @freeze_exp(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.exp.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.exp.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.exp.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_exp2(float %arg) {
 ; CHECK-LABEL: @freeze_exp2(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.exp2.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.exp2.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.exp2.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_fabs(float %arg) {
 ; CHECK-LABEL: @freeze_fabs(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.fabs.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.fabs.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.fabs.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_copysign(float %arg0, float noundef %arg1) {
 ; CHECK-LABEL: @freeze_copysign(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.copysign.f32(float [[ARG0:%.*]], float noundef [[ARG1:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze float [[ARG0:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.copysign.f32(float [[ARG0_FR]], float noundef [[ARG1:%.*]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.copysign.f32(float %arg0, float noundef %arg1)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_floor(float %arg) {
 ; CHECK-LABEL: @freeze_floor(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.floor.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.floor.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.floor.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_ceil(float %arg) {
 ; CHECK-LABEL: @freeze_ceil(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.ceil.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.ceil.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.ceil.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_trunc(float %arg) {
 ; CHECK-LABEL: @freeze_trunc(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.trunc.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.trunc.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.trunc.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_rint(float %arg) {
 ; CHECK-LABEL: @freeze_rint(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.rint.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.rint.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.rint.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_nearbyint(float %arg) {
 ; CHECK-LABEL: @freeze_nearbyint(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.nearbyint.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.nearbyint.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.nearbyint.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_round(float %arg) {
 ; CHECK-LABEL: @freeze_round(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.round.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.round.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.round.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_roundeven(float %arg) {
 ; CHECK-LABEL: @freeze_roundeven(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.roundeven.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.roundeven.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.roundeven.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_canonicalize(float %arg) {
 ; CHECK-LABEL: @freeze_canonicalize(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.canonicalize.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.canonicalize.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.canonicalize.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_arithmetic_fence(float %arg) {
 ; CHECK-LABEL: @freeze_arithmetic_fence(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.arithmetic.fence.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.arithmetic.fence.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.arithmetic.fence.f32(float %arg)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define i32 @freeze_lround(float %arg) {
 ; CHECK-LABEL: @freeze_lround(
-; CHECK-NEXT:    [[OP:%.*]] = call i32 @llvm.lround.i32.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze i32 [[OP]]
-; CHECK-NEXT:    ret i32 [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call i32 @llvm.lround.i32.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret i32 [[OP]]
 ;
   %op = call i32 @llvm.lround.i32.f32(float %arg)
   %freeze = freeze i32 %op
   ret i32 %freeze
 }
 
 define i32 @freeze_llround(float %arg) {
 ; CHECK-LABEL: @freeze_llround(
-; CHECK-NEXT:    [[OP:%.*]] = call i32 @llvm.llround.i32.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze i32 [[OP]]
-; CHECK-NEXT:    ret i32 [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call i32 @llvm.llround.i32.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret i32 [[OP]]
 ;
   %op = call i32 @llvm.llround.i32.f32(float %arg)
   %freeze = freeze i32 %op
   ret i32 %freeze
 }
 
 define i32 @freeze_lrint(float %arg) {
 ; CHECK-LABEL: @freeze_lrint(
-; CHECK-NEXT:    [[OP:%.*]] = call i32 @llvm.lrint.i32.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze i32 [[OP]]
-; CHECK-NEXT:    ret i32 [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call i32 @llvm.lrint.i32.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret i32 [[OP]]
 ;
   %op = call i32 @llvm.lrint.i32.f32(float %arg)
   %freeze = freeze i32 %op
   ret i32 %freeze
 }
 
 define i32 @freeze_llrint(float %arg) {
 ; CHECK-LABEL: @freeze_llrint(
-; CHECK-NEXT:    [[OP:%.*]] = call i32 @llvm.llrint.i32.f32(float [[ARG:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze i32 [[OP]]
-; CHECK-NEXT:    ret i32 [[FREEZE]]
+; CHECK-NEXT:    [[ARG_FR:%.*]] = freeze float [[ARG:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call i32 @llvm.llrint.i32.f32(float [[ARG_FR]])
+; CHECK-NEXT:    ret i32 [[OP]]
 ;
   %op = call i32 @llvm.llrint.i32.f32(float %arg)
   %freeze = freeze i32 %op
   ret i32 %freeze
 }
 
 define i32 @freeze_noundef_lround(float %arg) {
 ; CHECK-LABEL: @freeze_noundef_lround(

 ;
   %op = call noundef i32 @llvm.llrint.i32.f32(float %arg)
   %freeze = freeze i32 %op
   ret i32 %freeze
 }
 
 define float @freeze_minnum(float %arg0, float noundef %arg1) {
 ; CHECK-LABEL: @freeze_minnum(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.minnum.f32(float [[ARG0:%.*]], float noundef [[ARG1:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze float [[ARG0:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.minnum.f32(float [[ARG0_FR]], float noundef [[ARG1:%.*]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.minnum.f32(float %arg0, float noundef %arg1)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_maxnum(float %arg0, float noundef %arg1) {
 ; CHECK-LABEL: @freeze_maxnum(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.maxnum.f32(float [[ARG0:%.*]], float noundef [[ARG1:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze float [[ARG0:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.maxnum.f32(float [[ARG0_FR]], float noundef [[ARG1:%.*]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.maxnum.f32(float %arg0, float noundef %arg1)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_minimum(float %arg0, float noundef %arg1) {
 ; CHECK-LABEL: @freeze_minimum(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.minimum.f32(float [[ARG0:%.*]], float noundef [[ARG1:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze float [[ARG0:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.minimum.f32(float [[ARG0_FR]], float noundef [[ARG1:%.*]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.minimum.f32(float %arg0, float noundef %arg1)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define float @freeze_maximum(float %arg0, float noundef %arg1) {
 ; CHECK-LABEL: @freeze_maximum(
-; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.maximum.f32(float [[ARG0:%.*]], float noundef [[ARG1:%.*]])
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
-; CHECK-NEXT:    ret float [[FREEZE]]
+; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze float [[ARG0:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.maximum.f32(float [[ARG0_FR]], float noundef [[ARG1:%.*]])
+; CHECK-NEXT:    ret float [[OP]]
 ;
   %op = call float @llvm.maximum.f32(float %arg0, float noundef %arg1)
   %freeze = freeze float %op
   ret float %freeze
 }
 
 define i1 @freeze_isfpclass(float %arg0) {
 ; CHECK-LABEL: @freeze_isfpclass(
-; CHECK-NEXT:    [[OP:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG0:%.*]], i32 27)
-; CHECK-NEXT:    [[FREEZE:%.*]] = freeze i1 [[OP]]
-; CHECK-NEXT:    ret i1 [[FREEZE]]
+; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze float [[ARG0:%.*]]
+; CHECK-NEXT:    [[OP:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG0_FR]], i32 27)
+; CHECK-NEXT:    ret i1 [[OP]]
 ;
   %op = call i1 @llvm.is.fpclass.f32(float %arg0, i32 27)
   %freeze = freeze i1 %op
   ret i1 %freeze
 }
 
 define float @freeze_fptrunc_round(double %arg0) {
 ; CHECK-LABEL: @freeze_fptrunc_round(