diff --git a/llvm/include/llvm/IR/Type.h b/llvm/include/llvm/IR/Type.h
index e6d351babb5639..a1848c812c3de1 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 df1a9bfa3da270..690545c0a9d33e 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 42517fca8307bc..b1cd8f32ab71c2 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 8c8d887c3beb9c..1bb05a1cedc6e0 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 7f8bd4f8d4095c..2c7c402ec41a7d 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