[InstCombine] Refactor test checks (NFC)

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@352935 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/test/Transforms/InstCombine/double-float-shrink-2.ll b/test/Transforms/InstCombine/double-float-shrink-2.ll
index cbd9daee125260ee0da25e667dd9117e032c29c8..d5099531af9fb38c99798506f7c8e037d973acfd 100644 (file)
--- a/test/Transforms/InstCombine/double-float-shrink-2.ll
+++ b/test/Transforms/InstCombine/double-float-shrink-2.ll
@@ -1,10 +1,10 @@
 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -instcombine -S -mtriple "i386-pc-linux"     | FileCheck --check-prefixes=ALL,DO-SIMPLIFY %s
-; RUN: opt < %s -instcombine -S -mtriple "i386-pc-win32"     | FileCheck --check-prefixes=ALL,DONT-SIMPLIFY %s
-; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32"   | FileCheck --check-prefixes=ALL,C89-SIMPLIFY %s
-; RUN: opt < %s -instcombine -S -mtriple "i386-pc-mingw32"   | FileCheck --check-prefixes=ALL,DO-SIMPLIFY %s
-; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-mingw32" | FileCheck --check-prefixes=ALL,DO-SIMPLIFY %s
-; RUN: opt < %s -instcombine -S -mtriple "sparc-sun-solaris" | FileCheck --check-prefixes=ALL,DO-SIMPLIFY %s
+; RUN: opt < %s -instcombine -S -mtriple "i386-pc-linux"     | FileCheck --check-prefixes=CHECK,DO-SIMPLIFY %s
+; RUN: opt < %s -instcombine -S -mtriple "i386-pc-win32"     | FileCheck --check-prefixes=CHECK,DONT-SIMPLIFY %s
+; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32"   | FileCheck --check-prefixes=CHECK,C89-SIMPLIFY %s
+; RUN: opt < %s -instcombine -S -mtriple "i386-pc-mingw32"   | FileCheck --check-prefixes=CHECK,DO-SIMPLIFY %s
+; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-mingw32" | FileCheck --check-prefixes=CHECK,DO-SIMPLIFY %s
+; RUN: opt < %s -instcombine -S -mtriple "sparc-sun-solaris" | FileCheck --check-prefixes=CHECK,DO-SIMPLIFY %s
 ; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32" -enable-debugify 2>&1 | FileCheck --check-prefix=DBG-VALID %s
 
 declare double @floor(double)
