InstSimplify: Regenerate checks in a test

For some reason this was missing the "Assertions have been autogenerated"
comment so were getting spurious diffs in a future change.

diff --git a/llvm/test/Transforms/InstSimplify/known-never-infinity.ll b/llvm/test/Transforms/InstSimplify/known-never-infinity.ll
index da044aa..0ee5988 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/known-never-infinity.ll
+++ b/llvm/test/Transforms/InstSimplify/known-never-infinity.ll
@@ -1,10 +1,12 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt < %s -S -passes=instsimplify | FileCheck %s
 
 ; largest unsigned i15 = 2^15 - 1 = 32767
 ; largest half (max exponent = 15 -> 2^15 * (1 + 1023/1024) = 65504
 
 define i1 @isKnownNeverInfinity_uitofp(i15 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_uitofp(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_uitofp
+; CHECK-SAME: (i15 [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %f = uitofp i15 %x to half
@@ -15,8 +17,9 @@ define i1 @isKnownNeverInfinity_uitofp(i15 %x) {
 ; negative test
 
 define i1 @isNotKnownNeverInfinity_uitofp(i16 %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_uitofp(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[X:%.*]] to half
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_uitofp
+; CHECK-SAME: (i16 [[X:%.*]]) {
+; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[X]] to half
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une half [[F]], 0xH7C00
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -26,7 +29,8 @@ define i1 @isNotKnownNeverInfinity_uitofp(i16 %x) {
 }
 
 define i1 @isKnownNeverNegativeInfinity_uitofp(i15 %x) {
-; CHECK-LABEL: @isKnownNeverNegativeInfinity_uitofp(
+; CHECK-LABEL: define i1 @isKnownNeverNegativeInfinity_uitofp
+; CHECK-SAME: (i15 [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 false
 ;
   %f = uitofp i15 %x to half
@@ -37,7 +41,8 @@ define i1 @isKnownNeverNegativeInfinity_uitofp(i15 %x) {
 ; uitofp can't be negative, so this still works.
 
 define i1 @isNotKnownNeverNegativeInfinity_uitofp(i16 %x) {
-; CHECK-LABEL: @isNotKnownNeverNegativeInfinity_uitofp(
+; CHECK-LABEL: define i1 @isNotKnownNeverNegativeInfinity_uitofp
+; CHECK-SAME: (i16 [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 false
 ;
   %f = uitofp i16 %x to half
@@ -49,7 +54,8 @@ define i1 @isNotKnownNeverNegativeInfinity_uitofp(i16 %x) {
 ; largest half (max exponent = 15 -> 2^15 * (1 + 1023/1024) = 65504
 
 define i1 @isKnownNeverInfinity_sitofp(i16 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_sitofp(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_sitofp
+; CHECK-SAME: (i16 [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %f = sitofp i16 %x to half
@@ -60,8 +66,9 @@ define i1 @isKnownNeverInfinity_sitofp(i16 %x) {
 ; negative test
 
 define i1 @isNotKnownNeverInfinity_sitofp(i17 %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_sitofp(
-; CHECK-NEXT:    [[F:%.*]] = sitofp i17 [[X:%.*]] to half
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_sitofp
+; CHECK-SAME: (i17 [[X:%.*]]) {
+; CHECK-NEXT:    [[F:%.*]] = sitofp i17 [[X]] to half
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une half [[F]], 0xH7C00
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -71,7 +78,8 @@ define i1 @isNotKnownNeverInfinity_sitofp(i17 %x) {
 }
 
 define i1 @isKnownNeverNegativeInfinity_sitofp(i16 %x) {
-; CHECK-LABEL: @isKnownNeverNegativeInfinity_sitofp(
+; CHECK-LABEL: define i1 @isKnownNeverNegativeInfinity_sitofp
+; CHECK-SAME: (i16 [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 false
 ;
   %f = sitofp i16 %x to half
@@ -82,8 +90,9 @@ define i1 @isKnownNeverNegativeInfinity_sitofp(i16 %x) {
 ; negative test
 
 define i1 @isNotKnownNeverNegativeInfinity_sitofp(i17 %x) {
-; CHECK-LABEL: @isNotKnownNeverNegativeInfinity_sitofp(
-; CHECK-NEXT:    [[F:%.*]] = sitofp i17 [[X:%.*]] to half
+; CHECK-LABEL: define i1 @isNotKnownNeverNegativeInfinity_sitofp
+; CHECK-SAME: (i17 [[X:%.*]]) {
+; CHECK-NEXT:    [[F:%.*]] = sitofp i17 [[X]] to half
 ; CHECK-NEXT:    [[R:%.*]] = fcmp oeq half [[F]], 0xHFC00
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -93,7 +102,8 @@ define i1 @isNotKnownNeverNegativeInfinity_sitofp(i17 %x) {
 }
 
 define i1 @isKnownNeverInfinity_fpext(float %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_fpext(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_fpext
+; CHECK-SAME: (float [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf float %x, 1.0
@@ -103,7 +113,8 @@ define i1 @isKnownNeverInfinity_fpext(float %x) {
 }
 
 define i1 @isKnownNeverInfinity_fpext_sitofp(i16 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_fpext_sitofp(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_fpext_sitofp
+; CHECK-SAME: (i16 [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 false
 ;
   %f = sitofp i16 %x to half
@@ -113,8 +124,9 @@ define i1 @isKnownNeverInfinity_fpext_sitofp(i16 %x) {
 }
 
 define i1 @isKnownNeverInfinity_fptrunc(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_fptrunc(
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_fptrunc
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X]], 1.000000e+00
 ; CHECK-NEXT:    [[E:%.*]] = fptrunc double [[A]] to float
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une float [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -126,8 +138,9 @@ define i1 @isKnownNeverInfinity_fptrunc(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_fptrunc(double %unknown) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fptrunc(
-; CHECK-NEXT:    [[E:%.*]] = fptrunc double [[UNKNOWN:%.*]] to float
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_fptrunc
+; CHECK-SAME: (double [[UNKNOWN:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = fptrunc double [[UNKNOWN]] to float
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une float [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -137,7 +150,8 @@ define i1 @isNotKnownNeverInfinity_fptrunc(double %unknown) {
 }
 
 define i1 @isKnownNeverInfinity_canonicalize(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_canonicalize(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_canonicalize
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -147,8 +161,9 @@ define i1 @isKnownNeverInfinity_canonicalize(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_canonicalize(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_canonicalize(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.canonicalize.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_canonicalize
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.canonicalize.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -158,7 +173,8 @@ define i1 @isNotKnownNeverInfinity_canonicalize(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_fabs(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_fabs(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_fabs
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -168,8 +184,9 @@ define i1 @isKnownNeverInfinity_fabs(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_fabs(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fabs(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.fabs.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_fabs
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.fabs.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -179,7 +196,8 @@ define i1 @isNotKnownNeverInfinity_fabs(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_fneg(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_fneg(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_fneg
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -189,8 +207,9 @@ define i1 @isKnownNeverInfinity_fneg(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_fneg(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fneg(
-; CHECK-NEXT:    [[E:%.*]] = fneg double [[X:%.*]]
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_fneg
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = fneg double [[X]]
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -200,7 +219,8 @@ define i1 @isNotKnownNeverInfinity_fneg(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_copysign(double %x, double %sign) {
-; CHECK-LABEL: @isKnownNeverInfinity_copysign(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_copysign
+; CHECK-SAME: (double [[X:%.*]], double [[SIGN:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -210,8 +230,9 @@ define i1 @isKnownNeverInfinity_copysign(double %x, double %sign) {
 }
 
 define i1 @isNotKnownNeverInfinity_copysign(double %x, double %sign) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_copysign(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.copysign.f64(double [[X:%.*]], double [[SIGN:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_copysign
+; CHECK-SAME: (double [[X:%.*]], double [[SIGN:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.copysign.f64(double [[X]], double [[SIGN]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -221,7 +242,8 @@ define i1 @isNotKnownNeverInfinity_copysign(double %x, double %sign) {
 }
 
 define i1 @isKnownNeverInfinity_arithmetic_fence(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_arithmetic_fence(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_arithmetic_fence
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -231,8 +253,9 @@ define i1 @isKnownNeverInfinity_arithmetic_fence(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_arithmetic_fence(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_arithmetic_fence(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.arithmetic.fence.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_arithmetic_fence
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.arithmetic.fence.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -242,7 +265,8 @@ define i1 @isNotKnownNeverInfinity_arithmetic_fence(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_floor(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_floor(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_floor
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -252,8 +276,9 @@ define i1 @isKnownNeverInfinity_floor(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_floor(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_floor(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.floor.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_floor
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.floor.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -263,7 +288,8 @@ define i1 @isNotKnownNeverInfinity_floor(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_ceil(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_ceil(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_ceil
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -273,8 +299,9 @@ define i1 @isKnownNeverInfinity_ceil(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_ceil(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_ceil(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.ceil.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_ceil
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.ceil.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -284,7 +311,8 @@ define i1 @isNotKnownNeverInfinity_ceil(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_trunc(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_trunc(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_trunc
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -294,8 +322,9 @@ define i1 @isKnownNeverInfinity_trunc(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_trunc(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_trunc(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.trunc.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_trunc
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.trunc.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -305,7 +334,8 @@ define i1 @isNotKnownNeverInfinity_trunc(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_rint(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_rint(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_rint
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -315,8 +345,9 @@ define i1 @isKnownNeverInfinity_rint(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_rint(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_rint(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.rint.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_rint
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.rint.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -326,7 +357,8 @@ define i1 @isNotKnownNeverInfinity_rint(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_nearbyint(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_nearbyint(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_nearbyint
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -336,8 +368,9 @@ define i1 @isKnownNeverInfinity_nearbyint(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_nearbyint(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_nearbyint(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.nearbyint.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_nearbyint
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.nearbyint.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -347,7 +380,8 @@ define i1 @isNotKnownNeverInfinity_nearbyint(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_round(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_round(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_round
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -357,8 +391,9 @@ define i1 @isKnownNeverInfinity_round(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_round(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_round(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.round.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_round
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.round.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -368,7 +403,8 @@ define i1 @isNotKnownNeverInfinity_round(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_roundeven(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_roundeven(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_roundeven
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -378,8 +414,9 @@ define i1 @isKnownNeverInfinity_roundeven(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_roundeven(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_roundeven(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.roundeven.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_roundeven
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.roundeven.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -389,8 +426,9 @@ define i1 @isNotKnownNeverInfinity_roundeven(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_fptrunc_round(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fptrunc_round(
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_fptrunc_round
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X]], 1.000000e+00
 ; CHECK-NEXT:    [[E:%.*]] = call float @llvm.fptrunc.round.f32.f64(double [[A]], metadata !"round.downward")
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une float [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -402,8 +440,9 @@ define i1 @isNotKnownNeverInfinity_fptrunc_round(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_floor_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_floor_ppcf128(
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_floor_ppcf128
+; CHECK-SAME: (ppc_fp128 [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X]], [[X]]
 ; CHECK-NEXT:    [[E:%.*]] = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -415,8 +454,9 @@ define i1 @isKnownNeverInfinity_floor_ppcf128(ppc_fp128 %x) {
 }
 
 define i1 @isKnownNeverInfinity_ceil_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_ceil_ppcf128(
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_ceil_ppcf128
+; CHECK-SAME: (ppc_fp128 [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X]], [[X]]
 ; CHECK-NEXT:    [[E:%.*]] = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -428,8 +468,9 @@ define i1 @isKnownNeverInfinity_ceil_ppcf128(ppc_fp128 %x) {
 }
 
 define i1 @isKnownNeverInfinity_rint_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_rint_ppcf128(
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_rint_ppcf128
+; CHECK-SAME: (ppc_fp128 [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X]], [[X]]
 ; CHECK-NEXT:    [[E:%.*]] = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -441,8 +482,9 @@ define i1 @isKnownNeverInfinity_rint_ppcf128(ppc_fp128 %x) {
 }
 
 define i1 @isKnownNeverInfinity_nearbyint_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_nearbyint_ppcf128(
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_nearbyint_ppcf128
+; CHECK-SAME: (ppc_fp128 [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X]], [[X]]
 ; CHECK-NEXT:    [[E:%.*]] = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -454,8 +496,9 @@ define i1 @isKnownNeverInfinity_nearbyint_ppcf128(ppc_fp128 %x) {
 }
 
 define i1 @isKnownNeverInfinity_round_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_round_ppcf128(
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_round_ppcf128
+; CHECK-SAME: (ppc_fp128 [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X]], [[X]]
 ; CHECK-NEXT:    [[E:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -467,8 +510,9 @@ define i1 @isKnownNeverInfinity_round_ppcf128(ppc_fp128 %x) {
 }
 
 define i1 @isKnownNeverInfinity_roundeven_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_roundeven_ppcf128(
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X:%.*]], [[X]]
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_roundeven_ppcf128
+; CHECK-SAME: (ppc_fp128 [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = fadd ninf ppc_fp128 [[X]], [[X]]
 ; CHECK-NEXT:    [[E:%.*]] = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une ppc_fp128 [[E]], 0xM7FF00000000000000000000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -480,7 +524,8 @@ define i1 @isKnownNeverInfinity_roundeven_ppcf128(ppc_fp128 %x) {
 }
 
 define i1 @isKnownNeverInfinity_trunc_ppcf128(ppc_fp128 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_trunc_ppcf128(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_trunc_ppcf128
+; CHECK-SAME: (ppc_fp128 [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf ppc_fp128 %x, %x
@@ -490,7 +535,8 @@ define i1 @isKnownNeverInfinity_trunc_ppcf128(ppc_fp128 %x) {
 }
 
 define i1 @isKnownNeverInfinity_ceil_x86_fp80(x86_fp80 %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_ceil_x86_fp80(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_ceil_x86_fp80
+; CHECK-SAME: (x86_fp80 [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf x86_fp80 %x, %x
@@ -500,7 +546,8 @@ define i1 @isKnownNeverInfinity_ceil_x86_fp80(x86_fp80 %x) {
 }
 
 define i1 @isKnownNeverInfinity_minnum(double %x, double %y) {
-; CHECK-LABEL: @isKnownNeverInfinity_minnum(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_minnum
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %ninf.x = fadd ninf double %x, 1.0
@@ -511,9 +558,10 @@ define i1 @isKnownNeverInfinity_minnum(double %x, double %y) {
 }
 
 define i1 @isNotKnownNeverInfinity_minnum_lhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_minnum_lhs(
-; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.minnum.f64(double [[X:%.*]], double [[NINF_Y]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_minnum_lhs
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
+; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y]], 1.000000e+00
+; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.minnum.f64(double [[X]], double [[NINF_Y]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
@@ -524,9 +572,10 @@ define i1 @isNotKnownNeverInfinity_minnum_lhs(double %x, double %y) {
 }
 
 define i1 @isNotKnownNeverInfinity_minnum_rhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_minnum_rhs(
-; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.minnum.f64(double [[NINF_X]], double [[Y:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_minnum_rhs
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
+; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X]], 1.000000e+00
+; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.minnum.f64(double [[NINF_X]], double [[Y]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
@@ -537,7 +586,8 @@ define i1 @isNotKnownNeverInfinity_minnum_rhs(double %x, double %y) {
 }
 
 define i1 @isKnownNeverInfinity_maxnum(double %x, double %y) {
-; CHECK-LABEL: @isKnownNeverInfinity_maxnum(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_maxnum
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %ninf.x = fadd ninf double %x, 1.0
@@ -548,9 +598,10 @@ define i1 @isKnownNeverInfinity_maxnum(double %x, double %y) {
 }
 
 define i1 @isNotKnownNeverInfinity_maxnum_lhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_maxnum_lhs(
-; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double [[NINF_Y]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_maxnum_lhs
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
+; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y]], 1.000000e+00
+; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.maxnum.f64(double [[X]], double [[NINF_Y]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
@@ -561,9 +612,10 @@ define i1 @isNotKnownNeverInfinity_maxnum_lhs(double %x, double %y) {
 }
 
 define i1 @isNotKnownNeverInfinity_maxnum_rhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_maxnum_rhs(
-; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.maxnum.f64(double [[NINF_X]], double [[Y:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_maxnum_rhs
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
+; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X]], 1.000000e+00
+; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.maxnum.f64(double [[NINF_X]], double [[Y]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
@@ -574,7 +626,8 @@ define i1 @isNotKnownNeverInfinity_maxnum_rhs(double %x, double %y) {
 }
 
 define i1 @isKnownNeverInfinity_minimum(double %x, double %y) {
-; CHECK-LABEL: @isKnownNeverInfinity_minimum(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_minimum
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %ninf.x = fadd ninf double %x, 1.0
@@ -585,9 +638,10 @@ define i1 @isKnownNeverInfinity_minimum(double %x, double %y) {
 }
 
 define i1 @isNotKnownNeverInfinity_minimum_lhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_minimum_lhs(
-; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.minimum.f64(double [[X:%.*]], double [[NINF_Y]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_minimum_lhs
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
+; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y]], 1.000000e+00
+; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.minimum.f64(double [[X]], double [[NINF_Y]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
@@ -598,9 +652,10 @@ define i1 @isNotKnownNeverInfinity_minimum_lhs(double %x, double %y) {
 }
 
 define i1 @isNotKnownNeverInfinity_minimum_rhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_minimum_rhs(
-; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.minimum.f64(double [[NINF_X]], double [[Y:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_minimum_rhs
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
+; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X]], 1.000000e+00
+; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.minimum.f64(double [[NINF_X]], double [[Y]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
@@ -611,7 +666,8 @@ define i1 @isNotKnownNeverInfinity_minimum_rhs(double %x, double %y) {
 }
 
 define i1 @isKnownNeverInfinity_maximum(double %x, double %y) {
-; CHECK-LABEL: @isKnownNeverInfinity_maximum(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_maximum
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %ninf.x = fadd ninf double %x, 1.0
@@ -622,9 +678,10 @@ define i1 @isKnownNeverInfinity_maximum(double %x, double %y) {
 }
 
 define i1 @isNotKnownNeverInfinity_maximum_lhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_maximum_lhs(
-; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.maximum.f64(double [[X:%.*]], double [[NINF_Y]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_maximum_lhs
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
+; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y]], 1.000000e+00
+; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.maximum.f64(double [[X]], double [[NINF_Y]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
@@ -635,9 +692,10 @@ define i1 @isNotKnownNeverInfinity_maximum_lhs(double %x, double %y) {
 }
 
 define i1 @isNotKnownNeverInfinity_maximum_rhs(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_maximum_rhs(
-; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.maximum.f64(double [[NINF_X]], double [[Y:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_maximum_rhs
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
+; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X]], 1.000000e+00
+; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.maximum.f64(double [[NINF_X]], double [[Y]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
@@ -648,7 +706,8 @@ define i1 @isNotKnownNeverInfinity_maximum_rhs(double %x, double %y) {
 }
 
 define i1 @isKnownNeverInfinity_sqrt(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_sqrt(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_sqrt
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %a = fadd ninf double %x, 1.0
@@ -658,8 +717,9 @@ define i1 @isKnownNeverInfinity_sqrt(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_sqrt(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_sqrt(
-; CHECK-NEXT:    [[E:%.*]] = call double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_sqrt
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.sqrt.f64(double [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
@@ -670,7 +730,8 @@ define i1 @isNotKnownNeverInfinity_sqrt(double %x) {
 
 ; No source check required
 define i1 @isKnownNeverInfinity_sin(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_sin(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_sin
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %e = call double @llvm.sin.f64(double %x)
@@ -680,7 +741,8 @@ define i1 @isKnownNeverInfinity_sin(double %x) {
 
 ; No source check required
 define i1 @isKnownNeverInfinity_cos(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_cos(
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_cos
+; CHECK-SAME: (double [[X:%.*]]) {
 ; CHECK-NEXT:    ret i1 true
 ;
   %e = call double @llvm.cos.f64(double %x)
@@ -689,8 +751,9 @@ define i1 @isKnownNeverInfinity_cos(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_log(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_log(
-; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_log
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X]], double 0.000000e+00)
 ; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log.f64(double [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
@@ -704,8 +767,9 @@ define i1 @isKnownNeverInfinity_log(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_log_maybe_negative(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log_maybe_negative(
-; CHECK-NEXT:    [[X_NOT_INF:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_log_maybe_negative
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[X_NOT_INF:%.*]] = fadd ninf double [[X]], 1.000000e+00
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log.f64(double [[X_NOT_INF]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -718,8 +782,9 @@ define i1 @isNotKnownNeverInfinity_log_maybe_negative(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_log_maybe_inf(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log_maybe_inf(
-; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_log_maybe_inf
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X]], double 0.000000e+00)
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log.f64(double [[X_CLAMP_ZERO]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -731,8 +796,9 @@ define i1 @isNotKnownNeverInfinity_log_maybe_inf(double %x) {
 }
 
 define i1 @isKnownNeverNegInfinity_log_maybe_0(double %x) {
-; CHECK-LABEL: @isKnownNeverNegInfinity_log_maybe_0(
-; CHECK-NEXT:    [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isKnownNeverNegInfinity_log_maybe_0
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X]])
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log.f64(double [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0xFFF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -744,8 +810,9 @@ define i1 @isKnownNeverNegInfinity_log_maybe_0(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_log10(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_log10(
-; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_log10
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X]], double 0.000000e+00)
 ; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log10.f64(double [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
@@ -759,8 +826,9 @@ define i1 @isKnownNeverInfinity_log10(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_log10_maybe_negative(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log10_maybe_negative(
-; CHECK-NEXT:    [[X_NOT_INF:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_log10_maybe_negative
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[X_NOT_INF:%.*]] = fadd ninf double [[X]], 1.000000e+00
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log10.f64(double [[X_NOT_INF]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -773,8 +841,9 @@ define i1 @isNotKnownNeverInfinity_log10_maybe_negative(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_log10_maybe_inf(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log10_maybe_inf(
-; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_log10_maybe_inf
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X]], double 0.000000e+00)
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log10.f64(double [[X_CLAMP_ZERO]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -786,8 +855,9 @@ define i1 @isNotKnownNeverInfinity_log10_maybe_inf(double %x) {
 }
 
 define i1 @isKnownNeverNegInfinity_log10_maybe_0(double %x) {
-; CHECK-LABEL: @isKnownNeverNegInfinity_log10_maybe_0(
-; CHECK-NEXT:    [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isKnownNeverNegInfinity_log10_maybe_0
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X]])
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log10.f64(double [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0xFFF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -799,8 +869,9 @@ define i1 @isKnownNeverNegInfinity_log10_maybe_0(double %x) {
 }
 
 define i1 @isKnownNeverInfinity_log2(double %x) {
-; CHECK-LABEL: @isKnownNeverInfinity_log2(
-; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-LABEL: define i1 @isKnownNeverInfinity_log2
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X]], double 0.000000e+00)
 ; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X_CLAMP_ZERO]], 1.000000e+00
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log2.f64(double [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
@@ -814,8 +885,9 @@ define i1 @isKnownNeverInfinity_log2(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_log2_maybe_negative(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log2_maybe_negative(
-; CHECK-NEXT:    [[X_NOT_INF:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_log2_maybe_negative
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[X_NOT_INF:%.*]] = fadd ninf double [[X]], 1.000000e+00
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log2.f64(double [[X_NOT_INF]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -828,8 +900,9 @@ define i1 @isNotKnownNeverInfinity_log2_maybe_negative(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_log2_maybe_inf(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_log2_maybe_inf(
-; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double 0.000000e+00)
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_log2_maybe_inf
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[X_CLAMP_ZERO:%.*]] = call double @llvm.maxnum.f64(double [[X]], double 0.000000e+00)
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log2.f64(double [[X_CLAMP_ZERO]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -841,8 +914,9 @@ define i1 @isNotKnownNeverInfinity_log2_maybe_inf(double %x) {
 }
 
 define i1 @isKnownNeverNegInfinity_log2_maybe_0(double %x) {
-; CHECK-LABEL: @isKnownNeverNegInfinity_log2_maybe_0(
-; CHECK-NEXT:    [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-LABEL: define i1 @isKnownNeverNegInfinity_log2_maybe_0
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = call ninf double @llvm.sqrt.f64(double [[X]])
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.log2.f64(double [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0xFFF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -854,9 +928,10 @@ define i1 @isKnownNeverNegInfinity_log2_maybe_0(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_pow(double %x, double %y) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_pow(
-; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_pow
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
+; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X]], 1.000000e+00
+; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y]], 1.000000e+00
 ; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.pow.f64(double [[NINF_X]], double [[NINF_Y]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
@@ -869,8 +944,9 @@ define i1 @isNotKnownNeverInfinity_pow(double %x, double %y) {
 }
 
 define i1 @isNotKnownNeverInfinity_powi(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_powi(
-; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_powi
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X]], 1.000000e+00
 ; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.powi.f64.i32(double [[NINF_X]], i32 2)
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
@@ -882,8 +958,9 @@ define i1 @isNotKnownNeverInfinity_powi(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_exp(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_exp(
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_exp
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X]], 1.000000e+00
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.exp.f64(double [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -895,8 +972,9 @@ define i1 @isNotKnownNeverInfinity_exp(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_exp2(double %x) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_exp2(
-; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_exp2
+; CHECK-SAME: (double [[X:%.*]]) {
+; CHECK-NEXT:    [[A:%.*]] = fadd ninf double [[X]], 1.000000e+00
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.exp2.f64(double [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fcmp une double [[E]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[R]]
@@ -908,10 +986,11 @@ define i1 @isNotKnownNeverInfinity_exp2(double %x) {
 }
 
 define i1 @isNotKnownNeverInfinity_fma(double %x, double %y, double %z) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fma(
-; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[NINF_Z:%.*]] = fadd ninf double [[Z:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_fma
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]], double [[Z:%.*]]) {
+; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X]], 1.000000e+00
+; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y]], 1.000000e+00
+; CHECK-NEXT:    [[NINF_Z:%.*]] = fadd ninf double [[Z]], 1.000000e+00
 ; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.fma.f64(double [[NINF_X]], double [[NINF_Y]], double [[NINF_Z]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]
@@ -925,10 +1004,11 @@ define i1 @isNotKnownNeverInfinity_fma(double %x, double %y, double %z) {
 }
 
 define i1 @isNotKnownNeverInfinity_fmuladd(double %x, double %y, double %z) {
-; CHECK-LABEL: @isNotKnownNeverInfinity_fmuladd(
-; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[NINF_Z:%.*]] = fadd ninf double [[Z:%.*]], 1.000000e+00
+; CHECK-LABEL: define i1 @isNotKnownNeverInfinity_fmuladd
+; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]], double [[Z:%.*]]) {
+; CHECK-NEXT:    [[NINF_X:%.*]] = fadd ninf double [[X]], 1.000000e+00
+; CHECK-NEXT:    [[NINF_Y:%.*]] = fadd ninf double [[Y]], 1.000000e+00
+; CHECK-NEXT:    [[NINF_Z:%.*]] = fadd ninf double [[Z]], 1.000000e+00
 ; CHECK-NEXT:    [[OP:%.*]] = call double @llvm.fmuladd.f64(double [[NINF_X]], double [[NINF_Y]], double [[NINF_Z]])
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double [[OP]], 0x7FF0000000000000
 ; CHECK-NEXT:    ret i1 [[CMP]]