[llvm] 28e3220 - ValueTracking: Teach canCreateUndefOrPoison about FP ops
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Mon Dec 12 20:22:40 PST 2022
Author: Matt Arsenault
Date: 2022-12-12T22:57:44-05:00
New Revision: 28e3220a5cb4194399c25a17281cc18f19b3fd3c
URL: https://github.com/llvm/llvm-project/commit/28e3220a5cb4194399c25a17281cc18f19b3fd3c
DIFF: https://github.com/llvm/llvm-project/commit/28e3220a5cb4194399c25a17281cc18f19b3fd3c.diff
LOG: ValueTracking: Teach canCreateUndefOrPoison about FP ops
Probably could replace the switch by marking the intrinsic definitions
with NoUndef<RetIndex>.
Added:
Modified:
llvm/lib/Analysis/ValueTracking.cpp
llvm/test/Transforms/InstCombine/freeze-fp-ops.ll
Removed:
################################################################################
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index a514bde912bf..584e64542d8f 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -5208,6 +5208,42 @@ static bool canCreateUndefOrPoison(const Operator *Op, bool PoisonOnly,
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;
}
}
@@ -5246,6 +5282,11 @@ static bool canCreateUndefOrPoison(const Operator *Op, bool PoisonOnly,
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
diff --git a/llvm/test/Transforms/InstCombine/freeze-fp-ops.ll b/llvm/test/Transforms/InstCombine/freeze-fp-ops.ll
index 6f05ba58e64e..4d4af0572ec4 100644
--- a/llvm/test/Transforms/InstCombine/freeze-fp-ops.ll
+++ b/llvm/test/Transforms/InstCombine/freeze-fp-ops.ll
@@ -116,9 +116,9 @@ define float @uitofp(i32 %arg) {
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
@@ -127,9 +127,9 @@ define float @freeze_fma(float %arg0, float noundef %arg1, float noundef %arg2)
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
@@ -138,9 +138,9 @@ define float @freeze_fmuladd(float %arg0, float noundef %arg1, float noundef %ar
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
@@ -160,9 +160,9 @@ define float @freeze_powi(float %arg0, i32 %arg1) {
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
@@ -171,9 +171,9 @@ define float @freeze_sin(float %arg) {
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
@@ -182,9 +182,9 @@ define float @freeze_cos(float %arg) {
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
@@ -193,9 +193,9 @@ define float @freeze_pow(float %arg0, float noundef %arg1) {
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
@@ -204,9 +204,9 @@ define float @freeze_log(float %arg) {
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
@@ -215,9 +215,9 @@ define float @freeze_log10(float %arg) {
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
@@ -226,9 +226,9 @@ define float @freeze_log2(float %arg) {
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
@@ -237,9 +237,9 @@ define float @freeze_exp(float %arg) {
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
@@ -248,9 +248,9 @@ define float @freeze_exp2(float %arg) {
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
@@ -259,9 +259,9 @@ define float @freeze_fabs(float %arg) {
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
@@ -270,9 +270,9 @@ define float @freeze_copysign(float %arg0, float noundef %arg1) {
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
@@ -281,9 +281,9 @@ define float @freeze_floor(float %arg) {
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
@@ -292,9 +292,9 @@ define float @freeze_ceil(float %arg) {
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
@@ -303,9 +303,9 @@ define float @freeze_trunc(float %arg) {
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
@@ -314,9 +314,9 @@ define float @freeze_rint(float %arg) {
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
@@ -325,9 +325,9 @@ define float @freeze_nearbyint(float %arg) {
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
@@ -336,9 +336,9 @@ define float @freeze_round(float %arg) {
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
@@ -347,9 +347,9 @@ define float @freeze_roundeven(float %arg) {
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
@@ -358,9 +358,9 @@ define float @freeze_canonicalize(float %arg) {
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
@@ -369,9 +369,9 @@ define float @freeze_arithmetic_fence(float %arg) {
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
@@ -380,9 +380,9 @@ define i32 @freeze_lround(float %arg) {
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
@@ -391,9 +391,9 @@ define i32 @freeze_llround(float %arg) {
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
@@ -402,9 +402,9 @@ define i32 @freeze_lrint(float %arg) {
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
@@ -453,9 +453,9 @@ define i32 @freeze_noundef_llrint(float %arg) {
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
@@ -464,9 +464,9 @@ define float @freeze_minnum(float %arg0, float noundef %arg1) {
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
@@ -475,9 +475,9 @@ define float @freeze_maxnum(float %arg0, float noundef %arg1) {
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
@@ -486,9 +486,9 @@ define float @freeze_minimum(float %arg0, float noundef %arg1) {
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
@@ -497,9 +497,9 @@ define float @freeze_maximum(float %arg0, float noundef %arg1) {
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
More information about the llvm-commits
mailing list