[llvm] 841a0ed - ConstantFolding: Constant fold some canonicalizes
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Fri Nov 18 10:35:25 PST 2022
Author: Matt Arsenault
Date: 2022-11-18T10:35:19-08:00
New Revision: 841a0edd030d4cce2e6b764996d3372773d0089b
URL: https://github.com/llvm/llvm-project/commit/841a0edd030d4cce2e6b764996d3372773d0089b
DIFF: https://github.com/llvm/llvm-project/commit/841a0edd030d4cce2e6b764996d3372773d0089b.diff
LOG: ConstantFolding: Constant fold some canonicalizes
+/-0 is obviously foldable. Other non-special, non-subnormal
values are also probably OK. For denormal values, check
the calling function's denormal mode. For now, don't fold
denormals to the input for IEEE mode because as far as I know
the langref is still pretending LLVM's float isn't IEEE.
Also folds undef to 0, although NaN may make more sense. Skips
folding nans and infinities, although it should be OK to fold those
in a future change.
Added:
Modified:
llvm/include/llvm/IR/Type.h
llvm/lib/Analysis/ConstantFolding.cpp
llvm/test/CodeGen/AMDGPU/fcanonicalize.f16.ll
llvm/test/CodeGen/AMDGPU/fcanonicalize.ll
llvm/test/Transforms/InstSimplify/canonicalize.ll
Removed:
################################################################################
diff --git a/llvm/include/llvm/IR/Type.h b/llvm/include/llvm/IR/Type.h
index e6d351babb563..a1848c812c3de 100644
--- a/llvm/include/llvm/IR/Type.h
+++ b/llvm/include/llvm/IR/Type.h
@@ -164,11 +164,25 @@ class Type {
/// Return true if this is powerpc long double.
bool isPPC_FP128Ty() const { return getTypeID() == PPC_FP128TyID; }
- /// Return true if this is one of the six floating-point types
+ /// Return true if this is a well-behaved IEEE-like type, which has a IEEE
+ /// compatible layout as defined by isIEEE(), and does not have unnormal
+ /// values
+ bool isIEEELikeFPTy() const {
+ switch (getTypeID()) {
+ case DoubleTyID:
+ case FloatTyID:
+ case HalfTyID:
+ case BFloatTyID:
+ case FP128TyID:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ /// Return true if this is one of the floating-point types
bool isFloatingPointTy() const {
- return getTypeID() == HalfTyID || getTypeID() == BFloatTyID ||
- getTypeID() == FloatTyID || getTypeID() == DoubleTyID ||
- getTypeID() == X86_FP80TyID || getTypeID() == FP128TyID ||
+ return isIEEELikeFPTy() || getTypeID() == X86_FP80TyID ||
getTypeID() == PPC_FP128TyID;
}
diff --git a/llvm/lib/Analysis/ConstantFolding.cpp b/llvm/lib/Analysis/ConstantFolding.cpp
index df1a9bfa3da27..690545c0a9d33 100644
--- a/llvm/lib/Analysis/ConstantFolding.cpp
+++ b/llvm/lib/Analysis/ConstantFolding.cpp
@@ -1626,6 +1626,7 @@ bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
case Intrinsic::trunc:
case Intrinsic::nearbyint:
case Intrinsic::rint:
+ case Intrinsic::canonicalize:
// Constrained intrinsics can be folded if FP environment is known
// to compiler.
case Intrinsic::experimental_constrained_fma:
@@ -1941,6 +1942,39 @@ getEvaluationRoundingMode(const ConstrainedFPIntrinsic *CI) {
return *ORM;
}
+/// Try to constant fold llvm.canonicalize for the given caller and value.
+static Constant *constantFoldCanonicalize(const Type *Ty, const CallBase *CI,
+ const APFloat &Src) {
+ // Zero, positive and negative, is always OK to fold.
+ if (Src.isZero())
+ return ConstantFP::get(CI->getContext(), Src);
+
+ if (!Ty->isIEEELikeFPTy())
+ return nullptr;
+
+ // Zero is always canonical and the sign must be preserved.
+ //
+ // Denorms and nans may have special encodings, but it should be OK to fold a
+ // totally average number.
+ if (Src.isNormal() || Src.isInfinity())
+ return ConstantFP::get(CI->getContext(), Src);
+
+ if (Src.isDenormal()) {
+ DenormalMode DenormMode =
+ CI->getFunction()->getDenormalMode(Src.getSemantics());
+ if (DenormMode == DenormalMode::getIEEE())
+ return nullptr;
+
+ bool IsPositive = !Src.isNegative() ||
+ DenormMode.Input == DenormalMode::PositiveZero ||
+ DenormMode.Output == DenormalMode::PositiveZero;
+ return ConstantFP::get(CI->getContext(),
+ APFloat::getZero(Src.getSemantics(), !IsPositive));
+ }
+
+ return nullptr;
+}
+
static Constant *ConstantFoldScalarCall1(StringRef Name,
Intrinsic::ID IntrinsicID,
Type *Ty,
@@ -1957,6 +1991,13 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
return ConstantInt::getTrue(Ty->getContext());
return nullptr;
}
+
+ if (isa<PoisonValue>(Operands[0])) {
+ // TODO: All of these operations should probably propagate poison.
+ if (IntrinsicID == Intrinsic::canonicalize)
+ return PoisonValue::get(Ty);
+ }
+
if (isa<UndefValue>(Operands[0])) {
// cosine(arg) is between -1 and 1. cosine(invalid arg) is NaN.
// ctpop() is between 0 and bitwidth, pick 0 for undef.
@@ -1964,7 +2005,8 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
if (IntrinsicID == Intrinsic::cos ||
IntrinsicID == Intrinsic::ctpop ||
IntrinsicID == Intrinsic::fptoui_sat ||
- IntrinsicID == Intrinsic::fptosi_sat)
+ IntrinsicID == Intrinsic::fptosi_sat ||
+ IntrinsicID == Intrinsic::canonicalize)
return Constant::getNullValue(Ty);
if (IntrinsicID == Intrinsic::bswap ||
IntrinsicID == Intrinsic::bitreverse ||
@@ -2032,6 +2074,9 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
return ConstantInt::get(Ty, Int);
}
+ if (IntrinsicID == Intrinsic::canonicalize)
+ return constantFoldCanonicalize(Ty, Call, U);
+
if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy())
return nullptr;
diff --git a/llvm/test/CodeGen/AMDGPU/fcanonicalize.f16.ll b/llvm/test/CodeGen/AMDGPU/fcanonicalize.f16.ll
index 42517fca8307b..b1cd8f32ab71c 100644
--- a/llvm/test/CodeGen/AMDGPU/fcanonicalize.f16.ll
+++ b/llvm/test/CodeGen/AMDGPU/fcanonicalize.f16.ll
@@ -15,7 +15,7 @@ define amdgpu_kernel void @test_fold_canonicalize_undef_value_f16(half addrspace
; VI-LABEL: test_fold_canonicalize_undef_value_f16:
; VI: ; %bb.0:
; VI-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0x24
-; VI-NEXT: v_mov_b32_e32 v2, 0x7e00
+; VI-NEXT: v_mov_b32_e32 v2, 0
; VI-NEXT: s_waitcnt lgkmcnt(0)
; VI-NEXT: v_mov_b32_e32 v0, s0
; VI-NEXT: v_mov_b32_e32 v1, s1
@@ -26,9 +26,8 @@ define amdgpu_kernel void @test_fold_canonicalize_undef_value_f16(half addrspace
; GFX9: ; %bb.0:
; GFX9-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0x24
; GFX9-NEXT: v_mov_b32_e32 v0, 0
-; GFX9-NEXT: v_mov_b32_e32 v1, 0x7e00
; GFX9-NEXT: s_waitcnt lgkmcnt(0)
-; GFX9-NEXT: global_store_short v0, v1, s[0:1]
+; GFX9-NEXT: global_store_short v0, v0, s[0:1]
; GFX9-NEXT: s_endpgm
;
; CI-LABEL: test_fold_canonicalize_undef_value_f16:
@@ -36,7 +35,7 @@ define amdgpu_kernel void @test_fold_canonicalize_undef_value_f16(half addrspace
; CI-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0x9
; CI-NEXT: s_mov_b32 s3, 0xf000
; CI-NEXT: s_mov_b32 s2, -1
-; CI-NEXT: v_mov_b32_e32 v0, 0x7e00
+; CI-NEXT: v_mov_b32_e32 v0, 0
; CI-NEXT: s_waitcnt lgkmcnt(0)
; CI-NEXT: buffer_store_short v0, off, s[0:3], 0
; CI-NEXT: s_endpgm
@@ -1847,7 +1846,7 @@ define amdgpu_kernel void @s_test_canonicalize_undef_v2f16(<2 x half> addrspace(
; VI-LABEL: s_test_canonicalize_undef_v2f16:
; VI: ; %bb.0:
; VI-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0x24
-; VI-NEXT: v_mov_b32_e32 v2, 0x7e007e00
+; VI-NEXT: v_mov_b32_e32 v2, 0
; VI-NEXT: s_waitcnt lgkmcnt(0)
; VI-NEXT: v_mov_b32_e32 v0, s0
; VI-NEXT: v_mov_b32_e32 v1, s1
@@ -1858,9 +1857,8 @@ define amdgpu_kernel void @s_test_canonicalize_undef_v2f16(<2 x half> addrspace(
; GFX9: ; %bb.0:
; GFX9-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0x24
; GFX9-NEXT: v_mov_b32_e32 v0, 0
-; GFX9-NEXT: v_mov_b32_e32 v1, 0x7e007e00
; GFX9-NEXT: s_waitcnt lgkmcnt(0)
-; GFX9-NEXT: global_store_dword v0, v1, s[0:1]
+; GFX9-NEXT: global_store_dword v0, v0, s[0:1]
; GFX9-NEXT: s_endpgm
;
; CI-LABEL: s_test_canonicalize_undef_v2f16:
@@ -1868,7 +1866,7 @@ define amdgpu_kernel void @s_test_canonicalize_undef_v2f16(<2 x half> addrspace(
; CI-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0x9
; CI-NEXT: s_mov_b32 s3, 0xf000
; CI-NEXT: s_mov_b32 s2, -1
-; CI-NEXT: v_mov_b32_e32 v0, 0x7e007e00
+; CI-NEXT: v_mov_b32_e32 v0, 0
; CI-NEXT: s_waitcnt lgkmcnt(0)
; CI-NEXT: buffer_store_dword v0, off, s[0:3], 0
; CI-NEXT: s_endpgm
@@ -1934,19 +1932,19 @@ define <2 x half> @v_test_canonicalize_undef_lo_imm_hi_v2f16() #1 {
; VI-LABEL: v_test_canonicalize_undef_lo_imm_hi_v2f16:
; VI: ; %bb.0:
; VI-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; VI-NEXT: v_mov_b32_e32 v0, 0x3c003c00
+; VI-NEXT: v_bfrev_b32_e32 v0, 60
; VI-NEXT: s_setpc_b64 s[30:31]
;
; GFX9-LABEL: v_test_canonicalize_undef_lo_imm_hi_v2f16:
; GFX9: ; %bb.0:
; GFX9-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX9-NEXT: v_mov_b32_e32 v0, 0x3c003c00
+; GFX9-NEXT: v_bfrev_b32_e32 v0, 60
; GFX9-NEXT: s_setpc_b64 s[30:31]
;
; CI-LABEL: v_test_canonicalize_undef_lo_imm_hi_v2f16:
; CI: ; %bb.0:
; CI-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; CI-NEXT: v_mov_b32_e32 v0, 0x7fc00000
+; CI-NEXT: v_mov_b32_e32 v0, 0
; CI-NEXT: v_mov_b32_e32 v1, 1.0
; CI-NEXT: s_setpc_b64 s[30:31]
%vec = insertelement <2 x half> undef, half 1.0, i32 1
@@ -1958,20 +1956,20 @@ define <2 x half> @v_test_canonicalize_imm_lo_undef_hi_v2f16() #1 {
; VI-LABEL: v_test_canonicalize_imm_lo_undef_hi_v2f16:
; VI: ; %bb.0:
; VI-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; VI-NEXT: v_mov_b32_e32 v0, 0x3c003c00
+; VI-NEXT: v_mov_b32_e32 v0, 0x3c00
; VI-NEXT: s_setpc_b64 s[30:31]
;
; GFX9-LABEL: v_test_canonicalize_imm_lo_undef_hi_v2f16:
; GFX9: ; %bb.0:
; GFX9-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX9-NEXT: v_mov_b32_e32 v0, 0x3c003c00
+; GFX9-NEXT: v_mov_b32_e32 v0, 0x3c00
; GFX9-NEXT: s_setpc_b64 s[30:31]
;
; CI-LABEL: v_test_canonicalize_imm_lo_undef_hi_v2f16:
; CI: ; %bb.0:
; CI-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
; CI-NEXT: v_mov_b32_e32 v0, 1.0
-; CI-NEXT: v_mov_b32_e32 v1, 0x7fc00000
+; CI-NEXT: v_mov_b32_e32 v1, 0
; CI-NEXT: s_setpc_b64 s[30:31]
%vec = insertelement <2 x half> undef, half 1.0, i32 0
%canonicalized = call <2 x half> @llvm.canonicalize.v2f16(<2 x half> %vec)
@@ -1982,19 +1980,19 @@ define <2 x half> @v_test_canonicalize_undef_lo_k_hi_v2f16() #1 {
; VI-LABEL: v_test_canonicalize_undef_lo_k_hi_v2f16:
; VI: ; %bb.0:
; VI-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; VI-NEXT: v_mov_b32_e32 v0, 0x4c004c00
+; VI-NEXT: v_bfrev_b32_e32 v0, 50
; VI-NEXT: s_setpc_b64 s[30:31]
;
; GFX9-LABEL: v_test_canonicalize_undef_lo_k_hi_v2f16:
; GFX9: ; %bb.0:
; GFX9-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX9-NEXT: v_mov_b32_e32 v0, 0x4c004c00
+; GFX9-NEXT: v_bfrev_b32_e32 v0, 50
; GFX9-NEXT: s_setpc_b64 s[30:31]
;
; CI-LABEL: v_test_canonicalize_undef_lo_k_hi_v2f16:
; CI: ; %bb.0:
; CI-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; CI-NEXT: v_mov_b32_e32 v0, 0x7fc00000
+; CI-NEXT: v_mov_b32_e32 v0, 0
; CI-NEXT: v_mov_b32_e32 v1, 0x41800000
; CI-NEXT: s_setpc_b64 s[30:31]
%vec = insertelement <2 x half> undef, half 16.0, i32 1
@@ -2006,20 +2004,20 @@ define <2 x half> @v_test_canonicalize_k_lo_undef_hi_v2f16() #1 {
; VI-LABEL: v_test_canonicalize_k_lo_undef_hi_v2f16:
; VI: ; %bb.0:
; VI-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; VI-NEXT: v_mov_b32_e32 v0, 0x4c004c00
+; VI-NEXT: v_mov_b32_e32 v0, 0x4c00
; VI-NEXT: s_setpc_b64 s[30:31]
;
; GFX9-LABEL: v_test_canonicalize_k_lo_undef_hi_v2f16:
; GFX9: ; %bb.0:
; GFX9-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX9-NEXT: v_mov_b32_e32 v0, 0x4c004c00
+; GFX9-NEXT: v_mov_b32_e32 v0, 0x4c00
; GFX9-NEXT: s_setpc_b64 s[30:31]
;
; CI-LABEL: v_test_canonicalize_k_lo_undef_hi_v2f16:
; CI: ; %bb.0:
; CI-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
; CI-NEXT: v_mov_b32_e32 v0, 0x41800000
-; CI-NEXT: v_mov_b32_e32 v1, 0x7fc00000
+; CI-NEXT: v_mov_b32_e32 v1, 0
; CI-NEXT: s_setpc_b64 s[30:31]
%vec = insertelement <2 x half> undef, half 16.0, i32 0
%canonicalized = call <2 x half> @llvm.canonicalize.v2f16(<2 x half> %vec)
@@ -2086,7 +2084,7 @@ define amdgpu_kernel void @s_test_canonicalize_undef_v4f16(<4 x half> addrspace(
; VI-LABEL: s_test_canonicalize_undef_v4f16:
; VI: ; %bb.0:
; VI-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0x24
-; VI-NEXT: v_mov_b32_e32 v0, 0x7e007e00
+; VI-NEXT: v_mov_b32_e32 v0, 0
; VI-NEXT: v_mov_b32_e32 v1, v0
; VI-NEXT: s_waitcnt lgkmcnt(0)
; VI-NEXT: v_mov_b32_e32 v3, s1
@@ -2097,17 +2095,16 @@ define amdgpu_kernel void @s_test_canonicalize_undef_v4f16(<4 x half> addrspace(
; GFX9-LABEL: s_test_canonicalize_undef_v4f16:
; GFX9: ; %bb.0:
; GFX9-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0x24
-; GFX9-NEXT: v_mov_b32_e32 v0, 0x7e007e00
-; GFX9-NEXT: v_mov_b32_e32 v2, 0
+; GFX9-NEXT: v_mov_b32_e32 v0, 0
; GFX9-NEXT: v_mov_b32_e32 v1, v0
; GFX9-NEXT: s_waitcnt lgkmcnt(0)
-; GFX9-NEXT: global_store_dwordx2 v2, v[0:1], s[0:1]
+; GFX9-NEXT: global_store_dwordx2 v0, v[0:1], s[0:1]
; GFX9-NEXT: s_endpgm
;
; CI-LABEL: s_test_canonicalize_undef_v4f16:
; CI: ; %bb.0:
; CI-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0x9
-; CI-NEXT: v_mov_b32_e32 v0, 0x7e007e00
+; CI-NEXT: v_mov_b32_e32 v0, 0
; CI-NEXT: s_mov_b32 s3, 0xf000
; CI-NEXT: s_mov_b32 s2, -1
; CI-NEXT: v_mov_b32_e32 v1, v0
diff --git a/llvm/test/CodeGen/AMDGPU/fcanonicalize.ll b/llvm/test/CodeGen/AMDGPU/fcanonicalize.ll
index 8c8d887c3beb9..1bb05a1cedc6e 100644
--- a/llvm/test/CodeGen/AMDGPU/fcanonicalize.ll
+++ b/llvm/test/CodeGen/AMDGPU/fcanonicalize.ll
@@ -76,7 +76,7 @@ define amdgpu_kernel void @v_test_canonicalize_fneg_var_f32(float addrspace(1)*
}
; GCN-LABEL: {{^}}test_fold_canonicalize_undef_f32:
-; GCN: v_mov_b32_e32 [[REG:v[0-9]+]], 0x7fc00000{{$}}
+; GCN: v_mov_b32_e32 [[REG:v[0-9]+]], 0{{$}}
; GCN: {{flat|global}}_store_dword v{{.+}}, [[REG]]
define amdgpu_kernel void @test_fold_canonicalize_undef_f32(float addrspace(1)* %out) #1 {
%canonicalized = call float @llvm.canonicalize.f32(float undef)
diff --git a/llvm/test/Transforms/InstSimplify/canonicalize.ll b/llvm/test/Transforms/InstSimplify/canonicalize.ll
index 7f8bd4f8d4095..2c7c402ec41a7 100644
--- a/llvm/test/Transforms/InstSimplify/canonicalize.ll
+++ b/llvm/test/Transforms/InstSimplify/canonicalize.ll
@@ -3,8 +3,7 @@
define float @canonicalize_zero() {
; CHECK-LABEL: @canonicalize_zero(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0.000000e+00)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float 0.0)
ret float %ret
@@ -12,8 +11,7 @@ define float @canonicalize_zero() {
define float @canonicalize_negzero() {
; CHECK-LABEL: @canonicalize_negzero(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float -0.000000e+00)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float -0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float -0.0)
ret float %ret
@@ -21,8 +19,7 @@ define float @canonicalize_negzero() {
define <2 x float> @canonicalize_zero_vector() {
; CHECK-LABEL: @canonicalize_zero_vector(
-; CHECK-NEXT: [[RET:%.*]] = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> zeroinitializer)
-; CHECK-NEXT: ret <2 x float> [[RET]]
+; CHECK-NEXT: ret <2 x float> zeroinitializer
;
%ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> zeroinitializer)
ret <2 x float> %ret
@@ -30,8 +27,7 @@ define <2 x float> @canonicalize_zero_vector() {
define <2 x float> @canonicalize_negzero_vector() {
; CHECK-LABEL: @canonicalize_negzero_vector(
-; CHECK-NEXT: [[RET:%.*]] = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float -0.000000e+00, float -0.000000e+00>)
-; CHECK-NEXT: ret <2 x float> [[RET]]
+; CHECK-NEXT: ret <2 x float> <float -0.000000e+00, float -0.000000e+00>
;
%ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float -0.0, float -0.0>)
ret <2 x float> %ret
@@ -39,8 +35,7 @@ define <2 x float> @canonicalize_negzero_vector() {
define <2 x float> @canonicalize_negzero_vector_partialundef() {
; CHECK-LABEL: @canonicalize_negzero_vector_partialundef(
-; CHECK-NEXT: [[RET:%.*]] = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float -0.000000e+00, float undef>)
-; CHECK-NEXT: ret <2 x float> [[RET]]
+; CHECK-NEXT: ret <2 x float> <float -0.000000e+00, float 0.000000e+00>
;
%ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float -0.0, float undef>)
ret <2 x float> %ret
@@ -48,8 +43,7 @@ define <2 x float> @canonicalize_negzero_vector_partialundef() {
define float @canonicalize_undef() {
; CHECK-LABEL: @canonicalize_undef(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float undef)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float undef)
ret float %ret
@@ -57,8 +51,7 @@ define float @canonicalize_undef() {
define <2 x float> @canonicalize_undef_vector() {
; CHECK-LABEL: @canonicalize_undef_vector(
-; CHECK-NEXT: [[RET:%.*]] = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> undef)
-; CHECK-NEXT: ret <2 x float> [[RET]]
+; CHECK-NEXT: ret <2 x float> zeroinitializer
;
%ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> undef)
ret <2 x float> %ret
@@ -66,8 +59,7 @@ define <2 x float> @canonicalize_undef_vector() {
define float @canonicalize_poison() {
; CHECK-LABEL: @canonicalize_poison(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float poison)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float poison
;
%ret = call float @llvm.canonicalize.f32(float poison)
ret float %ret
@@ -75,8 +67,7 @@ define float @canonicalize_poison() {
define <2 x float> @canonicalize_poison_vector() {
; CHECK-LABEL: @canonicalize_poison_vector(
-; CHECK-NEXT: [[RET:%.*]] = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> poison)
-; CHECK-NEXT: ret <2 x float> [[RET]]
+; CHECK-NEXT: ret <2 x float> poison
;
%ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> poison)
ret <2 x float> %ret
@@ -93,8 +84,7 @@ define float @canonicalize_denorm() {
define float @canonicalize_pos_denorm_preserve_sign_output() "denormal-fp-math"="preserve-sign,ieee" {
; CHECK-LABEL: @canonicalize_pos_denorm_preserve_sign_output(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0x380FFFFFC0000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float bitcast (i32 8388607 to float))
ret float %ret
@@ -102,8 +92,7 @@ define float @canonicalize_pos_denorm_preserve_sign_output() "denormal-fp-math"=
define float @canonicalize_pos_denorm_preserve_sign_input() "denormal-fp-math"="ieee,preserve-sign" {
; CHECK-LABEL: @canonicalize_pos_denorm_preserve_sign_input(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0x380FFFFFC0000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float bitcast (i32 8388607 to float))
ret float %ret
@@ -111,8 +100,7 @@ define float @canonicalize_pos_denorm_preserve_sign_input() "denormal-fp-math"="
define float @canonicalize_neg_denorm_preserve_sign_output() "denormal-fp-math"="preserve-sign,ieee" {
; CHECK-LABEL: @canonicalize_neg_denorm_preserve_sign_output(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0xB80FFFFFC0000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float -0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float bitcast (i32 -2139095041 to float))
ret float %ret
@@ -120,8 +108,7 @@ define float @canonicalize_neg_denorm_preserve_sign_output() "denormal-fp-math"=
define float @canonicalize_neg_denorm_preserve_sign_input() "denormal-fp-math"="ieee,preserve-sign" {
; CHECK-LABEL: @canonicalize_neg_denorm_preserve_sign_input(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0xB80FFFFFC0000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float -0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float bitcast (i32 -2139095041 to float))
ret float %ret
@@ -129,8 +116,7 @@ define float @canonicalize_neg_denorm_preserve_sign_input() "denormal-fp-math"="
define float @canonicalize_pos_denorm_positive_zero_output() "denormal-fp-math"="positive-zero,ieee" {
; CHECK-LABEL: @canonicalize_pos_denorm_positive_zero_output(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0x380FFFFFC0000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float bitcast (i32 8388607 to float))
ret float %ret
@@ -138,8 +124,7 @@ define float @canonicalize_pos_denorm_positive_zero_output() "denormal-fp-math"=
define float @canonicalize_pos_denorm_positive_zero_input() "denormal-fp-math"="ieee,positive-zero" {
; CHECK-LABEL: @canonicalize_pos_denorm_positive_zero_input(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0x380FFFFFC0000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float bitcast (i32 8388607 to float))
ret float %ret
@@ -147,8 +132,7 @@ define float @canonicalize_pos_denorm_positive_zero_input() "denormal-fp-math"="
define float @canonicalize_neg_denorm_positive_zero_output() "denormal-fp-math"="positive-zero,ieee" {
; CHECK-LABEL: @canonicalize_neg_denorm_positive_zero_output(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0xB80FFFFFC0000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float bitcast (i32 -2139095041 to float))
ret float %ret
@@ -156,8 +140,7 @@ define float @canonicalize_neg_denorm_positive_zero_output() "denormal-fp-math"=
define float @canonicalize_neg_denorm_positive_zero_input() "denormal-fp-math"="ieee,positive-zero" {
; CHECK-LABEL: @canonicalize_neg_denorm_positive_zero_input(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0xB80FFFFFC0000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float bitcast (i32 -2139095041 to float))
ret float %ret
@@ -165,8 +148,7 @@ define float @canonicalize_neg_denorm_positive_zero_input() "denormal-fp-math"="
define float @canonicalize_inf() {
; CHECK-LABEL: @canonicalize_inf(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0x7FF0000000000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%ret = call float @llvm.canonicalize.f32(float 0x7FF0000000000000)
ret float %ret
@@ -174,8 +156,7 @@ define float @canonicalize_inf() {
define float @canonicalize_neg_inf() {
; CHECK-LABEL: @canonicalize_neg_inf(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0xFFF0000000000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%ret = call float @llvm.canonicalize.f32(float 0xFFF0000000000000)
ret float %ret
@@ -201,8 +182,7 @@ define float @canonicalize_snan() {
define float @canonicalize_pos_normal() {
; CHECK-LABEL: @canonicalize_pos_normal(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 4.000000e+00)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 4.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float 4.0)
ret float %ret
@@ -210,8 +190,7 @@ define float @canonicalize_pos_normal() {
define float @canonicalize_neg_normal() {
; CHECK-LABEL: @canonicalize_neg_normal(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float -4.000000e+00)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float -4.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float -4.0)
ret float %ret
@@ -219,8 +198,7 @@ define float @canonicalize_neg_normal() {
define <2 x float> @canonicalize_pos_denorm_preserve_sign_output_mixed_vector() "denormal-fp-math"="preserve-sign,ieee" {
; CHECK-LABEL: @canonicalize_pos_denorm_preserve_sign_output_mixed_vector(
-; CHECK-NEXT: [[RET:%.*]] = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float 0x380FFFFFC0000000, float 0xB80FFFFFC0000000>)
-; CHECK-NEXT: ret <2 x float> [[RET]]
+; CHECK-NEXT: ret <2 x float> <float 0.000000e+00, float -0.000000e+00>
;
%ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float bitcast (i32 8388607 to float), float bitcast (i32 -2139095041 to float)>)
ret <2 x float> %ret
@@ -228,8 +206,7 @@ define <2 x float> @canonicalize_pos_denorm_preserve_sign_output_mixed_vector()
define <2 x float> @canonicalize_pos_denorm_preserve_sign_input_mixed_vector() "denormal-fp-math"="ieee,preserve-sign" {
; CHECK-LABEL: @canonicalize_pos_denorm_preserve_sign_input_mixed_vector(
-; CHECK-NEXT: [[RET:%.*]] = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float 0xB80FFFFFC0000000, float 0x380FFFFFC0000000>)
-; CHECK-NEXT: ret <2 x float> [[RET]]
+; CHECK-NEXT: ret <2 x float> <float -0.000000e+00, float 0.000000e+00>
;
%ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float bitcast (i32 -2139095041 to float), float bitcast (i32 8388607 to float)>)
ret <2 x float> %ret
@@ -237,8 +214,7 @@ define <2 x float> @canonicalize_pos_denorm_preserve_sign_input_mixed_vector() "
define <2 x float> @canonicalize_pos_denorm_positive_zero_output_mixed_vector() "denormal-fp-math"="positive-zero,ieee" {
; CHECK-LABEL: @canonicalize_pos_denorm_positive_zero_output_mixed_vector(
-; CHECK-NEXT: [[RET:%.*]] = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float 0x380FFFFFC0000000, float 0xB80FFFFFC0000000>)
-; CHECK-NEXT: ret <2 x float> [[RET]]
+; CHECK-NEXT: ret <2 x float> zeroinitializer
;
%ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float bitcast (i32 8388607 to float), float bitcast (i32 -2139095041 to float)>)
ret <2 x float> %ret
@@ -246,8 +222,7 @@ define <2 x float> @canonicalize_pos_denorm_positive_zero_output_mixed_vector()
define <2 x float> @canonicalize_pos_denorm_positive_zero_input_mixed_vector() "denormal-fp-math"="ieee,positive-zero" {
; CHECK-LABEL: @canonicalize_pos_denorm_positive_zero_input_mixed_vector(
-; CHECK-NEXT: [[RET:%.*]] = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float 0xB80FFFFFC0000000, float 0x380FFFFFC0000000>)
-; CHECK-NEXT: ret <2 x float> [[RET]]
+; CHECK-NEXT: ret <2 x float> zeroinitializer
;
%ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float bitcast (i32 -2139095041 to float), float bitcast (i32 8388607 to float)>)
ret <2 x float> %ret
@@ -255,8 +230,7 @@ define <2 x float> @canonicalize_pos_denorm_positive_zero_input_mixed_vector() "
define float @canonicalize_neg_denorm_preserve_sign_output_positive_zero_input() "denormal-fp-math"="preserve-sign,positive-zero" {
; CHECK-LABEL: @canonicalize_neg_denorm_preserve_sign_output_positive_zero_input(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0xB80FFFFFC0000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float bitcast (i32 -2139095041 to float))
ret float %ret
@@ -264,8 +238,7 @@ define float @canonicalize_neg_denorm_preserve_sign_output_positive_zero_input()
define float @canonicalize_neg_denorm_positive_zero_output_preserve_sign_input() "denormal-fp-math"="positive-zero,preserve-sign" {
; CHECK-LABEL: @canonicalize_neg_denorm_positive_zero_output_preserve_sign_input(
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.canonicalize.f32(float 0xB80FFFFFC0000000)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float 0.000000e+00
;
%ret = call float @llvm.canonicalize.f32(float bitcast (i32 -2139095041 to float))
ret float %ret
@@ -277,8 +250,7 @@ define float @canonicalize_neg_denorm_positive_zero_output_preserve_sign_input()
define double @canonicalize_zero_f64() {
; CHECK-LABEL: @canonicalize_zero_f64(
-; CHECK-NEXT: [[RET:%.*]] = call double @llvm.canonicalize.f64(double 0.000000e+00)
-; CHECK-NEXT: ret double [[RET]]
+; CHECK-NEXT: ret double 0.000000e+00
;
%ret = call double @llvm.canonicalize.f64(double 0.0)
ret double %ret
@@ -286,8 +258,7 @@ define double @canonicalize_zero_f64() {
define double @canonicalize_negzero_f64() {
; CHECK-LABEL: @canonicalize_negzero_f64(
-; CHECK-NEXT: [[RET:%.*]] = call double @llvm.canonicalize.f64(double -0.000000e+00)
-; CHECK-NEXT: ret double [[RET]]
+; CHECK-NEXT: ret double -0.000000e+00
;
%ret = call double @llvm.canonicalize.f64(double -0.0)
ret double %ret
@@ -295,8 +266,7 @@ define double @canonicalize_negzero_f64() {
define double @canonicalize_1.0_f64() {
; CHECK-LABEL: @canonicalize_1.0_f64(
-; CHECK-NEXT: [[RET:%.*]] = call double @llvm.canonicalize.f64(double 1.000000e+00)
-; CHECK-NEXT: ret double [[RET]]
+; CHECK-NEXT: ret double 1.000000e+00
;
%ret = call double @llvm.canonicalize.f64(double 1.0)
ret double %ret
@@ -313,8 +283,7 @@ define double @canonicalize_0x00000000000001_f64() {
define double @canonicalize_inf_f64() {
; CHECK-LABEL: @canonicalize_inf_f64(
-; CHECK-NEXT: [[RET:%.*]] = call double @llvm.canonicalize.f64(double 0x7FF0000000000000)
-; CHECK-NEXT: ret double [[RET]]
+; CHECK-NEXT: ret double 0x7FF0000000000000
;
%ret = call double @llvm.canonicalize.f64(double 0x7FF0000000000000)
ret double %ret
@@ -322,8 +291,7 @@ define double @canonicalize_inf_f64() {
define double @canonicalize_ninf_f64() {
; CHECK-LABEL: @canonicalize_ninf_f64(
-; CHECK-NEXT: [[RET:%.*]] = call double @llvm.canonicalize.f64(double 0xFFF0000000000000)
-; CHECK-NEXT: ret double [[RET]]
+; CHECK-NEXT: ret double 0xFFF0000000000000
;
%ret = call double @llvm.canonicalize.f64(double 0xFFF0000000000000)
ret double %ret
@@ -335,8 +303,7 @@ define double @canonicalize_ninf_f64() {
define half @canonicalize_zero_f16() {
; CHECK-LABEL: @canonicalize_zero_f16(
-; CHECK-NEXT: [[RET:%.*]] = call half @llvm.canonicalize.f16(half 0xH0000)
-; CHECK-NEXT: ret half [[RET]]
+; CHECK-NEXT: ret half 0xH0000
;
%ret = call half @llvm.canonicalize.f16(half 0.0)
ret half %ret
@@ -344,8 +311,7 @@ define half @canonicalize_zero_f16() {
define half @canonicalize_1.0_f16() {
; CHECK-LABEL: @canonicalize_1.0_f16(
-; CHECK-NEXT: [[RET:%.*]] = call half @llvm.canonicalize.f16(half 0xH3C00)
-; CHECK-NEXT: ret half [[RET]]
+; CHECK-NEXT: ret half 0xH3C00
;
%ret = call half @llvm.canonicalize.f16(half 1.0)
ret half %ret
@@ -362,8 +328,7 @@ define half @canonicalize_0x0001_f16() {
define half @canonicalize_inf_f16() {
; CHECK-LABEL: @canonicalize_inf_f16(
-; CHECK-NEXT: [[RET:%.*]] = call half @llvm.canonicalize.f16(half 0xH7C00)
-; CHECK-NEXT: ret half [[RET]]
+; CHECK-NEXT: ret half 0xH7C00
;
%ret = call half @llvm.canonicalize.f16(half 0xH7C00)
ret half %ret
@@ -371,8 +336,7 @@ define half @canonicalize_inf_f16() {
define half @canonicalize_neg_inf_f16() {
; CHECK-LABEL: @canonicalize_neg_inf_f16(
-; CHECK-NEXT: [[RET:%.*]] = call half @llvm.canonicalize.f16(half 0xHFC00)
-; CHECK-NEXT: ret half [[RET]]
+; CHECK-NEXT: ret half 0xHFC00
;
%ret = call half @llvm.canonicalize.f16(half 0xHFC00)
ret half %ret
@@ -384,8 +348,7 @@ define half @canonicalize_neg_inf_f16() {
define fp128 @canonicalize_zero_fp128() {
; CHECK-LABEL: @canonicalize_zero_fp128(
-; CHECK-NEXT: [[RET:%.*]] = call fp128 @llvm.canonicalize.f128(fp128 0xL00000000000000000000000000000000)
-; CHECK-NEXT: ret fp128 [[RET]]
+; CHECK-NEXT: ret fp128 0xL00000000000000000000000000000000
;
%ret = call fp128 @llvm.canonicalize.fp128(fp128 0xL00000000000000000000000000000000)
ret fp128 %ret
@@ -393,8 +356,7 @@ define fp128 @canonicalize_zero_fp128() {
define fp128 @canonicalize_1.0_fp128() {
; CHECK-LABEL: @canonicalize_1.0_fp128(
-; CHECK-NEXT: [[RET:%.*]] = call fp128 @llvm.canonicalize.f128(fp128 0xL00000000000000003FFF000000000000)
-; CHECK-NEXT: ret fp128 [[RET]]
+; CHECK-NEXT: ret fp128 0xL00000000000000003FFF000000000000
;
%ret = call fp128 @llvm.canonicalize.fp128(fp128 0xL00000000000000003FFF000000000000)
ret fp128 %ret
@@ -411,8 +373,7 @@ define fp128 @canonicalize_0x00000000000000000000000000000001_fp128() {
define fp128 @canonicalize_inf_fp128() {
; CHECK-LABEL: @canonicalize_inf_fp128(
-; CHECK-NEXT: [[RET:%.*]] = call fp128 @llvm.canonicalize.f128(fp128 0xL00000000000000007FFF000000000000)
-; CHECK-NEXT: ret fp128 [[RET]]
+; CHECK-NEXT: ret fp128 0xL00000000000000007FFF000000000000
;
%ret = call fp128 @llvm.canonicalize.fp128(fp128 0xL00000000000000007FFF000000000000)
ret fp128 %ret
@@ -420,8 +381,7 @@ define fp128 @canonicalize_inf_fp128() {
define fp128 @canonicalize_neg_inf_fp128() {
; CHECK-LABEL: @canonicalize_neg_inf_fp128(
-; CHECK-NEXT: [[RET:%.*]] = call fp128 @llvm.canonicalize.f128(fp128 0xL0000000000000000FFFF000000000000)
-; CHECK-NEXT: ret fp128 [[RET]]
+; CHECK-NEXT: ret fp128 0xL0000000000000000FFFF000000000000
;
%ret = call fp128 @llvm.canonicalize.fp128(fp128 0xL0000000000000000FFFF000000000000)
ret fp128 %ret
@@ -442,8 +402,7 @@ define fp128 @canonicalize_nan_fp128() {
define bfloat @canonicalize_zero_bf16() {
; CHECK-LABEL: @canonicalize_zero_bf16(
-; CHECK-NEXT: [[RET:%.*]] = call bfloat @llvm.canonicalize.bf16(bfloat 0xR0000)
-; CHECK-NEXT: ret bfloat [[RET]]
+; CHECK-NEXT: ret bfloat 0xR0000
;
%ret = call bfloat @llvm.canonicalize.bf16(bfloat 0.0)
ret bfloat %ret
@@ -451,8 +410,7 @@ define bfloat @canonicalize_zero_bf16() {
define bfloat @canonicalize_1.0_bf16() {
; CHECK-LABEL: @canonicalize_1.0_bf16(
-; CHECK-NEXT: [[RET:%.*]] = call bfloat @llvm.canonicalize.bf16(bfloat 0xR3F80)
-; CHECK-NEXT: ret bfloat [[RET]]
+; CHECK-NEXT: ret bfloat 0xR3F80
;
%ret = call bfloat @llvm.canonicalize.bf16(bfloat 1.0)
ret bfloat %ret
@@ -469,8 +427,7 @@ define bfloat @canonicalize_0x0001_bf16() {
define bfloat @canonicalize_inf_bf16() {
; CHECK-LABEL: @canonicalize_inf_bf16(
-; CHECK-NEXT: [[RET:%.*]] = call bfloat @llvm.canonicalize.bf16(bfloat 0xR7F80)
-; CHECK-NEXT: ret bfloat [[RET]]
+; CHECK-NEXT: ret bfloat 0xR7F80
;
%ret = call bfloat @llvm.canonicalize.bf16(bfloat 0xR7F80)
ret bfloat %ret
@@ -478,8 +435,7 @@ define bfloat @canonicalize_inf_bf16() {
define bfloat @canonicalize_neg_inf_bf16() {
; CHECK-LABEL: @canonicalize_neg_inf_bf16(
-; CHECK-NEXT: [[RET:%.*]] = call bfloat @llvm.canonicalize.bf16(bfloat 0xRFF80)
-; CHECK-NEXT: ret bfloat [[RET]]
+; CHECK-NEXT: ret bfloat 0xRFF80
;
%ret = call bfloat @llvm.canonicalize.bf16(bfloat 0xRFF80)
ret bfloat %ret
@@ -496,8 +452,7 @@ define bfloat @canonicalize_nan_bf16() {
define bfloat @canonicalize_0xff_bf16() {
; CHECK-LABEL: @canonicalize_0xff_bf16(
-; CHECK-NEXT: [[RET:%.*]] = call bfloat @llvm.canonicalize.bf16(bfloat 0xR00FF)
-; CHECK-NEXT: ret bfloat [[RET]]
+; CHECK-NEXT: ret bfloat 0xR00FF
;
%ret = call bfloat @llvm.canonicalize.bf16(bfloat 0xR00FF)
ret bfloat %ret
@@ -509,8 +464,7 @@ define bfloat @canonicalize_0xff_bf16() {
define x86_fp80 @canonicalize_poison_f80() {
; CHECK-LABEL: @canonicalize_poison_f80(
-; CHECK-NEXT: [[RET:%.*]] = call x86_fp80 @llvm.canonicalize.f80(x86_fp80 poison)
-; CHECK-NEXT: ret x86_fp80 [[RET]]
+; CHECK-NEXT: ret x86_fp80 poison
;
%ret = call x86_fp80 @llvm.canonicalize.f80(x86_fp80 poison)
ret x86_fp80 %ret
@@ -518,8 +472,7 @@ define x86_fp80 @canonicalize_poison_f80() {
define x86_fp80 @canonicalize_undef_f80() {
; CHECK-LABEL: @canonicalize_undef_f80(
-; CHECK-NEXT: [[RET:%.*]] = call x86_fp80 @llvm.canonicalize.f80(x86_fp80 undef)
-; CHECK-NEXT: ret x86_fp80 [[RET]]
+; CHECK-NEXT: ret x86_fp80 0xK00000000000000000000
;
%ret = call x86_fp80 @llvm.canonicalize.f80(x86_fp80 undef)
ret x86_fp80 %ret
@@ -527,8 +480,7 @@ define x86_fp80 @canonicalize_undef_f80() {
define x86_fp80 @canonicalize_zero_f80() {
; CHECK-LABEL: @canonicalize_zero_f80(
-; CHECK-NEXT: [[RET:%.*]] = call x86_fp80 @llvm.canonicalize.f80(x86_fp80 0xK00000000000000000000)
-; CHECK-NEXT: ret x86_fp80 [[RET]]
+; CHECK-NEXT: ret x86_fp80 0xK00000000000000000000
;
%ret = call x86_fp80 @llvm.canonicalize.f80(x86_fp80 0xK00000000000000000000)
ret x86_fp80 %ret
@@ -536,8 +488,7 @@ define x86_fp80 @canonicalize_zero_f80() {
define x86_fp80 @canonicalize_negzero_f80() {
; CHECK-LABEL: @canonicalize_negzero_f80(
-; CHECK-NEXT: [[RET:%.*]] = call x86_fp80 @llvm.canonicalize.f80(x86_fp80 0xK80000000000000000000)
-; CHECK-NEXT: ret x86_fp80 [[RET]]
+; CHECK-NEXT: ret x86_fp80 0xK80000000000000000000
;
%ret = call x86_fp80 @llvm.canonicalize.f80(x86_fp80 0xK80000000000000000000)
ret x86_fp80 %ret
@@ -612,8 +563,7 @@ define x86_fp80 @canonicalize_0xK00000000000000000001_f80() {
define ppc_fp128 @canonicalize_poison_ppcf128() {
; CHECK-LABEL: @canonicalize_poison_ppcf128(
-; CHECK-NEXT: [[RET:%.*]] = call ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128 poison)
-; CHECK-NEXT: ret ppc_fp128 [[RET]]
+; CHECK-NEXT: ret ppc_fp128 poison
;
%ret = call ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128 poison)
ret ppc_fp128 %ret
@@ -621,8 +571,7 @@ define ppc_fp128 @canonicalize_poison_ppcf128() {
define ppc_fp128 @canonicalize_undef_ppcf128() {
; CHECK-LABEL: @canonicalize_undef_ppcf128(
-; CHECK-NEXT: [[RET:%.*]] = call ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128 undef)
-; CHECK-NEXT: ret ppc_fp128 [[RET]]
+; CHECK-NEXT: ret ppc_fp128 0xM00000000000000000000000000000000
;
%ret = call ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128 undef)
ret ppc_fp128 %ret
@@ -630,8 +579,7 @@ define ppc_fp128 @canonicalize_undef_ppcf128() {
define ppc_fp128 @canonicalize_zero_ppcf128() {
; CHECK-LABEL: @canonicalize_zero_ppcf128(
-; CHECK-NEXT: [[RET:%.*]] = call ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128 0xM00000000000000000000000000000000)
-; CHECK-NEXT: ret ppc_fp128 [[RET]]
+; CHECK-NEXT: ret ppc_fp128 0xM00000000000000000000000000000000
;
%ret = call ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128 0xM00000000000000000000000000000000)
ret ppc_fp128 %ret
@@ -639,8 +587,7 @@ define ppc_fp128 @canonicalize_zero_ppcf128() {
define ppc_fp128 @canonicalize_negzero_ppcf128() {
; CHECK-LABEL: @canonicalize_negzero_ppcf128(
-; CHECK-NEXT: [[RET:%.*]] = call ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128 0xM80000000000000000000000000000000)
-; CHECK-NEXT: ret ppc_fp128 [[RET]]
+; CHECK-NEXT: ret ppc_fp128 0xM80000000000000000000000000000000
;
%ret = call ppc_fp128 @llvm.canonicalize.ppcf128(ppc_fp128 0xM80000000000000000000000000000000)
ret ppc_fp128 %ret
More information about the llvm-commits
mailing list