@@ -36,9 +36,9 @@ declare double @llvm.trunc.f64(double)
 declare <2 x double> @llvm.trunc.v2f64(<2 x double>)
 
 define float @test_shrink_libcall_floor(float %C) {
-; ALL-LABEL: @test_shrink_libcall_floor(
-; ALL-NEXT:    [[F:%.*]] = call float @llvm.floor.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_shrink_libcall_floor(
+; CHECK-NEXT:    [[F:%.*]] = call float @llvm.floor.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext float %C to double
   ; --> floorf
@@ -48,9 +48,9 @@ define float @test_shrink_libcall_floor(float %C) {
 }
 
 define float @test_shrink_libcall_ceil(float %C) {
-; ALL-LABEL: @test_shrink_libcall_ceil(
-; ALL-NEXT:    [[F:%.*]] = call float @llvm.ceil.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_shrink_libcall_ceil(
+; CHECK-NEXT:    [[F:%.*]] = call float @llvm.ceil.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext float %C to double
   ; --> ceilf
@@ -60,7 +60,7 @@ define float @test_shrink_libcall_ceil(float %C) {
 }
 
 define float @test_shrink_libcall_round(float %C) {
-; ALL-LABEL: @test_shrink_libcall_round(
+; CHECK-LABEL: @test_shrink_libcall_round(
 
 ; DO-SIMPLIFY-NEXT:    [[F:%.*]] = call float @llvm.round.f32(float [[C:%.*]])
 ; DO-SIMPLIFY-NEXT:    ret float [[F]]
@@ -83,7 +83,7 @@ define float @test_shrink_libcall_round(float %C) {
 }
 
 define float @test_shrink_libcall_nearbyint(float %C) {
-; ALL-LABEL: @test_shrink_libcall_nearbyint(
+; CHECK-LABEL: @test_shrink_libcall_nearbyint(
 
 ; DO-SIMPLIFY-NEXT:    [[F:%.*]] = call float @llvm.nearbyint.f32(float [[C:%.*]])
 ; DO-SIMPLIFY-NEXT:    ret float [[F]]
@@ -106,7 +106,7 @@ define float @test_shrink_libcall_nearbyint(float %C) {
 }
 
 define float @test_shrink_libcall_trunc(float %C) {
-; ALL-LABEL: @test_shrink_libcall_trunc(
+; CHECK-LABEL: @test_shrink_libcall_trunc(
 
 ; DO-SIMPLIFY-NEXT:    [[F:%.*]] = call float @llvm.trunc.f32(float [[C:%.*]])
 ; DO-SIMPLIFY-NEXT:    ret float [[F]]
@@ -129,11 +129,11 @@ define float @test_shrink_libcall_trunc(float %C) {
 }
 
 ; This is replaced with the intrinsic, which does the right thing on
-; all platforms.
+; CHECK platforms.
 define float @test_shrink_libcall_fabs(float %C) {
-; ALL-LABEL: @test_shrink_libcall_fabs(
-; ALL-NEXT:    [[F:%.*]] = call float @llvm.fabs.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_shrink_libcall_fabs(
+; CHECK-NEXT:    [[F:%.*]] = call float @llvm.fabs.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext float %C to double
   %E = call double @fabs(double %D)
@@ -143,9 +143,9 @@ define float @test_shrink_libcall_fabs(float %C) {
 
 ; Make sure fast math flags are preserved
 define float @test_shrink_libcall_fabs_fast(float %C) {
-; ALL-LABEL: @test_shrink_libcall_fabs_fast(
-; ALL-NEXT:    [[F:%.*]] = call fast float @llvm.fabs.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_shrink_libcall_fabs_fast(
+; CHECK-NEXT:    [[F:%.*]] = call fast float @llvm.fabs.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext float %C to double
   %E = call fast double @fabs(double %D)
@@ -154,9 +154,9 @@ define float @test_shrink_libcall_fabs_fast(float %C) {
 }
 
 define float @test_shrink_intrin_ceil(float %C) {
-; ALL-LABEL: @test_shrink_intrin_ceil(
-; ALL-NEXT:    [[TMP1:%.*]] = call float @llvm.ceil.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[TMP1]]
+; CHECK-LABEL: @test_shrink_intrin_ceil(
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.ceil.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %D = fpext float %C to double
   %E = call double @llvm.ceil.f64(double %D)
@@ -165,9 +165,9 @@ define float @test_shrink_intrin_ceil(float %C) {
 }
 
 define float @test_shrink_intrin_fabs(float %C) {
-; ALL-LABEL: @test_shrink_intrin_fabs(
-; ALL-NEXT:    [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[TMP1]]
+; CHECK-LABEL: @test_shrink_intrin_fabs(
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %D = fpext float %C to double
   %E = call double @llvm.fabs.f64(double %D)
@@ -176,9 +176,9 @@ define float @test_shrink_intrin_fabs(float %C) {
 }
 
 define float @test_shrink_intrin_floor(float %C) {
-; ALL-LABEL: @test_shrink_intrin_floor(
-; ALL-NEXT:    [[TMP1:%.*]] = call float @llvm.floor.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[TMP1]]
+; CHECK-LABEL: @test_shrink_intrin_floor(
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.floor.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %D = fpext float %C to double
   %E = call double @llvm.floor.f64(double %D)
@@ -187,9 +187,9 @@ define float @test_shrink_intrin_floor(float %C) {
 }
 
 define float @test_shrink_intrin_nearbyint(float %C) {
-; ALL-LABEL: @test_shrink_intrin_nearbyint(
-; ALL-NEXT:    [[TMP1:%.*]] = call float @llvm.nearbyint.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[TMP1]]
+; CHECK-LABEL: @test_shrink_intrin_nearbyint(
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.nearbyint.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %D = fpext float %C to double
   %E = call double @llvm.nearbyint.f64(double %D)
@@ -198,9 +198,9 @@ define float @test_shrink_intrin_nearbyint(float %C) {
 }
 
 define half @test_shrink_intrin_rint(half %C) {
-; ALL-LABEL: @test_shrink_intrin_rint(
-; ALL-NEXT:    [[TMP1:%.*]] = call half @llvm.rint.f16(half [[C:%.*]])
-; ALL-NEXT:    ret half [[TMP1]]
+; CHECK-LABEL: @test_shrink_intrin_rint(
+; CHECK-NEXT:    [[TMP1:%.*]] = call half @llvm.rint.f16(half [[C:%.*]])
+; CHECK-NEXT:    ret half [[TMP1]]
 ;
   %D = fpext half %C to float
   %E = call float @llvm.rint.f32(float %D)
@@ -209,9 +209,9 @@ define half @test_shrink_intrin_rint(half %C) {
 }
 
 define float @test_shrink_intrin_round(float %C) {
-; ALL-LABEL: @test_shrink_intrin_round(
-; ALL-NEXT:    [[TMP1:%.*]] = call float @llvm.round.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[TMP1]]
+; CHECK-LABEL: @test_shrink_intrin_round(
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.round.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %D = fpext float %C to double
   %E = call double @llvm.round.f64(double %D)
@@ -220,9 +220,9 @@ define float @test_shrink_intrin_round(float %C) {
 }
 
 define float @test_shrink_intrin_trunc(float %C) {
-; ALL-LABEL: @test_shrink_intrin_trunc(
-; ALL-NEXT:    [[TMP1:%.*]] = call float @llvm.trunc.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[TMP1]]
+; CHECK-LABEL: @test_shrink_intrin_trunc(
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.trunc.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %D = fpext float %C to double
   %E = call double @llvm.trunc.f64(double %D)
@@ -234,12 +234,12 @@ declare void @use_v2f64(<2 x double>)
 declare void @use_v2f32(<2 x float>)
 
 define <2 x float> @test_shrink_intrin_ceil_multi_use(<2 x float> %C) {
-; ALL-LABEL: @test_shrink_intrin_ceil_multi_use(
-; ALL-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
-; ALL-NEXT:    [[E:%.*]] = call <2 x double> @llvm.ceil.v2f64(<2 x double> [[D]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
-; ALL-NEXT:    call void @use_v2f64(<2 x double> [[D]])
-; ALL-NEXT:    ret <2 x float> [[F]]
+; CHECK-LABEL: @test_shrink_intrin_ceil_multi_use(
+; CHECK-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
+; CHECK-NEXT:    [[E:%.*]] = call <2 x double> @llvm.ceil.v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
+; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    ret <2 x float> [[F]]
 ;
   %D = fpext <2 x float> %C to <2 x double>
   %E = call <2 x double> @llvm.ceil.v2f64(<2 x double> %D)
@@ -249,11 +249,11 @@ define <2 x float> @test_shrink_intrin_ceil_multi_use(<2 x float> %C) {
 }
 
 define <2 x float> @test_shrink_intrin_fabs_multi_use(<2 x float> %C) {
-; ALL-LABEL: @test_shrink_intrin_fabs_multi_use(
-; ALL-NEXT:    [[TMP1:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[C:%.*]])
-; ALL-NEXT:    [[E:%.*]] = fpext <2 x float> [[TMP1]] to <2 x double>
-; ALL-NEXT:    call void @use_v2f64(<2 x double> [[E]])
-; ALL-NEXT:    ret <2 x float> [[TMP1]]
+; CHECK-LABEL: @test_shrink_intrin_fabs_multi_use(
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[C:%.*]])
+; CHECK-NEXT:    [[E:%.*]] = fpext <2 x float> [[TMP1]] to <2 x double>
+; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[E]])
+; CHECK-NEXT:    ret <2 x float> [[TMP1]]
 ;
   %D = fpext <2 x float> %C to <2 x double>
   %E = call <2 x double> @llvm.fabs.v2f64(<2 x double> %D)
@@ -263,13 +263,13 @@ define <2 x float> @test_shrink_intrin_fabs_multi_use(<2 x float> %C) {
 }
 
 define <2 x float> @test_shrink_intrin_floor_multi_use(<2 x float> %C) {
-; ALL-LABEL: @test_shrink_intrin_floor_multi_use(
-; ALL-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
-; ALL-NEXT:    [[E:%.*]] = call <2 x double> @llvm.floor.v2f64(<2 x double> [[D]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
-; ALL-NEXT:    call void @use_v2f64(<2 x double> [[D]])
-; ALL-NEXT:    call void @use_v2f64(<2 x double> [[E]])
-; ALL-NEXT:    ret <2 x float> [[F]]
+; CHECK-LABEL: @test_shrink_intrin_floor_multi_use(
+; CHECK-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
+; CHECK-NEXT:    [[E:%.*]] = call <2 x double> @llvm.floor.v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
+; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[E]])
+; CHECK-NEXT:    ret <2 x float> [[F]]
 ;
   %D = fpext <2 x float> %C to <2 x double>
   %E = call <2 x double> @llvm.floor.v2f64(<2 x double> %D)
@@ -280,12 +280,12 @@ define <2 x float> @test_shrink_intrin_floor_multi_use(<2 x float> %C) {
 }
 
 define <2 x float> @test_shrink_intrin_nearbyint_multi_use(<2 x float> %C) {
-; ALL-LABEL: @test_shrink_intrin_nearbyint_multi_use(
-; ALL-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
-; ALL-NEXT:    [[E:%.*]] = call <2 x double> @llvm.nearbyint.v2f64(<2 x double> [[D]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
-; ALL-NEXT:    call void @use_v2f64(<2 x double> [[D]])
-; ALL-NEXT:    ret <2 x float> [[F]]
+; CHECK-LABEL: @test_shrink_intrin_nearbyint_multi_use(
+; CHECK-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
+; CHECK-NEXT:    [[E:%.*]] = call <2 x double> @llvm.nearbyint.v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
+; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    ret <2 x float> [[F]]
 ;
   %D = fpext <2 x float> %C to <2 x double>
   %E = call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %D)
@@ -295,11 +295,11 @@ define <2 x float> @test_shrink_intrin_nearbyint_multi_use(<2 x float> %C) {
 }
 
 define <2 x half> @test_shrink_intrin_rint_multi_use(<2 x half> %C) {
-; ALL-LABEL: @test_shrink_intrin_rint_multi_use(
-; ALL-NEXT:    [[TMP1:%.*]] = call <2 x half> @llvm.rint.v2f16(<2 x half> [[C:%.*]])
-; ALL-NEXT:    [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x float>
-; ALL-NEXT:    call void @use_v2f32(<2 x float> [[E]])
-; ALL-NEXT:    ret <2 x half> [[TMP1]]
+; CHECK-LABEL: @test_shrink_intrin_rint_multi_use(
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x half> @llvm.rint.v2f16(<2 x half> [[C:%.*]])
+; CHECK-NEXT:    [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x float>
+; CHECK-NEXT:    call void @use_v2f32(<2 x float> [[E]])
+; CHECK-NEXT:    ret <2 x half> [[TMP1]]
 ;
   %D = fpext <2 x half> %C to <2 x float>
   %E = call <2 x float> @llvm.rint.v2f32(<2 x float> %D)
@@ -309,13 +309,13 @@ define <2 x half> @test_shrink_intrin_rint_multi_use(<2 x half> %C) {
 }
 
 define <2 x float> @test_shrink_intrin_round_multi_use(<2 x float> %C) {
-; ALL-LABEL: @test_shrink_intrin_round_multi_use(
-; ALL-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
-; ALL-NEXT:    [[E:%.*]] = call <2 x double> @llvm.round.v2f64(<2 x double> [[D]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
-; ALL-NEXT:    call void @use_v2f64(<2 x double> [[D]])
-; ALL-NEXT:    call void @use_v2f64(<2 x double> [[E]])
-; ALL-NEXT:    ret <2 x float> [[F]]
+; CHECK-LABEL: @test_shrink_intrin_round_multi_use(
+; CHECK-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
+; CHECK-NEXT:    [[E:%.*]] = call <2 x double> @llvm.round.v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
+; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[E]])
+; CHECK-NEXT:    ret <2 x float> [[F]]
 ;
   %D = fpext <2 x float> %C to <2 x double>
   %E = call <2 x double> @llvm.round.v2f64(<2 x double> %D)
@@ -326,12 +326,12 @@ define <2 x float> @test_shrink_intrin_round_multi_use(<2 x float> %C) {
 }
 
 define <2 x float> @test_shrink_intrin_trunc_multi_use(<2 x float> %C) {
-; ALL-LABEL: @test_shrink_intrin_trunc_multi_use(
-; ALL-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
-; ALL-NEXT:    [[E:%.*]] = call <2 x double> @llvm.trunc.v2f64(<2 x double> [[D]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
-; ALL-NEXT:    call void @use_v2f64(<2 x double> [[D]])
-; ALL-NEXT:    ret <2 x float> [[F]]
+; CHECK-LABEL: @test_shrink_intrin_trunc_multi_use(
+; CHECK-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
+; CHECK-NEXT:    [[E:%.*]] = call <2 x double> @llvm.trunc.v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
+; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    ret <2 x float> [[F]]
 ;
   %D = fpext <2 x float> %C to <2 x double>
   %E = call <2 x double> @llvm.trunc.v2f64(<2 x double> %D)
@@ -342,9 +342,9 @@ define <2 x float> @test_shrink_intrin_trunc_multi_use(<2 x float> %C) {
 
 ; Make sure fast math flags are preserved
 define float @test_shrink_intrin_fabs_fast(float %C) {
-; ALL-LABEL: @test_shrink_intrin_fabs_fast(
-; ALL-NEXT:    [[TMP1:%.*]] = call fast float @llvm.fabs.f32(float [[C:%.*]])
-; ALL-NEXT:    ret float [[TMP1]]
+; CHECK-LABEL: @test_shrink_intrin_fabs_fast(
+; CHECK-NEXT:    [[TMP1:%.*]] = call fast float @llvm.fabs.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %D = fpext float %C to double
   %E = call fast double @llvm.fabs.f64(double %D)
@@ -353,10 +353,10 @@ define float @test_shrink_intrin_fabs_fast(float %C) {
 }
 
 define float @test_no_shrink_intrin_floor(double %D) {
-; ALL-LABEL: @test_no_shrink_intrin_floor(
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.floor.f64(double [[D:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_no_shrink_intrin_floor(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.floor.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %E = call double @llvm.floor.f64(double %D)
   %F = fptrunc double %E to float
@@ -364,10 +364,10 @@ define float @test_no_shrink_intrin_floor(double %D) {
 }
 
 define float @test_no_shrink_intrin_ceil(double %D) {
-; ALL-LABEL: @test_no_shrink_intrin_ceil(
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.ceil.f64(double [[D:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_no_shrink_intrin_ceil(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.ceil.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %E = call double @llvm.ceil.f64(double %D)
   %F = fptrunc double %E to float
@@ -375,10 +375,10 @@ define float @test_no_shrink_intrin_ceil(double %D) {
 }
 
 define float @test_no_shrink_intrin_round(double %D) {
-; ALL-LABEL: @test_no_shrink_intrin_round(
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.round.f64(double [[D:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_no_shrink_intrin_round(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.round.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %E = call double @llvm.round.f64(double %D)
   %F = fptrunc double %E to float
@@ -386,10 +386,10 @@ define float @test_no_shrink_intrin_round(double %D) {
 }
 
 define float @test_no_shrink_intrin_nearbyint(double %D) {
-; ALL-LABEL: @test_no_shrink_intrin_nearbyint(
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.nearbyint.f64(double [[D:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_no_shrink_intrin_nearbyint(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.nearbyint.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %E = call double @llvm.nearbyint.f64(double %D)
   %F = fptrunc double %E to float
@@ -397,10 +397,10 @@ define float @test_no_shrink_intrin_nearbyint(double %D) {
 }
 
 define float @test_no_shrink_intrin_trunc(double %D) {
-; ALL-LABEL: @test_no_shrink_intrin_trunc(
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.trunc.f64(double [[D:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_no_shrink_intrin_trunc(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.trunc.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %E = call double @llvm.trunc.f64(double %D)
   %F = fptrunc double %E to float
@@ -408,10 +408,10 @@ define float @test_no_shrink_intrin_trunc(double %D) {
 }
 
 define float @test_shrink_intrin_fabs_double_src(double %D) {
-; ALL-LABEL: @test_shrink_intrin_fabs_double_src(
-; ALL-NEXT:    [[TMP1:%.*]] = fptrunc double [[D:%.*]] to float
-; ALL-NEXT:    [[F:%.*]] = call float @llvm.fabs.f32(float [[TMP1]])
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_shrink_intrin_fabs_double_src(
+; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc double [[D:%.*]] to float
+; CHECK-NEXT:    [[F:%.*]] = call float @llvm.fabs.f32(float [[TMP1]])
+; CHECK-NEXT:    ret float [[F]]
 ;
   %E = call double @llvm.fabs.f64(double %D)
   %F = fptrunc double %E to float
@@ -420,10 +420,10 @@ define float @test_shrink_intrin_fabs_double_src(double %D) {
 
 ; Make sure fast math flags are preserved
 define float @test_shrink_intrin_fabs_fast_double_src(double %D) {
-; ALL-LABEL: @test_shrink_intrin_fabs_fast_double_src(
-; ALL-NEXT:    [[TMP1:%.*]] = fptrunc double [[D:%.*]] to float
-; ALL-NEXT:    [[F:%.*]] = call fast float @llvm.fabs.f32(float [[TMP1]])
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_shrink_intrin_fabs_fast_double_src(
+; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc double [[D:%.*]] to float
+; CHECK-NEXT:    [[F:%.*]] = call fast float @llvm.fabs.f32(float [[TMP1]])
+; CHECK-NEXT:    ret float [[F]]
 ;
   %E = call fast double @llvm.fabs.f64(double %D)
   %F = fptrunc double %E to float
@@ -431,8 +431,8 @@ define float @test_shrink_intrin_fabs_fast_double_src(double %D) {
 }
 
 define float @test_shrink_float_convertible_constant_intrin_floor() {
-; ALL-LABEL: @test_shrink_float_convertible_constant_intrin_floor(
-; ALL-NEXT:    ret float 2.000000e+00
+; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_floor(
+; CHECK-NEXT:    ret float 2.000000e+00
 ;
   %E = call double @llvm.floor.f64(double 2.1)
   %F = fptrunc double %E to float
@@ -440,8 +440,8 @@ define float @test_shrink_float_convertible_constant_intrin_floor() {
 }
 
 define float @test_shrink_float_convertible_constant_intrin_ceil() {
-; ALL-LABEL: @test_shrink_float_convertible_constant_intrin_ceil(
-; ALL-NEXT:    ret float 3.000000e+00
+; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_ceil(
+; CHECK-NEXT:    ret float 3.000000e+00
 ;
   %E = call double @llvm.ceil.f64(double 2.1)
   %F = fptrunc double %E to float
@@ -449,8 +449,8 @@ define float @test_shrink_float_convertible_constant_intrin_ceil() {
 }
 
 define float @test_shrink_float_convertible_constant_intrin_round() {
-; ALL-LABEL: @test_shrink_float_convertible_constant_intrin_round(
-; ALL-NEXT:    ret float 2.000000e+00
+; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_round(
+; CHECK-NEXT:    ret float 2.000000e+00
 ;
   %E = call double @llvm.round.f64(double 2.1)
   %F = fptrunc double %E to float
@@ -458,8 +458,8 @@ define float @test_shrink_float_convertible_constant_intrin_round() {
 }
 
 define float @test_shrink_float_convertible_constant_intrin_nearbyint() {
-; ALL-LABEL: @test_shrink_float_convertible_constant_intrin_nearbyint(
-; ALL-NEXT:    ret float 2.000000e+00
+; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_nearbyint(
+; CHECK-NEXT:    ret float 2.000000e+00
 ;
   %E = call double @llvm.nearbyint.f64(double 2.1)
   %F = fptrunc double %E to float
@@ -467,8 +467,8 @@ define float @test_shrink_float_convertible_constant_intrin_nearbyint() {
 }
 
 define float @test_shrink_float_convertible_constant_intrin_trunc() {
-; ALL-LABEL: @test_shrink_float_convertible_constant_intrin_trunc(
-; ALL-NEXT:    ret float 2.000000e+00
+; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_trunc(
+; CHECK-NEXT:    ret float 2.000000e+00
 ;
   %E = call double @llvm.trunc.f64(double 2.1)
   %F = fptrunc double %E to float
@@ -476,8 +476,8 @@ define float @test_shrink_float_convertible_constant_intrin_trunc() {
 }
 
 define float @test_shrink_float_convertible_constant_intrin_fabs() {
-; ALL-LABEL: @test_shrink_float_convertible_constant_intrin_fabs(
-; ALL-NEXT:    ret float 0x4000CCCCC0000000
+; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_fabs(
+; CHECK-NEXT:    ret float 0x4000CCCCC0000000
 ;
   %E = call double @llvm.fabs.f64(double 2.1)
   %F = fptrunc double %E to float
@@ -486,8 +486,8 @@ define float @test_shrink_float_convertible_constant_intrin_fabs() {
 
 ; Make sure fast math flags are preserved
 define float @test_shrink_float_convertible_constant_intrin_fabs_fast() {
-; ALL-LABEL: @test_shrink_float_convertible_constant_intrin_fabs_fast(
-; ALL-NEXT:    ret float 0x4000CCCCC0000000
+; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_fabs_fast(
+; CHECK-NEXT:    ret float 0x4000CCCCC0000000
 ;
   %E = call fast double @llvm.fabs.f64(double 2.1)
   %F = fptrunc double %E to float
@@ -495,10 +495,10 @@ define float @test_shrink_float_convertible_constant_intrin_fabs_fast() {
 }
 
 define half @test_no_shrink_mismatched_type_intrin_floor(double %D) {
-; ALL-LABEL: @test_no_shrink_mismatched_type_intrin_floor(
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.floor.f64(double [[D:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
-; ALL-NEXT:    ret half [[F]]
+; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_floor(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.floor.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
+; CHECK-NEXT:    ret half [[F]]
 ;
   %E = call double @llvm.floor.f64(double %D)
   %F = fptrunc double %E to half
@@ -506,10 +506,10 @@ define half @test_no_shrink_mismatched_type_intrin_floor(double %D) {
 }
 
 define half @test_no_shrink_mismatched_type_intrin_ceil(double %D) {
-; ALL-LABEL: @test_no_shrink_mismatched_type_intrin_ceil(
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.ceil.f64(double [[D:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
-; ALL-NEXT:    ret half [[F]]
+; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_ceil(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.ceil.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
+; CHECK-NEXT:    ret half [[F]]
 ;
   %E = call double @llvm.ceil.f64(double %D)
   %F = fptrunc double %E to half
@@ -517,10 +517,10 @@ define half @test_no_shrink_mismatched_type_intrin_ceil(double %D) {
 }
 
 define half @test_no_shrink_mismatched_type_intrin_round(double %D) {
-; ALL-LABEL: @test_no_shrink_mismatched_type_intrin_round(
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.round.f64(double [[D:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
-; ALL-NEXT:    ret half [[F]]
+; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_round(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.round.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
+; CHECK-NEXT:    ret half [[F]]
 ;
   %E = call double @llvm.round.f64(double %D)
   %F = fptrunc double %E to half
@@ -528,10 +528,10 @@ define half @test_no_shrink_mismatched_type_intrin_round(double %D) {
 }
 
 define half @test_no_shrink_mismatched_type_intrin_nearbyint(double %D) {
-; ALL-LABEL: @test_no_shrink_mismatched_type_intrin_nearbyint(
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.nearbyint.f64(double [[D:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
-; ALL-NEXT:    ret half [[F]]
+; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_nearbyint(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.nearbyint.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
+; CHECK-NEXT:    ret half [[F]]
 ;
   %E = call double @llvm.nearbyint.f64(double %D)
   %F = fptrunc double %E to half
@@ -539,10 +539,10 @@ define half @test_no_shrink_mismatched_type_intrin_nearbyint(double %D) {
 }
 
 define half @test_no_shrink_mismatched_type_intrin_trunc(double %D) {
-; ALL-LABEL: @test_no_shrink_mismatched_type_intrin_trunc(
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.trunc.f64(double [[D:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
-; ALL-NEXT:    ret half [[F]]
+; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_trunc(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.trunc.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
+; CHECK-NEXT:    ret half [[F]]
 ;
   %E = call double @llvm.trunc.f64(double %D)
   %F = fptrunc double %E to half
@@ -550,10 +550,10 @@ define half @test_no_shrink_mismatched_type_intrin_trunc(double %D) {
 }
 
 define half @test_shrink_mismatched_type_intrin_fabs_double_src(double %D) {
-; ALL-LABEL: @test_shrink_mismatched_type_intrin_fabs_double_src(
-; ALL-NEXT:    [[TMP1:%.*]] = fptrunc double [[D:%.*]] to half
-; ALL-NEXT:    [[F:%.*]] = call half @llvm.fabs.f16(half [[TMP1]])
-; ALL-NEXT:    ret half [[F]]
+; CHECK-LABEL: @test_shrink_mismatched_type_intrin_fabs_double_src(
+; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc double [[D:%.*]] to half
+; CHECK-NEXT:    [[F:%.*]] = call half @llvm.fabs.f16(half [[TMP1]])
+; CHECK-NEXT:    ret half [[F]]
 ;
   %E = call double @llvm.fabs.f64(double %D)
   %F = fptrunc double %E to half
@@ -562,10 +562,10 @@ define half @test_shrink_mismatched_type_intrin_fabs_double_src(double %D) {
 
 ; Make sure fast math flags are preserved
 define half @test_mismatched_type_intrin_fabs_fast_double_src(double %D) {
-; ALL-LABEL: @test_mismatched_type_intrin_fabs_fast_double_src(
-; ALL-NEXT:    [[TMP1:%.*]] = fptrunc double [[D:%.*]] to half
-; ALL-NEXT:    [[F:%.*]] = call fast half @llvm.fabs.f16(half [[TMP1]])
-; ALL-NEXT:    ret half [[F]]
+; CHECK-LABEL: @test_mismatched_type_intrin_fabs_fast_double_src(
+; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc double [[D:%.*]] to half
+; CHECK-NEXT:    [[F:%.*]] = call fast half @llvm.fabs.f16(half [[TMP1]])
+; CHECK-NEXT:    ret half [[F]]
 ;
   %E = call fast double @llvm.fabs.f64(double %D)
   %F = fptrunc double %E to half
@@ -573,10 +573,10 @@ define half @test_mismatched_type_intrin_fabs_fast_double_src(double %D) {
 }
 
 define <2 x double> @test_shrink_intrin_floor_fp16_vec(<2 x half> %C) {
-; ALL-LABEL: @test_shrink_intrin_floor_fp16_vec(
-; ALL-NEXT:    [[TMP1:%.*]] = call arcp <2 x half> @llvm.floor.v2f16(<2 x half> [[C:%.*]])
-; ALL-NEXT:    [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
-; ALL-NEXT:    ret <2 x double> [[E]]
+; CHECK-LABEL: @test_shrink_intrin_floor_fp16_vec(
+; CHECK-NEXT:    [[TMP1:%.*]] = call arcp <2 x half> @llvm.floor.v2f16(<2 x half> [[C:%.*]])
+; CHECK-NEXT:    [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
+; CHECK-NEXT:    ret <2 x double> [[E]]
 ;
   %D = fpext <2 x half> %C to <2 x double>
   %E = call arcp <2 x double> @llvm.floor.v2f64(<2 x double> %D)
@@ -584,10 +584,10 @@ define <2 x double> @test_shrink_intrin_floor_fp16_vec(<2 x half> %C) {
 }
 
 define float @test_shrink_intrin_ceil_fp16_src(half %C) {
-; ALL-LABEL: @test_shrink_intrin_ceil_fp16_src(
-; ALL-NEXT:    [[TMP1:%.*]] = call half @llvm.ceil.f16(half [[C:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fpext half [[TMP1]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_shrink_intrin_ceil_fp16_src(
+; CHECK-NEXT:    [[TMP1:%.*]] = call half @llvm.ceil.f16(half [[C:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fpext half [[TMP1]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call double @llvm.ceil.f64(double %D)
@@ -596,10 +596,10 @@ define float @test_shrink_intrin_ceil_fp16_src(half %C) {
 }
 
 define <2 x double> @test_shrink_intrin_round_fp16_vec(<2 x half> %C) {
-; ALL-LABEL: @test_shrink_intrin_round_fp16_vec(
-; ALL-NEXT:    [[TMP1:%.*]] = call <2 x half> @llvm.round.v2f16(<2 x half> [[C:%.*]])
-; ALL-NEXT:    [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
-; ALL-NEXT:    ret <2 x double> [[E]]
+; CHECK-LABEL: @test_shrink_intrin_round_fp16_vec(
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x half> @llvm.round.v2f16(<2 x half> [[C:%.*]])
+; CHECK-NEXT:    [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
+; CHECK-NEXT:    ret <2 x double> [[E]]
 ;
   %D = fpext <2 x  half> %C to <2 x double>
   %E = call <2 x double> @llvm.round.v2f64(<2 x double> %D)
@@ -607,10 +607,10 @@ define <2 x double> @test_shrink_intrin_round_fp16_vec(<2 x half> %C) {
 }
 
 define float @test_shrink_intrin_nearbyint_fp16_src(half %C) {
-; ALL-LABEL: @test_shrink_intrin_nearbyint_fp16_src(
-; ALL-NEXT:    [[TMP1:%.*]] = call half @llvm.nearbyint.f16(half [[C:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fpext half [[TMP1]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_shrink_intrin_nearbyint_fp16_src(
+; CHECK-NEXT:    [[TMP1:%.*]] = call half @llvm.nearbyint.f16(half [[C:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fpext half [[TMP1]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call double @llvm.nearbyint.f64(double %D)
@@ -619,10 +619,10 @@ define float @test_shrink_intrin_nearbyint_fp16_src(half %C) {
 }
 
 define <2 x double> @test_shrink_intrin_trunc_fp16_src(<2 x half> %C) {
-; ALL-LABEL: @test_shrink_intrin_trunc_fp16_src(
-; ALL-NEXT:    [[TMP1:%.*]] = call <2 x half> @llvm.trunc.v2f16(<2 x half> [[C:%.*]])
-; ALL-NEXT:    [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
-; ALL-NEXT:    ret <2 x double> [[E]]
+; CHECK-LABEL: @test_shrink_intrin_trunc_fp16_src(
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x half> @llvm.trunc.v2f16(<2 x half> [[C:%.*]])
+; CHECK-NEXT:    [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
+; CHECK-NEXT:    ret <2 x double> [[E]]
 ;
   %D = fpext <2 x half> %C to <2 x double>
   %E = call <2 x double> @llvm.trunc.v2f64(<2 x double> %D)
@@ -630,10 +630,10 @@ define <2 x double> @test_shrink_intrin_trunc_fp16_src(<2 x half> %C) {
 }
 
 define float @test_shrink_intrin_fabs_fp16_src(half %C) {
-; ALL-LABEL: @test_shrink_intrin_fabs_fp16_src(
-; ALL-NEXT:    [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[C:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fpext half [[TMP1]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_shrink_intrin_fabs_fp16_src(
+; CHECK-NEXT:    [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[C:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fpext half [[TMP1]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call double @llvm.fabs.f64(double %D)
@@ -643,10 +643,10 @@ define float @test_shrink_intrin_fabs_fp16_src(half %C) {
 
 ; Make sure fast math flags are preserved
 define float @test_shrink_intrin_fabs_fast_fp16_src(half %C) {
-; ALL-LABEL: @test_shrink_intrin_fabs_fast_fp16_src(
-; ALL-NEXT:    [[TMP1:%.*]] = call fast half @llvm.fabs.f16(half [[C:%.*]])
-; ALL-NEXT:    [[F:%.*]] = fpext half [[TMP1]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_shrink_intrin_fabs_fast_fp16_src(
+; CHECK-NEXT:    [[TMP1:%.*]] = call fast half @llvm.fabs.f16(half [[C:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fpext half [[TMP1]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call fast double @llvm.fabs.f64(double %D)
@@ -655,12 +655,12 @@ define float @test_shrink_intrin_fabs_fast_fp16_src(half %C) {
 }
 
 define float @test_no_shrink_intrin_floor_multi_use_fpext(half %C) {
-; ALL-LABEL: @test_no_shrink_intrin_floor_multi_use_fpext(
-; ALL-NEXT:    [[D:%.*]] = fpext half [[C:%.*]] to double
-; ALL-NEXT:    store volatile double [[D]], double* undef, align 8
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.floor.f64(double [[D]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_no_shrink_intrin_floor_multi_use_fpext(
+; CHECK-NEXT:    [[D:%.*]] = fpext half [[C:%.*]] to double
+; CHECK-NEXT:    store volatile double [[D]], double* undef, align 8
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.floor.f64(double [[D]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   store volatile double %D, double* undef
@@ -670,12 +670,12 @@ define float @test_no_shrink_intrin_floor_multi_use_fpext(half %C) {
 }
 
 define float @test_no_shrink_intrin_fabs_multi_use_fpext(half %C) {
-; ALL-LABEL: @test_no_shrink_intrin_fabs_multi_use_fpext(
-; ALL-NEXT:    [[D:%.*]] = fpext half [[C:%.*]] to double
-; ALL-NEXT:    store volatile double [[D]], double* undef, align 8
-; ALL-NEXT:    [[E:%.*]] = call double @llvm.fabs.f64(double [[D]])
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
-; ALL-NEXT:    ret float [[F]]
+; CHECK-LABEL: @test_no_shrink_intrin_fabs_multi_use_fpext(
+; CHECK-NEXT:    [[D:%.*]] = fpext half [[C:%.*]] to double
+; CHECK-NEXT:    store volatile double [[D]], double* undef, align 8
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.fabs.f64(double [[D]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
+; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   store volatile double %D, double* undef