declare double @llvm.fma.f64(double, double, double)
define float @test_fmadd(float %a, float %b, float %c) {
-; CHECK: test_fmadd:
-; CHECK-NOFAST: test_fmadd:
+; CHECK-LABEL: test_fmadd:
+; CHECK-NOFAST-LABEL: test_fmadd:
%val = call float @llvm.fma.f32(float %a, float %b, float %c)
; CHECK: fmadd {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
; CHECK-NOFAST: fmadd {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}
define float @test_fmsub(float %a, float %b, float %c) {
-; CHECK: test_fmsub:
-; CHECK-NOFAST: test_fmsub:
+; CHECK-LABEL: test_fmsub:
+; CHECK-NOFAST-LABEL: test_fmsub:
%nega = fsub float -0.0, %a
%val = call float @llvm.fma.f32(float %nega, float %b, float %c)
; CHECK: fmsub {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}
define float @test_fnmadd(float %a, float %b, float %c) {
-; CHECK: test_fnmadd:
-; CHECK-NOFAST: test_fnmadd:
+; CHECK-LABEL: test_fnmadd:
+; CHECK-NOFAST-LABEL: test_fnmadd:
%negc = fsub float -0.0, %c
%val = call float @llvm.fma.f32(float %a, float %b, float %negc)
; CHECK: fnmadd {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}
define float @test_fnmsub(float %a, float %b, float %c) {
-; CHECK: test_fnmsub:
-; CHECK-NOFAST: test_fnmsub:
+; CHECK-LABEL: test_fnmsub:
+; CHECK-NOFAST-LABEL: test_fnmsub:
%nega = fsub float -0.0, %a
%negc = fsub float -0.0, %c
%val = call float @llvm.fma.f32(float %nega, float %b, float %negc)
}
define float @test_fmadd_unfused(float %a, float %b, float %c) {
-; CHECK: test_fmadd_unfused:
-; CHECK-NOFAST: test_fmadd_unfused:
+; CHECK-LABEL: test_fmadd_unfused:
+; CHECK-NOFAST-LABEL: test_fmadd_unfused:
%prod = fmul float %b, %c
%sum = fadd float %a, %prod
; CHECK: fmadd {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}
define float @test_fmsub_unfused(float %a, float %b, float %c) {
-; CHECK: test_fmsub_unfused:
-; CHECK-NOFAST: test_fmsub_unfused:
+; CHECK-LABEL: test_fmsub_unfused:
+; CHECK-NOFAST-LABEL: test_fmsub_unfused:
%prod = fmul float %b, %c
%diff = fsub float %a, %prod
; CHECK: fmsub {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}
define float @test_fnmadd_unfused(float %a, float %b, float %c) {
-; CHECK: test_fnmadd_unfused:
-; CHECK-NOFAST: test_fnmadd_unfused:
+; CHECK-LABEL: test_fnmadd_unfused:
+; CHECK-NOFAST-LABEL: test_fnmadd_unfused:
%nega = fsub float -0.0, %a
%prod = fmul float %b, %c
%sum = fadd float %nega, %prod
}
define float @test_fnmsub_unfused(float %a, float %b, float %c) {
-; CHECK: test_fnmsub_unfused:
-; CHECK-NOFAST: test_fnmsub_unfused:
+; CHECK-LABEL: test_fnmsub_unfused:
+; CHECK-NOFAST-LABEL: test_fnmsub_unfused:
%nega = fsub float -0.0, %a
%prod = fmul float %b, %c
%diff = fsub float %nega, %prod
declare fp128 @llvm.cos.f128(fp128)
define void @test_cos(float %float, double %double, fp128 %fp128) {
-; CHECK: test_cos:
+; CHECK-LABEL: test_cos:
%cosfloat = call float @llvm.cos.f32(float %float)
store float %cosfloat, float* @varfloat
declare fp128 @llvm.exp.f128(fp128)
define void @test_exp(float %float, double %double, fp128 %fp128) {
-; CHECK: test_exp:
+; CHECK-LABEL: test_exp:
%expfloat = call float @llvm.exp.f32(float %float)
store float %expfloat, float* @varfloat
declare fp128 @llvm.exp2.f128(fp128)
define void @test_exp2(float %float, double %double, fp128 %fp128) {
-; CHECK: test_exp2:
+; CHECK-LABEL: test_exp2:
%exp2float = call float @llvm.exp2.f32(float %float)
store float %exp2float, float* @varfloat
declare fp128 @llvm.log.f128(fp128)
define void @test_log(float %float, double %double, fp128 %fp128) {
-; CHECK: test_log:
+; CHECK-LABEL: test_log:
%logfloat = call float @llvm.log.f32(float %float)
store float %logfloat, float* @varfloat
declare fp128 @llvm.log2.f128(fp128)
define void @test_log2(float %float, double %double, fp128 %fp128) {
-; CHECK: test_log2:
+; CHECK-LABEL: test_log2:
%log2float = call float @llvm.log2.f32(float %float)
store float %log2float, float* @varfloat
declare fp128 @llvm.log10.f128(fp128)
define void @test_log10(float %float, double %double, fp128 %fp128) {
-; CHECK: test_log10:
+; CHECK-LABEL: test_log10:
%log10float = call float @llvm.log10.f32(float %float)
store float %log10float, float* @varfloat
declare fp128 @llvm.sin.f128(fp128)
define void @test_sin(float %float, double %double, fp128 %fp128) {
-; CHECK: test_sin:
+; CHECK-LABEL: test_sin:
%sinfloat = call float @llvm.sin.f32(float %float)
store float %sinfloat, float* @varfloat
declare fp128 @llvm.pow.f128(fp128, fp128)
define void @test_pow(float %float, double %double, fp128 %fp128) {
-; CHECK: test_pow:
+; CHECK-LABEL: test_pow:
%powfloat = call float @llvm.pow.f32(float %float, float %float)
store float %powfloat, float* @varfloat
declare fp128 @llvm.powi.f128(fp128, i32)
define void @test_powi(float %float, double %double, i32 %exponent, fp128 %fp128) {
-; CHECK: test_powi:
+; CHECK-LABEL: test_powi:
%powifloat = call float @llvm.powi.f32(float %float, i32 %exponent)
store float %powifloat, float* @varfloat
}
define void @test_frem(float %float, double %double, fp128 %fp128) {
-; CHECK: test_frem:
+; CHECK-LABEL: test_frem:
%fremfloat = frem float %float, %float
store float %fremfloat, float* @varfloat
declare fp128 @llvm.fma.f128(fp128, fp128, fp128)
define void @test_fma(fp128 %fp128) {
-; CHECK: test_fma:
+; CHECK-LABEL: test_fma:
%fmafp128 = call fp128 @llvm.fma.f128(fp128 %fp128, fp128 %fp128, fp128 %fp128)
store fp128 %fmafp128, fp128* @varfp128
declare fp128 @llvm.fmuladd.f128(fp128, fp128, fp128)
define void @test_fmuladd(fp128 %fp128) {
-; CHECK: test_fmuladd:
+; CHECK-LABEL: test_fmuladd:
%fmuladdfp128 = call fp128 @llvm.fmuladd.f128(fp128 %fp128, fp128 %fp128, fp128 %fp128)
store fp128 %fmuladdfp128, fp128* @varfp128
; The zeroext param attribute below is meant to have no effect
define i16 @test_identity(i16 zeroext %x) {
entry:
-; CHECKELF: test_identity:
+; CHECKELF-LABEL: test_identity:
; CHECKELF: mov [[SAVEX:r[0-9]+]], r0
; CHECKELF: bl identity16
; CHECKELF: uxth r0, r0
; CHECKELF: bl identity32
; CHECKELF: mov r0, [[SAVEX]]
-; CHECKT2D: test_identity:
+; CHECKT2D-LABEL: test_identity:
; CHECKT2D: mov [[SAVEX:r[0-9]+]], r0
; CHECKT2D: blx _identity16
; CHECKT2D: uxth r0, r0
; x is not considered equal to %call (see SelectionDAGBuilder.cpp)
define i16 @test_matched_ret(i16 %x) {
entry:
-; CHECKELF: test_matched_ret:
+; CHECKELF-LABEL: test_matched_ret:
; This shouldn't be required
; CHECKELF: mov [[SAVEX:r[0-9]+]], r0
; This shouldn't be required
; CHECKELF: mov r0, [[SAVEX]]
-; CHECKT2D: test_matched_ret:
+; CHECKT2D-LABEL: test_matched_ret:
; This shouldn't be required
; CHECKT2D: mov [[SAVEX:r[0-9]+]], r0
define i16 @test_mismatched_ret(i16 %x) {
entry:
-; CHECKELF: test_mismatched_ret:
+; CHECKELF-LABEL: test_mismatched_ret:
; CHECKELF: mov [[SAVEX:r[0-9]+]], r0
; CHECKELF: bl retzext16
; CHECKELF: sxth r0, {{r[0-9]+}}
; CHECKELF: bl identity32
; CHECKELF: mov r0, [[SAVEX]]
-; CHECKT2D: test_mismatched_ret:
+; CHECKT2D-LABEL: test_mismatched_ret:
; CHECKT2D: mov [[SAVEX:r[0-9]+]], r0
; CHECKT2D: blx _retzext16
; CHECKT2D: sxth r0, {{r[0-9]+}}
define i16 @test_matched_paramext(i16 %x) {
entry:
-; CHECKELF: test_matched_paramext:
+; CHECKELF-LABEL: test_matched_paramext:
; CHECKELF: uxth r0, r0
; CHECKELF: bl paramzext16
; CHECKELF: uxth r0, r0
; CHECKELF: bl identity32
; CHECKELF: b paramzext16
-; CHECKT2D: test_matched_paramext:
+; CHECKT2D-LABEL: test_matched_paramext:
; CHECKT2D: uxth r0, r0
; CHECKT2D: blx _paramzext16
; CHECKT2D: uxth r0, r0
; optimization, don't bother checking: just verify that the calls are made
; in the correct order as a basic sanity check
-; CHECKELF: test_matched_paramext2:
+; CHECKELF-LABEL: test_matched_paramext2:
; CHECKELF: bl paramzext16
; CHECKELF: bl identity32
; CHECKELF: b paramzext16
-; CHECKT2D: test_matched_paramext2:
+; CHECKT2D-LABEL: test_matched_paramext2:
; CHECKT2D: blx _paramzext16
; CHECKT2D: blx _identity32
; CHECKT2D: b.w _paramzext16
define i16 @test_matched_bothext(i16 %x) {
entry:
-; CHECKELF: test_matched_bothext:
+; CHECKELF-LABEL: test_matched_bothext:
; CHECKELF: uxth r0, r0
; CHECKELF: bl bothzext16
; CHECKELF-NOT: uxth r0, r0
; FIXME: Tail call should be OK here
; CHECKELF: bl identity32
-; CHECKT2D: test_matched_bothext:
+; CHECKT2D-LABEL: test_matched_bothext:
; CHECKT2D: uxth r0, r0
; CHECKT2D: blx _bothzext16
; CHECKT2D-NOT: uxth r0, r0
define i16 @test_mismatched_bothext(i16 %x) {
entry:
-; CHECKELF: test_mismatched_bothext:
+; CHECKELF-LABEL: test_mismatched_bothext:
; CHECKELF: mov [[SAVEX:r[0-9]+]], r0
; CHECKELF: uxth r0, {{r[0-9]+}}
; CHECKELF: bl bothzext16
; CHECKELF: sxth r0, [[SAVEX]]
; CHECKELF: bl identity32
; CHECKELF: mov r0, [[SAVEX]]
-; CHECKT2D: test_mismatched_bothext:
+; CHECKT2D-LABEL: test_mismatched_bothext:
; CHECKT2D: mov [[SAVEX:r[0-9]+]], r0
; CHECKT2D: uxth r0, {{r[0-9]+}}
; CHECKT2D: blx _bothzext16
define %struct.C* @C_ctor_base(%struct.C* returned %this, i32 %x) {
entry:
-; CHECKELF: C_ctor_base:
+; CHECKELF-LABEL: C_ctor_base:
; CHECKELF-NOT: mov {{r[0-9]+}}, r0
; CHECKELF: bl A_ctor_base
; CHECKELF-NOT: mov r0, {{r[0-9]+}}
; CHECKELF: b B_ctor_base
-; CHECKT2D: C_ctor_base:
+; CHECKT2D-LABEL: C_ctor_base:
; CHECKT2D-NOT: mov {{r[0-9]+}}, r0
; CHECKT2D: blx _A_ctor_base
; CHECKT2D-NOT: mov r0, {{r[0-9]+}}
define %struct.C* @C_ctor_base_nothisret(%struct.C* %this, i32 %x) {
entry:
-; CHECKELF: C_ctor_base_nothisret:
+; CHECKELF-LABEL: C_ctor_base_nothisret:
; CHECKELF: mov [[SAVETHIS:r[0-9]+]], r0
; CHECKELF: bl A_ctor_base_nothisret
; CHECKELF: mov r0, [[SAVETHIS]]
; CHECKELF-NOT: b B_ctor_base_nothisret
-; CHECKT2D: C_ctor_base_nothisret:
+; CHECKT2D-LABEL: C_ctor_base_nothisret:
; CHECKT2D: mov [[SAVETHIS:r[0-9]+]], r0
; CHECKT2D: blx _A_ctor_base_nothisret
; CHECKT2D: mov r0, [[SAVETHIS]]
define %struct.C* @C_ctor_complete(%struct.C* %this, i32 %x) {
entry:
-; CHECKELF: C_ctor_complete:
+; CHECKELF-LABEL: C_ctor_complete:
; CHECKELF: b C_ctor_base
-; CHECKT2D: C_ctor_complete:
+; CHECKT2D-LABEL: C_ctor_complete:
; CHECKT2D: b.w _C_ctor_base
%call = tail call %struct.C* @C_ctor_base(%struct.C* %this, i32 %x)
ret %struct.C* %this
define %struct.C* @C_ctor_complete_nothisret(%struct.C* %this, i32 %x) {
entry:
-; CHECKELF: C_ctor_complete_nothisret:
+; CHECKELF-LABEL: C_ctor_complete_nothisret:
; CHECKELF-NOT: b C_ctor_base_nothisret
-; CHECKT2D: C_ctor_complete_nothisret:
+; CHECKT2D-LABEL: C_ctor_complete_nothisret:
; CHECKT2D-NOT: b.w _C_ctor_base_nothisret
%call = tail call %struct.C* @C_ctor_base_nothisret(%struct.C* %this, i32 %x)
ret %struct.C* %this
define %struct.D* @D_ctor_base(%struct.D* %this, i32 %x) {
entry:
-; CHECKELF: D_ctor_base:
+; CHECKELF-LABEL: D_ctor_base:
; CHECKELF-NOT: mov {{r[0-9]+}}, r0
; CHECKELF: bl B_ctor_complete
; CHECKELF-NOT: mov r0, {{r[0-9]+}}
; CHECKELF: b B_ctor_complete
-; CHECKT2D: D_ctor_base:
+; CHECKT2D-LABEL: D_ctor_base:
; CHECKT2D-NOT: mov {{r[0-9]+}}, r0
; CHECKT2D: blx _B_ctor_complete
; CHECKT2D-NOT: mov r0, {{r[0-9]+}}
define %struct.E* @E_ctor_base(%struct.E* %this, i32 %x) {
entry:
-; CHECKELF: E_ctor_base:
+; CHECKELF-LABEL: E_ctor_base:
; CHECKELF-NOT: b B_ctor_complete
-; CHECKT2D: E_ctor_base:
+; CHECKT2D-LABEL: E_ctor_base:
; CHECKT2D-NOT: b.w _B_ctor_complete
%b = getelementptr inbounds %struct.E* %this, i32 0, i32 0
%call = tail call %struct.B* @B_ctor_complete(%struct.B* %b, i32 %x)
ret <2 x float> %fmuladd
}
; fmuladd (<2 x float>) is promoted to fmuladd (<4 x float>)
-; CHECK: v2f32_fmuladd:
+; CHECK-LABEL: v2f32_fmuladd:
; CHECK: vmaddfp {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}
define <4 x float> @v4f32_fmuladd(<4 x float> %x) nounwind readnone {
%fmuladd = call <4 x float> @llvm.fmuladd.v4f32 (<4 x float> %x, <4 x float> %x, <4 x float> %x)
ret <4 x float> %fmuladd
}
-; CHECK: v4f32_fmuladd:
+; CHECK-LABEL: v4f32_fmuladd:
; CHECK: vmaddfp {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}
define <8 x float> @v8f32_fmuladd(<8 x float> %x) nounwind readnone {
%fmuladd = call <8 x float> @llvm.fmuladd.v8f32 (<8 x float> %x, <8 x float> %x, <8 x float> %x)
ret <8 x float> %fmuladd
}
-; CHECK: v8f32_fmuladd:
+; CHECK-LABEL: v8f32_fmuladd:
; CHECK: vmaddfp {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}
; CHECK: vmaddfp {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}
%fmuladd = call <2 x double> @llvm.fmuladd.v2f64 (<2 x double> %x, <2 x double> %x, <2 x double> %x)
ret <2 x double> %fmuladd
}
-; CHECK: v2f64_fmuladd:
+; CHECK-LABEL: v2f64_fmuladd:
; CHECK: fmadd {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}
; CHECK: fmadd {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}
%fmuladd = call <4 x double> @llvm.fmuladd.v4f64 (<4 x double> %x, <4 x double> %x, <4 x double> %x)
ret <4 x double> %fmuladd
}
-; CHECK: v4f64_fmuladd:
+; CHECK-LABEL: v4f64_fmuladd:
; CHECK: fmadd {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}
; CHECK: fmadd {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}
; CHECK: fmadd {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}, {{[0-9]+}}
; RUN: llc -march=x86 -mcpu=bdver2 -mattr=-fma -mtriple=x86_64-apple-darwin < %s | FileCheck %s
; RUN: llc -march=x86 -mcpu=bdver2 -mattr=-fma,-fma4 -mtriple=x86_64-apple-darwin < %s | FileCheck %s --check-prefix=CHECK-NOFMA
-; CHECK: fmafunc
+; CHECK-LABEL: fmafunc
define <3 x float> @fmafunc(<3 x float> %a, <3 x float> %b, <3 x float> %c) {
; CHECK-NOT: vmulps
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=bdver2 -mattr=-fma4 -fp-contract=fast | FileCheck %s
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=bdver1 -fp-contract=fast | FileCheck %s --check-prefix=CHECK_FMA4
-; CHECK: test_x86_fmadd_ps_y_wide
+; CHECK-LABEL: test_x86_fmadd_ps_y_wide
; CHECK: vfmadd213ps
; CHECK: vfmadd213ps
; CHECK: ret
-; CHECK_FMA4: test_x86_fmadd_ps_y_wide
+; CHECK_FMA4-LABEL: test_x86_fmadd_ps_y_wide
; CHECK_FMA4: vfmaddps
; CHECK_FMA4: vfmaddps
; CHECK_FMA4: ret
ret <16 x float> %res
}
-; CHECK: test_x86_fmsub_ps_y_wide
+; CHECK-LABEL: test_x86_fmsub_ps_y_wide
; CHECK: vfmsub213ps
; CHECK: vfmsub213ps
; CHECK: ret
-; CHECK_FMA4: test_x86_fmsub_ps_y_wide
+; CHECK_FMA4-LABEL: test_x86_fmsub_ps_y_wide
; CHECK_FMA4: vfmsubps
; CHECK_FMA4: vfmsubps
; CHECK_FMA4: ret
ret <16 x float> %res
}
-; CHECK: test_x86_fnmadd_ps_y_wide
+; CHECK-LABEL: test_x86_fnmadd_ps_y_wide
; CHECK: vfnmadd213ps
; CHECK: vfnmadd213ps
; CHECK: ret
-; CHECK_FMA4: test_x86_fnmadd_ps_y_wide
+; CHECK_FMA4-LABEL: test_x86_fnmadd_ps_y_wide
; CHECK_FMA4: vfnmaddps
; CHECK_FMA4: vfnmaddps
; CHECK_FMA4: ret
ret <16 x float> %res
}
-; CHECK: test_x86_fnmsub_ps_y_wide
+; CHECK-LABEL: test_x86_fnmsub_ps_y_wide
; CHECK: vfnmsub213ps
; CHECK: vfnmsub213ps
; CHECK: ret
ret <16 x float> %res
}
-; CHECK: test_x86_fmadd_pd_y_wide
+; CHECK-LABEL: test_x86_fmadd_pd_y_wide
; CHECK: vfmadd213pd
; CHECK: vfmadd213pd
; CHECK: ret
-; CHECK_FMA4: test_x86_fmadd_pd_y_wide
+; CHECK_FMA4-LABEL: test_x86_fmadd_pd_y_wide
; CHECK_FMA4: vfmaddpd
; CHECK_FMA4: vfmaddpd
; CHECK_FMA4: ret
ret <8 x double> %res
}
-; CHECK: test_x86_fmsub_pd_y_wide
+; CHECK-LABEL: test_x86_fmsub_pd_y_wide
; CHECK: vfmsub213pd
; CHECK: vfmsub213pd
; CHECK: ret
-; CHECK_FMA4: test_x86_fmsub_pd_y_wide
+; CHECK_FMA4-LABEL: test_x86_fmsub_pd_y_wide
; CHECK_FMA4: vfmsubpd
; CHECK_FMA4: vfmsubpd
; CHECK_FMA4: ret
; RUN: llc -march=x86-64 -mattr=+avx,-fma4 -mtriple=x86_64-apple-darwin -enable-unsafe-fp-math < %s | FileCheck %s
-; CHECK: test1
+; CHECK-LABEL: test1
define float @test1(float %a) {
; CHECK-NOT: addss
; CHECK: mulss
ret float %r
}
-; CHECK: test2
+; CHECK-LABEL: test2
define float @test2(float %a) {
; CHECK-NOT: addss
; CHECK: mulss
ret float %r
}
-; CHECK: test3
+; CHECK-LABEL: test3
define float @test3(float %a) {
; CHECK-NOT: addss
; CHECK: mulss
ret float %r
}
-; CHECK: test4
+; CHECK-LABEL: test4
define float @test4(float %a) {
; CHECK-NOT: addss
; CHECK: mulss
ret float %r
}
-; CHECK: test5
+; CHECK-LABEL: test5
define float @test5(float %a) {
; CHECK-NOT: addss
; CHECK: mulss
ret float %r
}
-; CHECK: test6
+; CHECK-LABEL: test6
define float @test6(float %a) {
; CHECK-NOT: addss
; CHECK: xorps
ret float %r
}
-; CHECK: test7
+; CHECK-LABEL: test7
define float @test7(float %a) {
; CHECK-NOT: addss
; CHECK: xorps
ret float %r
}
-; CHECK: test8
+; CHECK-LABEL: test8
define float @test8(float %a) {
; CHECK-NOT: fma
; CHECK-NOT: mul
ret float %t2
}
-; CHECK: test9
+; CHECK-LABEL: test9
define float @test9(float %a) {
; CHECK-NOT: fma
; CHECK-NOT: mul
ret float %t2
}
-; CHECK: test10
+; CHECK-LABEL: test10
define float @test10(float %a) {
; CHECK-NOT: add
; CHECK: vxorps
ret float %t2
}
-; CHECK: test11
+; CHECK-LABEL: test11
define float @test11(float %a) {
; CHECK-NOT: add
; CHECK: vxorps
%A = tail call i64 @testi()
ret i64 %A
}
-; CHECK: test_trivial:
+; CHECK-LABEL: test_trivial:
; CHECK: jmp _testi ## TAILCALL
%B = bitcast i64 %A to i64
ret i64 %B
}
-; CHECK: test_noop_bitcast:
+; CHECK-LABEL: test_noop_bitcast:
; CHECK: jmp _testi ## TAILCALL
ret i8* %B
}
-; CHECK: test_inttoptr:
+; CHECK-LABEL: test_inttoptr:
; CHECK: jmp _testi ## TAILCALL
%B = bitcast <4 x float> %A to <4 x i32>
ret <4 x i32> %B
}
-; CHECK: test_vectorbitcast:
+; CHECK-LABEL: test_vectorbitcast:
; CHECK: jmp _testv ## TAILCALL
%A = tail call { i64, i64} @testp()
ret { i64, i64} %A
}
-; CHECK: test_pair_trivial:
+; CHECK-LABEL: test_pair_trivial:
; CHECK: jmp _testp ## TAILCALL
define {i64, i64} @test_pair_notail() {
ret { i64, i64} %c
}
-; CHECK: test_pair_notail:
+; CHECK-LABEL: test_pair_notail:
; CHECK-NOT: jmp _testi
define {i64, i64} @test_pair_extract_trivial() {
ret { i64, i64} %c
}
-; CHECK: test_pair_extract_trivial:
+; CHECK-LABEL: test_pair_extract_trivial:
; CHECK: jmp _testp ## TAILCALL
define {i64, i64} @test_pair_extract_notail() {
ret { i64, i64} %c
}
-; CHECK: test_pair_extract_notail:
+; CHECK-LABEL: test_pair_extract_notail:
; CHECK-NOT: jmp _testp
define {i8*, i64} @test_pair_extract_conv() {
ret { i8*, i64} %c
}
-; CHECK: test_pair_extract_conv:
+; CHECK-LABEL: test_pair_extract_conv:
; CHECK: jmp _testp ## TAILCALL
define {i64, i64} @test_pair_extract_multiple() {
ret { i64, i64} %e
}
-; CHECK: test_pair_extract_multiple:
+; CHECK-LABEL: test_pair_extract_multiple:
; CHECK: jmp _testp ## TAILCALL
define {i64, i64} @test_pair_extract_undef() {
ret { i64, i64} %b
}
-; CHECK: test_pair_extract_undef:
+; CHECK-LABEL: test_pair_extract_undef:
; CHECK: jmp _testp ## TAILCALL
declare { i64, { i32, i32 } } @testn()
ret { i64, { i32, i32}} %c
}
-; CHECK: test_nest:
+; CHECK-LABEL: test_nest:
; CHECK: jmp _testn ## TAILCALL
%struct.A = type { i32 }
ret %struct.A* %x
}
-; CHECK: test_upcast:
+; CHECK-LABEL: test_upcast:
; CHECK: jmp _testu ## TAILCALL
; PR13006
; return funcs[n](0, 0, 0, 0, 0, 0);
; }
;
-; CHECK: rdar12282281
+; CHECK-LABEL: rdar12282281
; CHECK: jmpq *%r11 # TAILCALL
@funcs = external constant [0 x i32 (i8*, ...)*]
define x86_fp80 @fp80_call(x86_fp80 %x) nounwind {
entry:
-; CHECK: fp80_call:
+; CHECK-LABEL: fp80_call:
; CHECK: jmp _fp80_callee
%call = tail call x86_fp80 @fp80_callee(x86_fp80 %x) nounwind
ret x86_fp80 %call
; rdar://12229511
define x86_fp80 @trunc_fp80(x86_fp80 %x) nounwind {
entry:
-; CHECK: trunc_fp80
+; CHECK-LABEL: trunc_fp80
; CHECK: callq _trunc
; CHECK-NOT: jmp _trunc
; CHECK: ret
define %struct.C* @C_ctor(%struct.C* %this, i32 %y) {
entry:
-; CHECK: C_ctor:
+; CHECK-LABEL: C_ctor:
; CHECK: jmp B_ctor # TAILCALL
%0 = getelementptr inbounds %struct.C* %this, i64 0, i32 0
%call = tail call %struct.B* @B_ctor(%struct.B* %0, i32 %y)
define %struct.C* @C_ctor_nothisret(%struct.C* %this, i32 %y) {
entry:
-; CHECK: C_ctor_nothisret:
+; CHECK-LABEL: C_ctor_nothisret:
; CHECK-NOT: jmp B_ctor_nothisret
%0 = getelementptr inbounds %struct.C* %this, i64 0, i32 0
%call = tail call %struct.B* @B_ctor_nothisret(%struct.B* %0, i32 %y)
define %struct.D* @D_ctor(%struct.D* %this, i32 %y) {
entry:
-; CHECK: D_ctor:
+; CHECK-LABEL: D_ctor:
; CHECK: movq %rcx, [[SAVETHIS:%r[0-9a-z]+]]
; CHECK: callq A_ctor
; CHECK: movq [[SAVETHIS]], %rcx
define %struct.D* @D_ctor_nothisret(%struct.D* %this, i32 %y) {
entry:
-; CHECK: D_ctor_nothisret:
+; CHECK-LABEL: D_ctor_nothisret:
; CHECK: movq %rcx, [[SAVETHIS:%r[0-9a-z]+]]
; CHECK: callq A_ctor_nothisret
; CHECK: movq [[SAVETHIS]], %rcx
define %struct.E* @E_ctor(%struct.E* %this, i32 %x) {
entry:
-; CHECK: E_ctor:
+; CHECK-LABEL: E_ctor:
; CHECK: movq %rcx, [[SAVETHIS:%r[0-9a-z]+]]
; CHECK: callq B_ctor
; CHECK: movq [[SAVETHIS]], %rcx
define %struct.E* @E_ctor_nothisret(%struct.E* %this, i32 %x) {
entry:
-; CHECK: E_ctor_nothisret:
+; CHECK-LABEL: E_ctor_nothisret:
; CHECK: movq %rcx, [[SAVETHIS:%r[0-9a-z]+]]
; CHECK: callq B_ctor_nothisret
; CHECK: movq [[SAVETHIS]], %rcx
; RUN: llc -march=x86 -mcpu=bdver2 -mattr=-fma -mtriple=x86_64-apple-darwin < %s | FileCheck %s
; RUN: llc -march=x86 -mcpu=bdver2 -mattr=-fma,-fma4 -mtriple=x86_64-apple-darwin < %s | FileCheck %s --check-prefix=CHECK-NOFMA
-; CHECK: fmafunc
+; CHECK-LABEL: fmafunc
+; CHECK-NOFMA-LABEL: fmafunc
define <16 x float> @fmafunc(<16 x float> %a, <16 x float> %b, <16 x float> %c) {
; CHECK-NOT: vmulps
%Ty = type { i32, i32 }
; sanity check that the argument and return value are both dead
-; CHECK: define internal void @test1()
+; CHECK-LABEL: define internal void @test1()
define internal %Ty* @test1(%Ty* %this) {
ret %Ty* %this
}
; do not keep alive the return value of a function with a dead 'returned' argument
-; CHECK: define internal void @test2()
+; CHECK-LABEL: define internal void @test2()
define internal %Ty* @test2(%Ty* returned %this) {
ret %Ty* %this
@dummy = global %Ty* null
; sanity check that return value is dead
-; CHECK: define internal void @test3(%Ty* %this)
+; CHECK-LABEL: define internal void @test3(%Ty* %this)
define internal %Ty* @test3(%Ty* %this) {
store volatile %Ty* %this, %Ty** @dummy
}
; keep alive return value of a function if the 'returned' argument is live
-; CHECK: define internal %Ty* @test4(%Ty* returned %this)
+; CHECK-LABEL: define internal %Ty* @test4(%Ty* returned %this)
define internal %Ty* @test4(%Ty* returned %this) {
store volatile %Ty* %this, %Ty** @dummy
}
; don't do this if 'returned' is on the call site...
-; CHECK: define internal void @test5(%Ty* %this)
+; CHECK-LABEL: define internal void @test5(%Ty* %this)
define internal %Ty* @test5(%Ty* %this) {
store volatile %Ty* %this, %Ty** @dummy