From c122c77f4466f865f39fe65eb592175be7891678 Mon Sep 17 00:00:00 2001 From: Trevor Gross Date: Fri, 11 Jul 2025 22:29:03 -0400 Subject: [PATCH] [Test] Mark a number of libcall tests `nounwind` Many tests for floating point libcalls include CFI directives, which isn't needed for the purpose of these tests. Mark some of the relevantt test functions `nounwind` in order to remove this noise. --- llvm/test/CodeGen/AArch64/fsincos.ll | 452 +++++----------- llvm/test/CodeGen/AArch64/llvm.frexp.ll | 488 ++++-------------- llvm/test/CodeGen/AArch64/llvm.sincos.ll | 106 +--- llvm/test/CodeGen/Mips/ldexp.ll | 32 +- llvm/test/CodeGen/PowerPC/exp10-libcall.ll | 12 +- llvm/test/CodeGen/PowerPC/ldexp-libcall.ll | 18 +- llvm/test/CodeGen/PowerPC/ldexp.ll | 47 +- llvm/test/CodeGen/PowerPC/llvm.frexp.ll | 87 +--- llvm/test/CodeGen/SystemZ/fp-half-libcall.ll | 76 +-- llvm/test/CodeGen/X86/exp10-libcall.ll | 12 +- llvm/test/CodeGen/X86/ldexp-f80.ll | 8 +- llvm/test/CodeGen/X86/ldexp-libcall.ll | 8 +- llvm/test/CodeGen/X86/ldexp-not-readonly.ll | 8 +- llvm/test/CodeGen/X86/ldexp-strict.ll | 14 +- .../test/CodeGen/X86/ldexp-wrong-signature.ll | 8 +- .../CodeGen/X86/ldexp-wrong-signature2.ll | 8 +- llvm/test/CodeGen/X86/ldexp.ll | 80 +-- llvm/test/CodeGen/X86/llvm.frexp.f80.ll | 16 +- llvm/test/CodeGen/X86/llvm.frexp.ll | 66 +-- llvm/test/CodeGen/X86/sincos-stack-args.ll | 4 +- llvm/test/CodeGen/X86/sincos.ll | 18 +- 21 files changed, 373 insertions(+), 1195 deletions(-) diff --git a/llvm/test/CodeGen/AArch64/fsincos.ll b/llvm/test/CodeGen/AArch64/fsincos.ll index 2afc56a7139fb..98ba908da409e 100644 --- a/llvm/test/CodeGen/AArch64/fsincos.ll +++ b/llvm/test/CodeGen/AArch64/fsincos.ll @@ -20,12 +20,10 @@ entry: ret float %c } -define half @sin_f16(half %a) { +define half @sin_f16(half %a) nounwind { ; CHECK-LABEL: sin_f16: ; CHECK: // %bb.0: // %entry ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: fcvt s0, h0 ; CHECK-NEXT: bl sinf ; CHECK-NEXT: fcvt h0, s0 @@ -45,12 +43,10 @@ entry: ret fp128 %c } -define <1 x double> @sin_v1f64(<1 x double> %x) { +define <1 x double> @sin_v1f64(<1 x double> %x) nounwind { ; CHECK-LABEL: sin_v1f64: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: bl sin ; CHECK-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ret @@ -58,15 +54,13 @@ define <1 x double> @sin_v1f64(<1 x double> %x) { ret <1 x double> %c } -define <2 x double> @sin_v2f64(<2 x double> %a) { +define <2 x double> @sin_v2f64(<2 x double> %a) nounwind { ; CHECK-SD-LABEL: sin_v2f64: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-SD-NEXT: mov d0, v0.d[1] +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl sin ; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill @@ -84,12 +78,9 @@ define <2 x double> @sin_v2f64(<2 x double> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #32 ; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 ; CHECK-GI-NEXT: mov d8, v0.d[1] ; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 +; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill ; CHECK-GI-NEXT: bl sin ; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -108,19 +99,14 @@ entry: ret <2 x double> %c } -define <3 x double> @sin_v3f64(<3 x double> %a) { +define <3 x double> @sin_v3f64(<3 x double> %a) nounwind { ; CHECK-SD-LABEL: sin_v3f64: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: str d10, [sp, #-32]! // 8-byte Folded Spill ; CHECK-SD-NEXT: stp d9, d8, [sp, #8] // 16-byte Folded Spill -; CHECK-SD-NEXT: str x30, [sp, #24] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 32 -; CHECK-SD-NEXT: .cfi_offset w30, -8 -; CHECK-SD-NEXT: .cfi_offset b8, -16 -; CHECK-SD-NEXT: .cfi_offset b9, -24 -; CHECK-SD-NEXT: .cfi_offset b10, -32 ; CHECK-SD-NEXT: fmov d8, d2 ; CHECK-SD-NEXT: fmov d9, d1 +; CHECK-SD-NEXT: str x30, [sp, #24] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl sin ; CHECK-SD-NEXT: fmov d10, d0 ; CHECK-SD-NEXT: fmov d0, d9 @@ -140,14 +126,9 @@ define <3 x double> @sin_v3f64(<3 x double> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: str d10, [sp, #-32]! // 8-byte Folded Spill ; CHECK-GI-NEXT: stp d9, d8, [sp, #8] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 -; CHECK-GI-NEXT: .cfi_offset b9, -24 -; CHECK-GI-NEXT: .cfi_offset b10, -32 ; CHECK-GI-NEXT: fmov d8, d1 ; CHECK-GI-NEXT: fmov d9, d2 +; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill ; CHECK-GI-NEXT: bl sin ; CHECK-GI-NEXT: fmov d10, d0 ; CHECK-GI-NEXT: fmov d0, d8 @@ -167,15 +148,13 @@ entry: ret <3 x double> %c } -define <4 x double> @sin_v4f64(<4 x double> %a) { +define <4 x double> @sin_v4f64(<4 x double> %a) nounwind { ; CHECK-SD-LABEL: sin_v4f64: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #64 -; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-SD-NEXT: mov d0, v0.d[1] +; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-SD-NEXT: str q1, [sp, #32] // 16-byte Folded Spill ; CHECK-SD-NEXT: bl sin ; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 @@ -206,15 +185,11 @@ define <4 x double> @sin_v4f64(<4 x double> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #80 ; CHECK-GI-NEXT: stp d9, d8, [sp, #48] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #64] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 80 -; CHECK-GI-NEXT: .cfi_offset w30, -16 -; CHECK-GI-NEXT: .cfi_offset b8, -24 -; CHECK-GI-NEXT: .cfi_offset b9, -32 -; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill ; CHECK-GI-NEXT: mov d8, v0.d[1] ; CHECK-GI-NEXT: mov d9, v1.d[1] +; CHECK-GI-NEXT: str x30, [sp, #64] // 8-byte Folded Spill ; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 +; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill ; CHECK-GI-NEXT: bl sin ; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-GI-NEXT: str q0, [sp, #32] // 16-byte Folded Spill @@ -244,16 +219,14 @@ entry: ret <4 x double> %c } -define <2 x float> @sin_v2f32(<2 x float> %a) { +define <2 x float> @sin_v2f32(<2 x float> %a) nounwind { ; CHECK-SD-LABEL: sin_v2f32: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-SD-NEXT: mov s0, v0.s[1] +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl sinf ; CHECK-SD-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill @@ -271,13 +244,10 @@ define <2 x float> @sin_v2f32(<2 x float> %a) { ; CHECK-GI-LABEL: sin_v2f32: ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #32 -; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 ; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 +; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill ; CHECK-GI-NEXT: mov s8, v0.s[1] +; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 killed $q0 ; CHECK-GI-NEXT: bl sinf ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 def $q0 @@ -297,15 +267,13 @@ entry: ret <2 x float> %c } -define <3 x float> @sin_v3f32(<3 x float> %a) { +define <3 x float> @sin_v3f32(<3 x float> %a) nounwind { ; CHECK-SD-LABEL: sin_v3f32: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-SD-NEXT: mov s0, v0.s[1] +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl sinf ; CHECK-SD-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -331,13 +299,9 @@ define <3 x float> @sin_v3f32(<3 x float> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #64 ; CHECK-GI-NEXT: stp d9, d8, [sp, #32] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 64 -; CHECK-GI-NEXT: .cfi_offset w30, -16 -; CHECK-GI-NEXT: .cfi_offset b8, -24 -; CHECK-GI-NEXT: .cfi_offset b9, -32 ; CHECK-GI-NEXT: mov s8, v0.s[1] ; CHECK-GI-NEXT: mov s9, v0.s[2] +; CHECK-GI-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 killed $q0 ; CHECK-GI-NEXT: bl sinf ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 def $q0 @@ -362,15 +326,13 @@ entry: ret <3 x float> %c } -define <4 x float> @sin_v4f32(<4 x float> %a) { +define <4 x float> @sin_v4f32(<4 x float> %a) nounwind { ; CHECK-SD-LABEL: sin_v4f32: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-SD-NEXT: mov s0, v0.s[1] +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl sinf ; CHECK-SD-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -403,16 +365,11 @@ define <4 x float> @sin_v4f32(<4 x float> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #80 ; CHECK-GI-NEXT: str d10, [sp, #48] // 8-byte Folded Spill +; CHECK-GI-NEXT: mov s10, v0.s[3] ; CHECK-GI-NEXT: stp d9, d8, [sp, #56] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #72] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 80 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 -; CHECK-GI-NEXT: .cfi_offset b9, -24 -; CHECK-GI-NEXT: .cfi_offset b10, -32 ; CHECK-GI-NEXT: mov s8, v0.s[1] ; CHECK-GI-NEXT: mov s9, v0.s[2] -; CHECK-GI-NEXT: mov s10, v0.s[3] +; CHECK-GI-NEXT: str x30, [sp, #72] // 8-byte Folded Spill ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 killed $q0 ; CHECK-GI-NEXT: bl sinf ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 def $q0 @@ -444,15 +401,13 @@ entry: ret <4 x float> %c } -define <8 x float> @sin_v8f32(<8 x float> %a) { +define <8 x float> @sin_v8f32(<8 x float> %a) nounwind { ; CHECK-SD-LABEL: sin_v8f32: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #64 -; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: stp q0, q1, [sp] // 32-byte Folded Spill ; CHECK-SD-NEXT: mov s0, v0.s[1] +; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl sinf ; CHECK-SD-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-SD-NEXT: str q0, [sp, #32] // 16-byte Folded Spill @@ -511,25 +466,17 @@ define <8 x float> @sin_v8f32(<8 x float> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #176 ; CHECK-GI-NEXT: stp d13, d12, [sp, #112] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov s12, v1.s[2] +; CHECK-GI-NEXT: mov s13, v1.s[3] ; CHECK-GI-NEXT: stp d11, d10, [sp, #128] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov s10, v0.s[3] +; CHECK-GI-NEXT: mov s11, v1.s[1] ; CHECK-GI-NEXT: stp d9, d8, [sp, #144] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #160] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 176 -; CHECK-GI-NEXT: .cfi_offset w30, -16 -; CHECK-GI-NEXT: .cfi_offset b8, -24 -; CHECK-GI-NEXT: .cfi_offset b9, -32 -; CHECK-GI-NEXT: .cfi_offset b10, -40 -; CHECK-GI-NEXT: .cfi_offset b11, -48 -; CHECK-GI-NEXT: .cfi_offset b12, -56 -; CHECK-GI-NEXT: .cfi_offset b13, -64 -; CHECK-GI-NEXT: str q1, [sp, #32] // 16-byte Folded Spill ; CHECK-GI-NEXT: mov s8, v0.s[1] ; CHECK-GI-NEXT: mov s9, v0.s[2] -; CHECK-GI-NEXT: mov s10, v0.s[3] -; CHECK-GI-NEXT: mov s11, v1.s[1] +; CHECK-GI-NEXT: str x30, [sp, #160] // 8-byte Folded Spill ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 killed $q0 -; CHECK-GI-NEXT: mov s12, v1.s[2] -; CHECK-GI-NEXT: mov s13, v1.s[3] +; CHECK-GI-NEXT: str q1, [sp, #32] // 16-byte Folded Spill ; CHECK-GI-NEXT: bl sinf ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-GI-NEXT: str q0, [sp, #64] // 16-byte Folded Spill @@ -586,15 +533,13 @@ entry: ret <8 x float> %c } -define <7 x half> @sin_v7f16(<7 x half> %a) { +define <7 x half> @sin_v7f16(<7 x half> %a) nounwind { ; CHECK-SD-LABEL: sin_v7f16: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: mov h1, v0.h[1] ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: fcvt s0, h1 ; CHECK-SD-NEXT: bl sinf ; CHECK-SD-NEXT: fcvt h0, s0 @@ -661,24 +606,16 @@ define <7 x half> @sin_v7f16(<7 x half> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #160 ; CHECK-GI-NEXT: stp d13, d12, [sp, #96] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h12, v0.h[5] +; CHECK-GI-NEXT: mov h13, v0.h[6] ; CHECK-GI-NEXT: stp d11, d10, [sp, #112] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h10, v0.h[3] +; CHECK-GI-NEXT: mov h11, v0.h[4] ; CHECK-GI-NEXT: stp d9, d8, [sp, #128] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #144] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 160 -; CHECK-GI-NEXT: .cfi_offset w30, -16 -; CHECK-GI-NEXT: .cfi_offset b8, -24 -; CHECK-GI-NEXT: .cfi_offset b9, -32 -; CHECK-GI-NEXT: .cfi_offset b10, -40 -; CHECK-GI-NEXT: .cfi_offset b11, -48 -; CHECK-GI-NEXT: .cfi_offset b12, -56 -; CHECK-GI-NEXT: .cfi_offset b13, -64 ; CHECK-GI-NEXT: mov h8, v0.h[1] ; CHECK-GI-NEXT: mov h9, v0.h[2] -; CHECK-GI-NEXT: mov h10, v0.h[3] -; CHECK-GI-NEXT: mov h11, v0.h[4] -; CHECK-GI-NEXT: mov h12, v0.h[5] -; CHECK-GI-NEXT: mov h13, v0.h[6] ; CHECK-GI-NEXT: fcvt s0, h0 +; CHECK-GI-NEXT: str x30, [sp, #144] // 8-byte Folded Spill ; CHECK-GI-NEXT: bl sinf ; CHECK-GI-NEXT: fcvt s1, h8 ; CHECK-GI-NEXT: fcvt h0, s0 @@ -733,16 +670,14 @@ entry: ret <7 x half> %c } -define <4 x half> @sin_v4f16(<4 x half> %a) { +define <4 x half> @sin_v4f16(<4 x half> %a) nounwind { ; CHECK-SD-LABEL: sin_v4f16: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-SD-NEXT: mov h1, v0.h[1] ; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: fcvt s0, h1 ; CHECK-SD-NEXT: bl sinf ; CHECK-SD-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload @@ -778,19 +713,14 @@ define <4 x half> @sin_v4f16(<4 x half> %a) { ; CHECK-GI-LABEL: sin_v4f16: ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #80 +; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-GI-NEXT: str d10, [sp, #48] // 8-byte Folded Spill +; CHECK-GI-NEXT: mov h10, v0.h[3] ; CHECK-GI-NEXT: stp d9, d8, [sp, #56] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #72] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 80 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 -; CHECK-GI-NEXT: .cfi_offset b9, -24 -; CHECK-GI-NEXT: .cfi_offset b10, -32 -; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-GI-NEXT: mov h8, v0.h[1] ; CHECK-GI-NEXT: mov h9, v0.h[2] -; CHECK-GI-NEXT: mov h10, v0.h[3] ; CHECK-GI-NEXT: fcvt s0, h0 +; CHECK-GI-NEXT: str x30, [sp, #72] // 8-byte Folded Spill ; CHECK-GI-NEXT: bl sinf ; CHECK-GI-NEXT: fcvt s1, h8 ; CHECK-GI-NEXT: fcvt h0, s0 @@ -825,15 +755,13 @@ entry: ret <4 x half> %c } -define <8 x half> @sin_v8f16(<8 x half> %a) { +define <8 x half> @sin_v8f16(<8 x half> %a) nounwind { ; CHECK-SD-LABEL: sin_v8f16: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: mov h1, v0.h[1] ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: fcvt s0, h1 ; CHECK-SD-NEXT: bl sinf ; CHECK-SD-NEXT: fcvt h0, s0 @@ -900,27 +828,18 @@ define <8 x half> @sin_v8f16(<8 x half> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #176 ; CHECK-GI-NEXT: str d14, [sp, #112] // 8-byte Folded Spill +; CHECK-GI-NEXT: mov h14, v0.h[7] ; CHECK-GI-NEXT: stp d13, d12, [sp, #120] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h12, v0.h[5] +; CHECK-GI-NEXT: mov h13, v0.h[6] ; CHECK-GI-NEXT: stp d11, d10, [sp, #136] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h10, v0.h[3] +; CHECK-GI-NEXT: mov h11, v0.h[4] ; CHECK-GI-NEXT: stp d9, d8, [sp, #152] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #168] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 176 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 -; CHECK-GI-NEXT: .cfi_offset b9, -24 -; CHECK-GI-NEXT: .cfi_offset b10, -32 -; CHECK-GI-NEXT: .cfi_offset b11, -40 -; CHECK-GI-NEXT: .cfi_offset b12, -48 -; CHECK-GI-NEXT: .cfi_offset b13, -56 -; CHECK-GI-NEXT: .cfi_offset b14, -64 ; CHECK-GI-NEXT: mov h8, v0.h[1] ; CHECK-GI-NEXT: mov h9, v0.h[2] -; CHECK-GI-NEXT: mov h10, v0.h[3] -; CHECK-GI-NEXT: mov h11, v0.h[4] -; CHECK-GI-NEXT: mov h12, v0.h[5] -; CHECK-GI-NEXT: mov h13, v0.h[6] -; CHECK-GI-NEXT: mov h14, v0.h[7] ; CHECK-GI-NEXT: fcvt s0, h0 +; CHECK-GI-NEXT: str x30, [sp, #168] // 8-byte Folded Spill ; CHECK-GI-NEXT: bl sinf ; CHECK-GI-NEXT: fcvt s1, h8 ; CHECK-GI-NEXT: fcvt h0, s0 @@ -982,15 +901,13 @@ entry: ret <8 x half> %c } -define <16 x half> @sin_v16f16(<16 x half> %a) { +define <16 x half> @sin_v16f16(<16 x half> %a) nounwind { ; CHECK-SD-LABEL: sin_v16f16: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #64 -; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: stp q1, q0, [sp] // 32-byte Folded Spill ; CHECK-SD-NEXT: mov h1, v0.h[1] +; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-SD-NEXT: fcvt s0, h1 ; CHECK-SD-NEXT: bl sinf ; CHECK-SD-NEXT: fcvt h0, s0 @@ -1119,35 +1036,24 @@ define <16 x half> @sin_v16f16(<16 x half> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #320 ; CHECK-GI-NEXT: stp d15, d14, [sp, #240] // 16-byte Folded Spill -; CHECK-GI-NEXT: stp d13, d12, [sp, #256] // 16-byte Folded Spill -; CHECK-GI-NEXT: stp d11, d10, [sp, #272] // 16-byte Folded Spill -; CHECK-GI-NEXT: stp d9, d8, [sp, #288] // 16-byte Folded Spill -; CHECK-GI-NEXT: stp x29, x30, [sp, #304] // 16-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 320 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset w29, -16 -; CHECK-GI-NEXT: .cfi_offset b8, -24 -; CHECK-GI-NEXT: .cfi_offset b9, -32 -; CHECK-GI-NEXT: .cfi_offset b10, -40 -; CHECK-GI-NEXT: .cfi_offset b11, -48 -; CHECK-GI-NEXT: .cfi_offset b12, -56 -; CHECK-GI-NEXT: .cfi_offset b13, -64 -; CHECK-GI-NEXT: .cfi_offset b14, -72 -; CHECK-GI-NEXT: .cfi_offset b15, -80 ; CHECK-GI-NEXT: mov v2.16b, v1.16b -; CHECK-GI-NEXT: str q1, [sp, #80] // 16-byte Folded Spill ; CHECK-GI-NEXT: mov h14, v1.h[1] +; CHECK-GI-NEXT: str q1, [sp, #80] // 16-byte Folded Spill ; CHECK-GI-NEXT: mov h1, v1.h[2] ; CHECK-GI-NEXT: mov h15, v0.h[1] -; CHECK-GI-NEXT: mov h8, v0.h[2] -; CHECK-GI-NEXT: mov h9, v0.h[3] -; CHECK-GI-NEXT: mov h10, v0.h[4] -; CHECK-GI-NEXT: mov h11, v0.h[5] +; CHECK-GI-NEXT: stp d13, d12, [sp, #256] // 16-byte Folded Spill ; CHECK-GI-NEXT: mov h12, v0.h[6] ; CHECK-GI-NEXT: mov h13, v0.h[7] -; CHECK-GI-NEXT: fcvt s0, h0 +; CHECK-GI-NEXT: stp d11, d10, [sp, #272] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h10, v0.h[4] +; CHECK-GI-NEXT: mov h11, v0.h[5] +; CHECK-GI-NEXT: stp d9, d8, [sp, #288] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h8, v0.h[2] +; CHECK-GI-NEXT: mov h9, v0.h[3] ; CHECK-GI-NEXT: str h1, [sp, #16] // 2-byte Folded Spill ; CHECK-GI-NEXT: mov h1, v2.h[3] +; CHECK-GI-NEXT: fcvt s0, h0 +; CHECK-GI-NEXT: stp x29, x30, [sp, #304] // 16-byte Folded Spill ; CHECK-GI-NEXT: str h1, [sp, #32] // 2-byte Folded Spill ; CHECK-GI-NEXT: mov h1, v2.h[4] ; CHECK-GI-NEXT: str h1, [sp, #48] // 2-byte Folded Spill @@ -1282,13 +1188,11 @@ entry: ret <16 x half> %c } -define <2 x fp128> @sin_v2fp128(<2 x fp128> %a) { +define <2 x fp128> @sin_v2fp128(<2 x fp128> %a) nounwind { ; CHECK-LABEL: sin_v2fp128: ; CHECK: // %bb.0: // %entry ; CHECK-NEXT: sub sp, sp, #48 ; CHECK-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: str q1, [sp, #16] // 16-byte Folded Spill ; CHECK-NEXT: bl sinl ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -1322,12 +1226,10 @@ entry: ret float %c } -define half @cos_f16(half %a) { +define half @cos_f16(half %a) nounwind { ; CHECK-LABEL: cos_f16: ; CHECK: // %bb.0: // %entry ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: fcvt s0, h0 ; CHECK-NEXT: bl cosf ; CHECK-NEXT: fcvt h0, s0 @@ -1347,12 +1249,10 @@ entry: ret fp128 %c } -define <1 x double> @cos_v1f64(<1 x double> %x) { +define <1 x double> @cos_v1f64(<1 x double> %x) nounwind { ; CHECK-LABEL: cos_v1f64: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: bl cos ; CHECK-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ret @@ -1360,15 +1260,13 @@ define <1 x double> @cos_v1f64(<1 x double> %x) { ret <1 x double> %c } -define <2 x double> @cos_v2f64(<2 x double> %a) { +define <2 x double> @cos_v2f64(<2 x double> %a) nounwind { ; CHECK-SD-LABEL: cos_v2f64: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-SD-NEXT: mov d0, v0.d[1] +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl cos ; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill @@ -1386,12 +1284,9 @@ define <2 x double> @cos_v2f64(<2 x double> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #32 ; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 ; CHECK-GI-NEXT: mov d8, v0.d[1] ; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 +; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill ; CHECK-GI-NEXT: bl cos ; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -1410,19 +1305,14 @@ entry: ret <2 x double> %c } -define <3 x double> @cos_v3f64(<3 x double> %a) { +define <3 x double> @cos_v3f64(<3 x double> %a) nounwind { ; CHECK-SD-LABEL: cos_v3f64: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: str d10, [sp, #-32]! // 8-byte Folded Spill ; CHECK-SD-NEXT: stp d9, d8, [sp, #8] // 16-byte Folded Spill -; CHECK-SD-NEXT: str x30, [sp, #24] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 32 -; CHECK-SD-NEXT: .cfi_offset w30, -8 -; CHECK-SD-NEXT: .cfi_offset b8, -16 -; CHECK-SD-NEXT: .cfi_offset b9, -24 -; CHECK-SD-NEXT: .cfi_offset b10, -32 ; CHECK-SD-NEXT: fmov d8, d2 ; CHECK-SD-NEXT: fmov d9, d1 +; CHECK-SD-NEXT: str x30, [sp, #24] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl cos ; CHECK-SD-NEXT: fmov d10, d0 ; CHECK-SD-NEXT: fmov d0, d9 @@ -1442,14 +1332,9 @@ define <3 x double> @cos_v3f64(<3 x double> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: str d10, [sp, #-32]! // 8-byte Folded Spill ; CHECK-GI-NEXT: stp d9, d8, [sp, #8] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 -; CHECK-GI-NEXT: .cfi_offset b9, -24 -; CHECK-GI-NEXT: .cfi_offset b10, -32 ; CHECK-GI-NEXT: fmov d8, d1 ; CHECK-GI-NEXT: fmov d9, d2 +; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill ; CHECK-GI-NEXT: bl cos ; CHECK-GI-NEXT: fmov d10, d0 ; CHECK-GI-NEXT: fmov d0, d8 @@ -1469,15 +1354,13 @@ entry: ret <3 x double> %c } -define <4 x double> @cos_v4f64(<4 x double> %a) { +define <4 x double> @cos_v4f64(<4 x double> %a) nounwind { ; CHECK-SD-LABEL: cos_v4f64: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #64 -; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-SD-NEXT: mov d0, v0.d[1] +; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-SD-NEXT: str q1, [sp, #32] // 16-byte Folded Spill ; CHECK-SD-NEXT: bl cos ; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 @@ -1508,15 +1391,11 @@ define <4 x double> @cos_v4f64(<4 x double> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #80 ; CHECK-GI-NEXT: stp d9, d8, [sp, #48] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #64] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 80 -; CHECK-GI-NEXT: .cfi_offset w30, -16 -; CHECK-GI-NEXT: .cfi_offset b8, -24 -; CHECK-GI-NEXT: .cfi_offset b9, -32 -; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill ; CHECK-GI-NEXT: mov d8, v0.d[1] ; CHECK-GI-NEXT: mov d9, v1.d[1] +; CHECK-GI-NEXT: str x30, [sp, #64] // 8-byte Folded Spill ; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 +; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill ; CHECK-GI-NEXT: bl cos ; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-GI-NEXT: str q0, [sp, #32] // 16-byte Folded Spill @@ -1546,16 +1425,14 @@ entry: ret <4 x double> %c } -define <2 x float> @cos_v2f32(<2 x float> %a) { +define <2 x float> @cos_v2f32(<2 x float> %a) nounwind { ; CHECK-SD-LABEL: cos_v2f32: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-SD-NEXT: mov s0, v0.s[1] +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl cosf ; CHECK-SD-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill @@ -1573,13 +1450,10 @@ define <2 x float> @cos_v2f32(<2 x float> %a) { ; CHECK-GI-LABEL: cos_v2f32: ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #32 -; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 ; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 +; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill ; CHECK-GI-NEXT: mov s8, v0.s[1] +; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 killed $q0 ; CHECK-GI-NEXT: bl cosf ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 def $q0 @@ -1599,15 +1473,13 @@ entry: ret <2 x float> %c } -define <3 x float> @cos_v3f32(<3 x float> %a) { +define <3 x float> @cos_v3f32(<3 x float> %a) nounwind { ; CHECK-SD-LABEL: cos_v3f32: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-SD-NEXT: mov s0, v0.s[1] +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl cosf ; CHECK-SD-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -1633,13 +1505,9 @@ define <3 x float> @cos_v3f32(<3 x float> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #64 ; CHECK-GI-NEXT: stp d9, d8, [sp, #32] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 64 -; CHECK-GI-NEXT: .cfi_offset w30, -16 -; CHECK-GI-NEXT: .cfi_offset b8, -24 -; CHECK-GI-NEXT: .cfi_offset b9, -32 ; CHECK-GI-NEXT: mov s8, v0.s[1] ; CHECK-GI-NEXT: mov s9, v0.s[2] +; CHECK-GI-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 killed $q0 ; CHECK-GI-NEXT: bl cosf ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 def $q0 @@ -1664,15 +1532,13 @@ entry: ret <3 x float> %c } -define <4 x float> @cos_v4f32(<4 x float> %a) { +define <4 x float> @cos_v4f32(<4 x float> %a) nounwind { ; CHECK-SD-LABEL: cos_v4f32: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-SD-NEXT: mov s0, v0.s[1] +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl cosf ; CHECK-SD-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -1705,16 +1571,11 @@ define <4 x float> @cos_v4f32(<4 x float> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #80 ; CHECK-GI-NEXT: str d10, [sp, #48] // 8-byte Folded Spill +; CHECK-GI-NEXT: mov s10, v0.s[3] ; CHECK-GI-NEXT: stp d9, d8, [sp, #56] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #72] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 80 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 -; CHECK-GI-NEXT: .cfi_offset b9, -24 -; CHECK-GI-NEXT: .cfi_offset b10, -32 ; CHECK-GI-NEXT: mov s8, v0.s[1] ; CHECK-GI-NEXT: mov s9, v0.s[2] -; CHECK-GI-NEXT: mov s10, v0.s[3] +; CHECK-GI-NEXT: str x30, [sp, #72] // 8-byte Folded Spill ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 killed $q0 ; CHECK-GI-NEXT: bl cosf ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 def $q0 @@ -1746,15 +1607,13 @@ entry: ret <4 x float> %c } -define <8 x float> @cos_v8f32(<8 x float> %a) { +define <8 x float> @cos_v8f32(<8 x float> %a) nounwind { ; CHECK-SD-LABEL: cos_v8f32: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #64 -; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: stp q0, q1, [sp] // 32-byte Folded Spill ; CHECK-SD-NEXT: mov s0, v0.s[1] +; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-SD-NEXT: bl cosf ; CHECK-SD-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-SD-NEXT: str q0, [sp, #32] // 16-byte Folded Spill @@ -1813,25 +1672,17 @@ define <8 x float> @cos_v8f32(<8 x float> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #176 ; CHECK-GI-NEXT: stp d13, d12, [sp, #112] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov s12, v1.s[2] +; CHECK-GI-NEXT: mov s13, v1.s[3] ; CHECK-GI-NEXT: stp d11, d10, [sp, #128] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov s10, v0.s[3] +; CHECK-GI-NEXT: mov s11, v1.s[1] ; CHECK-GI-NEXT: stp d9, d8, [sp, #144] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #160] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 176 -; CHECK-GI-NEXT: .cfi_offset w30, -16 -; CHECK-GI-NEXT: .cfi_offset b8, -24 -; CHECK-GI-NEXT: .cfi_offset b9, -32 -; CHECK-GI-NEXT: .cfi_offset b10, -40 -; CHECK-GI-NEXT: .cfi_offset b11, -48 -; CHECK-GI-NEXT: .cfi_offset b12, -56 -; CHECK-GI-NEXT: .cfi_offset b13, -64 -; CHECK-GI-NEXT: str q1, [sp, #32] // 16-byte Folded Spill ; CHECK-GI-NEXT: mov s8, v0.s[1] ; CHECK-GI-NEXT: mov s9, v0.s[2] -; CHECK-GI-NEXT: mov s10, v0.s[3] -; CHECK-GI-NEXT: mov s11, v1.s[1] +; CHECK-GI-NEXT: str x30, [sp, #160] // 8-byte Folded Spill ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 killed $q0 -; CHECK-GI-NEXT: mov s12, v1.s[2] -; CHECK-GI-NEXT: mov s13, v1.s[3] +; CHECK-GI-NEXT: str q1, [sp, #32] // 16-byte Folded Spill ; CHECK-GI-NEXT: bl cosf ; CHECK-GI-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-GI-NEXT: str q0, [sp, #64] // 16-byte Folded Spill @@ -1888,15 +1739,13 @@ entry: ret <8 x float> %c } -define <7 x half> @cos_v7f16(<7 x half> %a) { +define <7 x half> @cos_v7f16(<7 x half> %a) nounwind { ; CHECK-SD-LABEL: cos_v7f16: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: mov h1, v0.h[1] ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: fcvt s0, h1 ; CHECK-SD-NEXT: bl cosf ; CHECK-SD-NEXT: fcvt h0, s0 @@ -1963,24 +1812,16 @@ define <7 x half> @cos_v7f16(<7 x half> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #160 ; CHECK-GI-NEXT: stp d13, d12, [sp, #96] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h12, v0.h[5] +; CHECK-GI-NEXT: mov h13, v0.h[6] ; CHECK-GI-NEXT: stp d11, d10, [sp, #112] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h10, v0.h[3] +; CHECK-GI-NEXT: mov h11, v0.h[4] ; CHECK-GI-NEXT: stp d9, d8, [sp, #128] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #144] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 160 -; CHECK-GI-NEXT: .cfi_offset w30, -16 -; CHECK-GI-NEXT: .cfi_offset b8, -24 -; CHECK-GI-NEXT: .cfi_offset b9, -32 -; CHECK-GI-NEXT: .cfi_offset b10, -40 -; CHECK-GI-NEXT: .cfi_offset b11, -48 -; CHECK-GI-NEXT: .cfi_offset b12, -56 -; CHECK-GI-NEXT: .cfi_offset b13, -64 ; CHECK-GI-NEXT: mov h8, v0.h[1] ; CHECK-GI-NEXT: mov h9, v0.h[2] -; CHECK-GI-NEXT: mov h10, v0.h[3] -; CHECK-GI-NEXT: mov h11, v0.h[4] -; CHECK-GI-NEXT: mov h12, v0.h[5] -; CHECK-GI-NEXT: mov h13, v0.h[6] ; CHECK-GI-NEXT: fcvt s0, h0 +; CHECK-GI-NEXT: str x30, [sp, #144] // 8-byte Folded Spill ; CHECK-GI-NEXT: bl cosf ; CHECK-GI-NEXT: fcvt s1, h8 ; CHECK-GI-NEXT: fcvt h0, s0 @@ -2035,16 +1876,14 @@ entry: ret <7 x half> %c } -define <4 x half> @cos_v4f16(<4 x half> %a) { +define <4 x half> @cos_v4f16(<4 x half> %a) nounwind { ; CHECK-SD-LABEL: cos_v4f16: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-SD-NEXT: mov h1, v0.h[1] ; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: fcvt s0, h1 ; CHECK-SD-NEXT: bl cosf ; CHECK-SD-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload @@ -2080,19 +1919,14 @@ define <4 x half> @cos_v4f16(<4 x half> %a) { ; CHECK-GI-LABEL: cos_v4f16: ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #80 +; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-GI-NEXT: str d10, [sp, #48] // 8-byte Folded Spill +; CHECK-GI-NEXT: mov h10, v0.h[3] ; CHECK-GI-NEXT: stp d9, d8, [sp, #56] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #72] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 80 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 -; CHECK-GI-NEXT: .cfi_offset b9, -24 -; CHECK-GI-NEXT: .cfi_offset b10, -32 -; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-GI-NEXT: mov h8, v0.h[1] ; CHECK-GI-NEXT: mov h9, v0.h[2] -; CHECK-GI-NEXT: mov h10, v0.h[3] ; CHECK-GI-NEXT: fcvt s0, h0 +; CHECK-GI-NEXT: str x30, [sp, #72] // 8-byte Folded Spill ; CHECK-GI-NEXT: bl cosf ; CHECK-GI-NEXT: fcvt s1, h8 ; CHECK-GI-NEXT: fcvt h0, s0 @@ -2127,15 +1961,13 @@ entry: ret <4 x half> %c } -define <8 x half> @cos_v8f16(<8 x half> %a) { +define <8 x half> @cos_v8f16(<8 x half> %a) nounwind { ; CHECK-SD-LABEL: cos_v8f16: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #48 -; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: mov h1, v0.h[1] ; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill +; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-SD-NEXT: fcvt s0, h1 ; CHECK-SD-NEXT: bl cosf ; CHECK-SD-NEXT: fcvt h0, s0 @@ -2202,27 +2034,18 @@ define <8 x half> @cos_v8f16(<8 x half> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #176 ; CHECK-GI-NEXT: str d14, [sp, #112] // 8-byte Folded Spill +; CHECK-GI-NEXT: mov h14, v0.h[7] ; CHECK-GI-NEXT: stp d13, d12, [sp, #120] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h12, v0.h[5] +; CHECK-GI-NEXT: mov h13, v0.h[6] ; CHECK-GI-NEXT: stp d11, d10, [sp, #136] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h10, v0.h[3] +; CHECK-GI-NEXT: mov h11, v0.h[4] ; CHECK-GI-NEXT: stp d9, d8, [sp, #152] // 16-byte Folded Spill -; CHECK-GI-NEXT: str x30, [sp, #168] // 8-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 176 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset b8, -16 -; CHECK-GI-NEXT: .cfi_offset b9, -24 -; CHECK-GI-NEXT: .cfi_offset b10, -32 -; CHECK-GI-NEXT: .cfi_offset b11, -40 -; CHECK-GI-NEXT: .cfi_offset b12, -48 -; CHECK-GI-NEXT: .cfi_offset b13, -56 -; CHECK-GI-NEXT: .cfi_offset b14, -64 ; CHECK-GI-NEXT: mov h8, v0.h[1] ; CHECK-GI-NEXT: mov h9, v0.h[2] -; CHECK-GI-NEXT: mov h10, v0.h[3] -; CHECK-GI-NEXT: mov h11, v0.h[4] -; CHECK-GI-NEXT: mov h12, v0.h[5] -; CHECK-GI-NEXT: mov h13, v0.h[6] -; CHECK-GI-NEXT: mov h14, v0.h[7] ; CHECK-GI-NEXT: fcvt s0, h0 +; CHECK-GI-NEXT: str x30, [sp, #168] // 8-byte Folded Spill ; CHECK-GI-NEXT: bl cosf ; CHECK-GI-NEXT: fcvt s1, h8 ; CHECK-GI-NEXT: fcvt h0, s0 @@ -2284,15 +2107,13 @@ entry: ret <8 x half> %c } -define <16 x half> @cos_v16f16(<16 x half> %a) { +define <16 x half> @cos_v16f16(<16 x half> %a) nounwind { ; CHECK-SD-LABEL: cos_v16f16: ; CHECK-SD: // %bb.0: // %entry ; CHECK-SD-NEXT: sub sp, sp, #64 -; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 -; CHECK-SD-NEXT: .cfi_offset w30, -16 ; CHECK-SD-NEXT: stp q1, q0, [sp] // 32-byte Folded Spill ; CHECK-SD-NEXT: mov h1, v0.h[1] +; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-SD-NEXT: fcvt s0, h1 ; CHECK-SD-NEXT: bl cosf ; CHECK-SD-NEXT: fcvt h0, s0 @@ -2421,35 +2242,24 @@ define <16 x half> @cos_v16f16(<16 x half> %a) { ; CHECK-GI: // %bb.0: // %entry ; CHECK-GI-NEXT: sub sp, sp, #320 ; CHECK-GI-NEXT: stp d15, d14, [sp, #240] // 16-byte Folded Spill -; CHECK-GI-NEXT: stp d13, d12, [sp, #256] // 16-byte Folded Spill -; CHECK-GI-NEXT: stp d11, d10, [sp, #272] // 16-byte Folded Spill -; CHECK-GI-NEXT: stp d9, d8, [sp, #288] // 16-byte Folded Spill -; CHECK-GI-NEXT: stp x29, x30, [sp, #304] // 16-byte Folded Spill -; CHECK-GI-NEXT: .cfi_def_cfa_offset 320 -; CHECK-GI-NEXT: .cfi_offset w30, -8 -; CHECK-GI-NEXT: .cfi_offset w29, -16 -; CHECK-GI-NEXT: .cfi_offset b8, -24 -; CHECK-GI-NEXT: .cfi_offset b9, -32 -; CHECK-GI-NEXT: .cfi_offset b10, -40 -; CHECK-GI-NEXT: .cfi_offset b11, -48 -; CHECK-GI-NEXT: .cfi_offset b12, -56 -; CHECK-GI-NEXT: .cfi_offset b13, -64 -; CHECK-GI-NEXT: .cfi_offset b14, -72 -; CHECK-GI-NEXT: .cfi_offset b15, -80 ; CHECK-GI-NEXT: mov v2.16b, v1.16b -; CHECK-GI-NEXT: str q1, [sp, #80] // 16-byte Folded Spill ; CHECK-GI-NEXT: mov h14, v1.h[1] +; CHECK-GI-NEXT: str q1, [sp, #80] // 16-byte Folded Spill ; CHECK-GI-NEXT: mov h1, v1.h[2] ; CHECK-GI-NEXT: mov h15, v0.h[1] -; CHECK-GI-NEXT: mov h8, v0.h[2] -; CHECK-GI-NEXT: mov h9, v0.h[3] -; CHECK-GI-NEXT: mov h10, v0.h[4] -; CHECK-GI-NEXT: mov h11, v0.h[5] +; CHECK-GI-NEXT: stp d13, d12, [sp, #256] // 16-byte Folded Spill ; CHECK-GI-NEXT: mov h12, v0.h[6] ; CHECK-GI-NEXT: mov h13, v0.h[7] -; CHECK-GI-NEXT: fcvt s0, h0 +; CHECK-GI-NEXT: stp d11, d10, [sp, #272] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h10, v0.h[4] +; CHECK-GI-NEXT: mov h11, v0.h[5] +; CHECK-GI-NEXT: stp d9, d8, [sp, #288] // 16-byte Folded Spill +; CHECK-GI-NEXT: mov h8, v0.h[2] +; CHECK-GI-NEXT: mov h9, v0.h[3] ; CHECK-GI-NEXT: str h1, [sp, #16] // 2-byte Folded Spill ; CHECK-GI-NEXT: mov h1, v2.h[3] +; CHECK-GI-NEXT: fcvt s0, h0 +; CHECK-GI-NEXT: stp x29, x30, [sp, #304] // 16-byte Folded Spill ; CHECK-GI-NEXT: str h1, [sp, #32] // 2-byte Folded Spill ; CHECK-GI-NEXT: mov h1, v2.h[4] ; CHECK-GI-NEXT: str h1, [sp, #48] // 2-byte Folded Spill @@ -2584,13 +2394,11 @@ entry: ret <16 x half> %c } -define <2 x fp128> @cos_v2fp128(<2 x fp128> %a) { +define <2 x fp128> @cos_v2fp128(<2 x fp128> %a) nounwind { ; CHECK-LABEL: cos_v2fp128: ; CHECK: // %bb.0: // %entry ; CHECK-NEXT: sub sp, sp, #48 ; CHECK-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: str q1, [sp, #16] // 16-byte Folded Spill ; CHECK-NEXT: bl cosl ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -2607,12 +2415,10 @@ entry: } ; This is testing that we do not produce incorrect tailcall lowerings -define i64 @donttailcall(double noundef %x, double noundef %y) { +define i64 @donttailcall(double noundef %x, double noundef %y) nounwind { ; CHECK-LABEL: donttailcall: ; CHECK: // %bb.0: // %entry ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: bl sin ; CHECK-NEXT: fmov x0, d0 ; CHECK-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload diff --git a/llvm/test/CodeGen/AArch64/llvm.frexp.ll b/llvm/test/CodeGen/AArch64/llvm.frexp.ll index 51400b96e8b77..2213aa1429dbd 100644 --- a/llvm/test/CodeGen/AArch64/llvm.frexp.ll +++ b/llvm/test/CodeGen/AArch64/llvm.frexp.ll @@ -2,12 +2,10 @@ ; RUN: llc -mtriple=aarch64-gnu-linux < %s | FileCheck -check-prefixes=CHECK %s ; RUN: llc -mtriple=aarch64-windows-pc-msvc < %s | FileCheck -check-prefixes=WINDOWS %s -define { half, i32 } @test_frexp_f16_i32(half %a) { +define { half, i32 } @test_frexp_f16_i32(half %a) nounwind { ; CHECK-LABEL: test_frexp_f16_i32: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: fcvt s0, h0 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: bl frexpf @@ -17,33 +15,23 @@ define { half, i32 } @test_frexp_f16_i32(half %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_f16_i32: -; WINDOWS: .seh_proc test_frexp_f16_i32 -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: fcvt d0, h0 ; WINDOWS-NEXT: add x0, sp, #12 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr w0, [sp, #12] ; WINDOWS-NEXT: fcvt h0, d0 -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { half, i32 } @llvm.frexp.f16.i32(half %a) ret { half, i32 } %result } -define half @test_frexp_f16_i32_only_use_fract(half %a) { +define half @test_frexp_f16_i32_only_use_fract(half %a) nounwind { ; CHECK-LABEL: test_frexp_f16_i32_only_use_fract: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: fcvt s0, h0 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: bl frexpf @@ -52,33 +40,23 @@ define half @test_frexp_f16_i32_only_use_fract(half %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_f16_i32_only_use_fract: -; WINDOWS: .seh_proc test_frexp_f16_i32_only_use_fract -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: fcvt d0, h0 ; WINDOWS-NEXT: add x0, sp, #12 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: fcvt h0, d0 -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { half, i32 } @llvm.frexp.f16.i32(half %a) %result.0 = extractvalue { half, i32 } %result, 0 ret half %result.0 } -define i32 @test_frexp_f16_i32_only_use_exp(half %a) { +define i32 @test_frexp_f16_i32_only_use_exp(half %a) nounwind { ; CHECK-LABEL: test_frexp_f16_i32_only_use_exp: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: fcvt s0, h0 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: bl frexpf @@ -87,39 +65,28 @@ define i32 @test_frexp_f16_i32_only_use_exp(half %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_f16_i32_only_use_exp: -; WINDOWS: .seh_proc test_frexp_f16_i32_only_use_exp -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: fcvt d0, h0 ; WINDOWS-NEXT: add x0, sp, #12 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr w0, [sp, #12] -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { half, i32 } @llvm.frexp.f16.i32(half %a) %result.0 = extractvalue { half, i32 } %result, 1 ret i32 %result.0 } -define { <2 x half>, <2 x i32> } @test_frexp_v2f16_v2i32(<2 x half> %a) { +define { <2 x half>, <2 x i32> } @test_frexp_v2f16_v2i32(<2 x half> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f16_v2i32: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #64 -; CHECK-NEXT: stp x30, x19, [sp, #48] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 64 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-NEXT: mov h1, v0.h[1] ; CHECK-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-NEXT: add x0, sp, #36 +; CHECK-NEXT: stp x30, x19, [sp, #48] // 16-byte Folded Spill ; CHECK-NEXT: add x19, sp, #36 ; CHECK-NEXT: fcvt s0, h1 ; CHECK-NEXT: bl frexpf @@ -160,19 +127,13 @@ define { <2 x half>, <2 x i32> } @test_frexp_v2f16_v2i32(<2 x half> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v2f16_v2i32: -; WINDOWS: .seh_proc test_frexp_v2f16_v2i32 -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #64 -; WINDOWS-NEXT: .seh_stackalloc 64 -; WINDOWS-NEXT: str x19, [sp, #48] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x19, 48 -; WINDOWS-NEXT: str x30, [sp, #56] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x30, 56 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: // kill: def $d0 killed $d0 def $q0 ; WINDOWS-NEXT: mov h1, v0.h[1] ; WINDOWS-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; WINDOWS-NEXT: add x0, sp, #36 +; WINDOWS-NEXT: stp x30, x19, [sp, #48] // 16-byte Folded Spill ; WINDOWS-NEXT: add x19, sp, #36 ; WINDOWS-NEXT: fcvt d0, h1 ; WINDOWS-NEXT: bl frexp @@ -205,35 +166,25 @@ define { <2 x half>, <2 x i32> } @test_frexp_v2f16_v2i32(<2 x half> %a) { ; WINDOWS-NEXT: ldr s1, [sp, #32] ; WINDOWS-NEXT: ldr q0, [sp] // 16-byte Folded Reload ; WINDOWS-NEXT: ld1 { v1.s }[1], [x19] +; WINDOWS-NEXT: ldp x30, x19, [sp, #48] // 16-byte Folded Reload ; WINDOWS-NEXT: // kill: def $d1 killed $d1 killed $q1 ; WINDOWS-NEXT: mov v0.h[3], v2.h[0] ; WINDOWS-NEXT: // kill: def $d0 killed $d0 killed $q0 -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldr x30, [sp, #56] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x30, 56 -; WINDOWS-NEXT: ldr x19, [sp, #48] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x19, 48 ; WINDOWS-NEXT: add sp, sp, #64 -; WINDOWS-NEXT: .seh_stackalloc 64 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half> %a) ret { <2 x half>, <2 x i32> } %result } -define <2 x half> @test_frexp_v2f16_v2i32_only_use_fract(<2 x half> %a) { +define <2 x half> @test_frexp_v2f16_v2i32_only_use_fract(<2 x half> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f16_v2i32_only_use_fract: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #64 -; CHECK-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 64 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-NEXT: mov h1, v0.h[1] ; CHECK-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-NEXT: add x0, sp, #44 +; CHECK-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-NEXT: fcvt s0, h1 ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload @@ -270,17 +221,13 @@ define <2 x half> @test_frexp_v2f16_v2i32_only_use_fract(<2 x half> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v2f16_v2i32_only_use_fract: -; WINDOWS: .seh_proc test_frexp_v2f16_v2i32_only_use_fract -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #64 -; WINDOWS-NEXT: .seh_stackalloc 64 -; WINDOWS-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x30, 48 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: // kill: def $d0 killed $d0 def $q0 ; WINDOWS-NEXT: mov h1, v0.h[1] ; WINDOWS-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; WINDOWS-NEXT: add x0, sp, #44 +; WINDOWS-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; WINDOWS-NEXT: fcvt d0, h1 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload @@ -310,34 +257,25 @@ define <2 x half> @test_frexp_v2f16_v2i32_only_use_fract(<2 x half> %a) { ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: fcvt h1, d0 ; WINDOWS-NEXT: ldr q0, [sp] // 16-byte Folded Reload +; WINDOWS-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload ; WINDOWS-NEXT: mov v0.h[3], v1.h[0] ; WINDOWS-NEXT: // kill: def $d0 killed $d0 killed $q0 -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x30, 48 ; WINDOWS-NEXT: add sp, sp, #64 -; WINDOWS-NEXT: .seh_stackalloc 64 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half> %a) %result.0 = extractvalue { <2 x half>, <2 x i32> } %result, 0 ret <2 x half> %result.0 } -define <2 x i32> @test_frexp_v2f16_v2i32_only_use_exp(<2 x half> %a) { +define <2 x i32> @test_frexp_v2f16_v2i32_only_use_exp(<2 x half> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f16_v2i32_only_use_exp: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #48 -; CHECK-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-NEXT: add x0, sp, #24 ; CHECK-NEXT: fcvt s0, h0 +; CHECK-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: ldr q0, [sp] // 16-byte Folded Reload ; CHECK-NEXT: add x0, sp, #28 @@ -353,19 +291,13 @@ define <2 x i32> @test_frexp_v2f16_v2i32_only_use_exp(<2 x half> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v2f16_v2i32_only_use_exp: -; WINDOWS: .seh_proc test_frexp_v2f16_v2i32_only_use_exp -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #48 -; WINDOWS-NEXT: .seh_stackalloc 48 -; WINDOWS-NEXT: str x19, [sp, #32] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x19, 32 -; WINDOWS-NEXT: str x30, [sp, #40] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x30, 40 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: // kill: def $d0 killed $d0 def $q0 ; WINDOWS-NEXT: str q0, [sp] // 16-byte Folded Spill ; WINDOWS-NEXT: add x0, sp, #24 ; WINDOWS-NEXT: fcvt d0, h0 +; WINDOWS-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr q0, [sp] // 16-byte Folded Reload ; WINDOWS-NEXT: add x0, sp, #28 @@ -375,36 +307,24 @@ define <2 x i32> @test_frexp_v2f16_v2i32_only_use_exp(<2 x half> %a) { ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr s0, [sp, #24] ; WINDOWS-NEXT: ld1 { v0.s }[1], [x19] +; WINDOWS-NEXT: ldp x30, x19, [sp, #32] // 16-byte Folded Reload ; WINDOWS-NEXT: // kill: def $d0 killed $d0 killed $q0 -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldr x30, [sp, #40] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x30, 40 -; WINDOWS-NEXT: ldr x19, [sp, #32] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x19, 32 ; WINDOWS-NEXT: add sp, sp, #48 -; WINDOWS-NEXT: .seh_stackalloc 48 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half> %a) %result.1 = extractvalue { <2 x half>, <2 x i32> } %result, 1 ret <2 x i32> %result.1 } -define { <3 x float>, <3 x i32> } @test_frexp_v3f32_v3i32(<3 x float> %a) { +define { <3 x float>, <3 x i32> } @test_frexp_v3f32_v3i32(<3 x float> %a) nounwind { ; CHECK-LABEL: test_frexp_v3f32_v3i32: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #80 -; CHECK-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-NEXT: stp x20, x19, [sp, #64] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 80 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w20, -16 -; CHECK-NEXT: .cfi_offset w30, -32 ; CHECK-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-NEXT: mov s0, v0.s[1] ; CHECK-NEXT: add x0, sp, #56 +; CHECK-NEXT: str x30, [sp, #48] // 8-byte Folded Spill +; CHECK-NEXT: stp x20, x19, [sp, #64] // 16-byte Folded Spill ; CHECK-NEXT: add x19, sp, #56 ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: // kill: def $s0 killed $s0 def $q0 @@ -435,18 +355,13 @@ define { <3 x float>, <3 x i32> } @test_frexp_v3f32_v3i32(<3 x float> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v3f32_v3i32: -; WINDOWS: .seh_proc test_frexp_v3f32_v3i32 -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #80 -; WINDOWS-NEXT: .seh_stackalloc 80 -; WINDOWS-NEXT: stp x19, x20, [sp, #48] // 16-byte Folded Spill -; WINDOWS-NEXT: .seh_save_regp x19, 48 -; WINDOWS-NEXT: stp x21, x30, [sp, #64] // 16-byte Folded Spill -; WINDOWS-NEXT: .seh_save_lrpair x21, 64 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: mov s1, v0.s[1] ; WINDOWS-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; WINDOWS-NEXT: add x0, sp, #36 +; WINDOWS-NEXT: stp x30, x21, [sp, #48] // 16-byte Folded Spill +; WINDOWS-NEXT: stp x20, x19, [sp, #64] // 16-byte Folded Spill ; WINDOWS-NEXT: add x19, sp, #36 ; WINDOWS-NEXT: fcvt d0, s1 ; WINDOWS-NEXT: bl frexp @@ -482,28 +397,19 @@ define { <3 x float>, <3 x i32> } @test_frexp_v3f32_v3i32(<3 x float> %a) { ; WINDOWS-NEXT: ld1 { v1.s }[1], [x19] ; WINDOWS-NEXT: mov v0.s[3], v2.s[0] ; WINDOWS-NEXT: ld1 { v1.s }[2], [x20] +; WINDOWS-NEXT: ldp x20, x19, [sp, #64] // 16-byte Folded Reload ; WINDOWS-NEXT: ld1 { v1.s }[3], [x21] -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldp x21, x30, [sp, #64] // 16-byte Folded Reload -; WINDOWS-NEXT: .seh_save_lrpair x21, 64 -; WINDOWS-NEXT: ldp x19, x20, [sp, #48] // 16-byte Folded Reload -; WINDOWS-NEXT: .seh_save_regp x19, 48 +; WINDOWS-NEXT: ldp x30, x21, [sp, #48] // 16-byte Folded Reload ; WINDOWS-NEXT: add sp, sp, #80 -; WINDOWS-NEXT: .seh_stackalloc 80 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <3 x float>, <3 x i32> } @llvm.frexp.v3f32.v3i32(<3 x float> %a) ret { <3 x float>, <3 x i32> } %result } -define { float, i32 } @test_frexp_f32_i32(float %a) { +define { float, i32 } @test_frexp_f32_i32(float %a) nounwind { ; CHECK-LABEL: test_frexp_f32_i32: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: ldr w0, [sp, #12] @@ -511,33 +417,23 @@ define { float, i32 } @test_frexp_f32_i32(float %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_f32_i32: -; WINDOWS: .seh_proc test_frexp_f32_i32 -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: fcvt d0, s0 ; WINDOWS-NEXT: add x0, sp, #12 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr w0, [sp, #12] ; WINDOWS-NEXT: fcvt s0, d0 -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { float, i32 } @llvm.frexp.f32.i32(float %a) ret { float, i32 } %result } -define { float, i32 } @test_frexp_f32_i32_tailcall(float %a) { +define { float, i32 } @test_frexp_f32_i32_tailcall(float %a) nounwind { ; CHECK-LABEL: test_frexp_f32_i32_tailcall: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: ldr w0, [sp, #12] @@ -545,66 +441,46 @@ define { float, i32 } @test_frexp_f32_i32_tailcall(float %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_f32_i32_tailcall: -; WINDOWS: .seh_proc test_frexp_f32_i32_tailcall -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: fcvt d0, s0 ; WINDOWS-NEXT: add x0, sp, #12 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr w0, [sp, #12] ; WINDOWS-NEXT: fcvt s0, d0 -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = tail call { float, i32 } @llvm.frexp.f32.i32(float %a) ret { float, i32 } %result } -define float @test_frexp_f32_i32_only_use_fract(float %a) { +define float @test_frexp_f32_i32_only_use_fract(float %a) nounwind { ; CHECK-LABEL: test_frexp_f32_i32_only_use_fract: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_f32_i32_only_use_fract: -; WINDOWS: .seh_proc test_frexp_f32_i32_only_use_fract -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: fcvt d0, s0 ; WINDOWS-NEXT: add x0, sp, #12 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: fcvt s0, d0 -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { float, i32 } @llvm.frexp.f32.i32(float %a) %result.0 = extractvalue { float, i32 } %result, 0 ret float %result.0 } -define i32 @test_frexp_f32_i32_only_use_exp(float %a) { +define i32 @test_frexp_f32_i32_only_use_exp(float %a) nounwind { ; CHECK-LABEL: test_frexp_f32_i32_only_use_exp: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: ldr w0, [sp, #12] @@ -612,40 +488,29 @@ define i32 @test_frexp_f32_i32_only_use_exp(float %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_f32_i32_only_use_exp: -; WINDOWS: .seh_proc test_frexp_f32_i32_only_use_exp -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: fcvt d0, s0 ; WINDOWS-NEXT: add x0, sp, #12 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr w0, [sp, #12] -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { float, i32 } @llvm.frexp.f32.i32(float %a) %result.0 = extractvalue { float, i32 } %result, 1 ret i32 %result.0 } -define { <2 x float>, <2 x i32> } @test_frexp_v2f32_v2i32(<2 x float> %a) { +define { <2 x float>, <2 x i32> } @test_frexp_v2f32_v2i32(<2 x float> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f32_v2i32: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #64 -; CHECK-NEXT: stp x30, x19, [sp, #48] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 64 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-NEXT: add x0, sp, #40 -; CHECK-NEXT: add x19, sp, #40 ; CHECK-NEXT: mov s0, v0.s[1] +; CHECK-NEXT: stp x30, x19, [sp, #48] // 16-byte Folded Spill +; CHECK-NEXT: add x19, sp, #40 ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-NEXT: str q0, [sp, #16] // 16-byte Folded Spill @@ -665,19 +530,13 @@ define { <2 x float>, <2 x i32> } @test_frexp_v2f32_v2i32(<2 x float> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v2f32_v2i32: -; WINDOWS: .seh_proc test_frexp_v2f32_v2i32 -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #48 -; WINDOWS-NEXT: .seh_stackalloc 48 -; WINDOWS-NEXT: str x19, [sp, #32] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x19, 32 -; WINDOWS-NEXT: str x30, [sp, #40] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x30, 40 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: // kill: def $d0 killed $d0 def $q0 ; WINDOWS-NEXT: mov s1, v0.s[1] ; WINDOWS-NEXT: str q0, [sp] // 16-byte Folded Spill ; WINDOWS-NEXT: add x0, sp, #28 +; WINDOWS-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill ; WINDOWS-NEXT: add x19, sp, #28 ; WINDOWS-NEXT: fcvt d0, s1 ; WINDOWS-NEXT: bl frexp @@ -692,35 +551,25 @@ define { <2 x float>, <2 x i32> } @test_frexp_v2f32_v2i32(<2 x float> %a) { ; WINDOWS-NEXT: ldr s1, [sp, #24] ; WINDOWS-NEXT: ldr q2, [sp] // 16-byte Folded Reload ; WINDOWS-NEXT: ld1 { v1.s }[1], [x19] +; WINDOWS-NEXT: ldp x30, x19, [sp, #32] // 16-byte Folded Reload ; WINDOWS-NEXT: // kill: def $d1 killed $d1 killed $q1 ; WINDOWS-NEXT: mov v0.s[1], v2.s[0] ; WINDOWS-NEXT: // kill: def $d0 killed $d0 killed $q0 -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldr x30, [sp, #40] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x30, 40 -; WINDOWS-NEXT: ldr x19, [sp, #32] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x19, 32 ; WINDOWS-NEXT: add sp, sp, #48 -; WINDOWS-NEXT: .seh_stackalloc 48 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a) ret { <2 x float>, <2 x i32> } %result } -define <2 x float> @test_frexp_v2f32_v2i32_only_use_fract(<2 x float> %a) { +define <2 x float> @test_frexp_v2f32_v2i32_only_use_fract(<2 x float> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f32_v2i32_only_use_fract: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #48 -; CHECK-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-NEXT: add x0, sp, #40 ; CHECK-NEXT: mov s0, v0.s[1] +; CHECK-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -737,17 +586,13 @@ define <2 x float> @test_frexp_v2f32_v2i32_only_use_fract(<2 x float> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v2f32_v2i32_only_use_fract: -; WINDOWS: .seh_proc test_frexp_v2f32_v2i32_only_use_fract -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #32 -; WINDOWS-NEXT: .seh_stackalloc 32 -; WINDOWS-NEXT: str x30, [sp, #16] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: // kill: def $d0 killed $d0 def $q0 ; WINDOWS-NEXT: mov s1, v0.s[1] ; WINDOWS-NEXT: str q0, [sp] // 16-byte Folded Spill ; WINDOWS-NEXT: add x0, sp, #28 +; WINDOWS-NEXT: str x30, [sp, #16] // 8-byte Folded Spill ; WINDOWS-NEXT: fcvt d0, s1 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr q1, [sp] // 16-byte Folded Reload @@ -759,32 +604,23 @@ define <2 x float> @test_frexp_v2f32_v2i32_only_use_fract(<2 x float> %a) { ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: fcvt s0, d0 ; WINDOWS-NEXT: ldr q1, [sp] // 16-byte Folded Reload +; WINDOWS-NEXT: ldr x30, [sp, #16] // 8-byte Folded Reload ; WINDOWS-NEXT: mov v0.s[1], v1.s[0] ; WINDOWS-NEXT: // kill: def $d0 killed $d0 killed $q0 -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldr x30, [sp, #16] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x30, 16 ; WINDOWS-NEXT: add sp, sp, #32 -; WINDOWS-NEXT: .seh_stackalloc 32 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a) %result.0 = extractvalue { <2 x float>, <2 x i32> } %result, 0 ret <2 x float> %result.0 } -define <2 x i32> @test_frexp_v2f32_v2i32_only_use_exp(<2 x float> %a) { +define <2 x i32> @test_frexp_v2f32_v2i32_only_use_exp(<2 x float> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f32_v2i32_only_use_exp: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #48 -; CHECK-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-NEXT: add x0, sp, #28 +; CHECK-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-NEXT: // kill: def $s0 killed $s0 killed $q0 ; CHECK-NEXT: bl frexpf @@ -801,19 +637,13 @@ define <2 x i32> @test_frexp_v2f32_v2i32_only_use_exp(<2 x float> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v2f32_v2i32_only_use_exp: -; WINDOWS: .seh_proc test_frexp_v2f32_v2i32_only_use_exp -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #48 -; WINDOWS-NEXT: .seh_stackalloc 48 -; WINDOWS-NEXT: str x19, [sp, #32] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x19, 32 -; WINDOWS-NEXT: str x30, [sp, #40] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x30, 40 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: // kill: def $d0 killed $d0 def $q0 ; WINDOWS-NEXT: str q0, [sp] // 16-byte Folded Spill ; WINDOWS-NEXT: add x0, sp, #24 ; WINDOWS-NEXT: fcvt d0, s0 +; WINDOWS-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr q0, [sp] // 16-byte Folded Reload ; WINDOWS-NEXT: add x0, sp, #28 @@ -823,37 +653,24 @@ define <2 x i32> @test_frexp_v2f32_v2i32_only_use_exp(<2 x float> %a) { ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr s0, [sp, #24] ; WINDOWS-NEXT: ld1 { v0.s }[1], [x19] +; WINDOWS-NEXT: ldp x30, x19, [sp, #32] // 16-byte Folded Reload ; WINDOWS-NEXT: // kill: def $d0 killed $d0 killed $q0 -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldr x30, [sp, #40] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x30, 40 -; WINDOWS-NEXT: ldr x19, [sp, #32] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x19, 32 ; WINDOWS-NEXT: add sp, sp, #48 -; WINDOWS-NEXT: .seh_stackalloc 48 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a) %result.1 = extractvalue { <2 x float>, <2 x i32> } %result, 1 ret <2 x i32> %result.1 } -define { <4 x float>, <4 x i32> } @test_frexp_v4f32_v4i32(<4 x float> %a) { +define { <4 x float>, <4 x i32> } @test_frexp_v4f32_v4i32(<4 x float> %a) nounwind { ; CHECK-LABEL: test_frexp_v4f32_v4i32: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #80 -; CHECK-NEXT: stp x30, x21, [sp, #48] // 16-byte Folded Spill -; CHECK-NEXT: stp x20, x19, [sp, #64] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 80 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w20, -16 -; CHECK-NEXT: .cfi_offset w21, -24 -; CHECK-NEXT: .cfi_offset w30, -32 ; CHECK-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-NEXT: mov s0, v0.s[1] ; CHECK-NEXT: add x0, sp, #40 +; CHECK-NEXT: stp x30, x21, [sp, #48] // 16-byte Folded Spill +; CHECK-NEXT: stp x20, x19, [sp, #64] // 16-byte Folded Spill ; CHECK-NEXT: add x19, sp, #40 ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: // kill: def $s0 killed $s0 def $q0 @@ -894,18 +711,13 @@ define { <4 x float>, <4 x i32> } @test_frexp_v4f32_v4i32(<4 x float> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v4f32_v4i32: -; WINDOWS: .seh_proc test_frexp_v4f32_v4i32 -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #80 -; WINDOWS-NEXT: .seh_stackalloc 80 -; WINDOWS-NEXT: stp x19, x20, [sp, #48] // 16-byte Folded Spill -; WINDOWS-NEXT: .seh_save_regp x19, 48 -; WINDOWS-NEXT: stp x21, x30, [sp, #64] // 16-byte Folded Spill -; WINDOWS-NEXT: .seh_save_lrpair x21, 64 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: mov s1, v0.s[1] ; WINDOWS-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; WINDOWS-NEXT: add x0, sp, #36 +; WINDOWS-NEXT: stp x30, x21, [sp, #48] // 16-byte Folded Spill +; WINDOWS-NEXT: stp x20, x19, [sp, #64] // 16-byte Folded Spill ; WINDOWS-NEXT: add x19, sp, #36 ; WINDOWS-NEXT: fcvt d0, s1 ; WINDOWS-NEXT: bl frexp @@ -941,32 +753,23 @@ define { <4 x float>, <4 x i32> } @test_frexp_v4f32_v4i32(<4 x float> %a) { ; WINDOWS-NEXT: ld1 { v1.s }[1], [x19] ; WINDOWS-NEXT: mov v0.s[3], v2.s[0] ; WINDOWS-NEXT: ld1 { v1.s }[2], [x20] +; WINDOWS-NEXT: ldp x20, x19, [sp, #64] // 16-byte Folded Reload ; WINDOWS-NEXT: ld1 { v1.s }[3], [x21] -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldp x21, x30, [sp, #64] // 16-byte Folded Reload -; WINDOWS-NEXT: .seh_save_lrpair x21, 64 -; WINDOWS-NEXT: ldp x19, x20, [sp, #48] // 16-byte Folded Reload -; WINDOWS-NEXT: .seh_save_regp x19, 48 +; WINDOWS-NEXT: ldp x30, x21, [sp, #48] // 16-byte Folded Reload ; WINDOWS-NEXT: add sp, sp, #80 -; WINDOWS-NEXT: .seh_stackalloc 80 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <4 x float>, <4 x i32> } @llvm.frexp.v4f32.v4i32(<4 x float> %a) ret { <4 x float>, <4 x i32> } %result } -define <4 x float> @test_frexp_v4f32_v4i32_only_use_fract(<4 x float> %a) { +define <4 x float> @test_frexp_v4f32_v4i32_only_use_fract(<4 x float> %a) nounwind { ; CHECK-LABEL: test_frexp_v4f32_v4i32_only_use_fract: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #64 -; CHECK-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 64 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-NEXT: mov s0, v0.s[1] ; CHECK-NEXT: add x0, sp, #56 +; CHECK-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: // kill: def $s0 killed $s0 def $q0 ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -999,16 +802,12 @@ define <4 x float> @test_frexp_v4f32_v4i32_only_use_fract(<4 x float> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v4f32_v4i32_only_use_fract: -; WINDOWS: .seh_proc test_frexp_v4f32_v4i32_only_use_fract -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #64 -; WINDOWS-NEXT: .seh_stackalloc 64 -; WINDOWS-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x30, 48 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: mov s1, v0.s[1] ; WINDOWS-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; WINDOWS-NEXT: add x0, sp, #44 +; WINDOWS-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; WINDOWS-NEXT: fcvt d0, s1 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: fcvt s0, d0 @@ -1037,33 +836,22 @@ define <4 x float> @test_frexp_v4f32_v4i32_only_use_fract(<4 x float> %a) { ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: fcvt s1, d0 ; WINDOWS-NEXT: ldr q0, [sp] // 16-byte Folded Reload -; WINDOWS-NEXT: mov v0.s[3], v1.s[0] -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x30, 48 +; WINDOWS-NEXT: mov v0.s[3], v1.s[0] ; WINDOWS-NEXT: add sp, sp, #64 -; WINDOWS-NEXT: .seh_stackalloc 64 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <4 x float>, <4 x i32> } @llvm.frexp.v4f32.v4i32(<4 x float> %a) %result.0 = extractvalue { <4 x float>, <4 x i32> } %result, 0 ret <4 x float> %result.0 } -define <4 x i32> @test_frexp_v4f32_v4i32_only_use_exp(<4 x float> %a) { +define <4 x i32> @test_frexp_v4f32_v4i32_only_use_exp(<4 x float> %a) nounwind { ; CHECK-LABEL: test_frexp_v4f32_v4i32_only_use_exp: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #64 +; CHECK-NEXT: add x0, sp, #28 ; CHECK-NEXT: stp x30, x21, [sp, #32] // 16-byte Folded Spill ; CHECK-NEXT: stp x20, x19, [sp, #48] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 64 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w20, -16 -; CHECK-NEXT: .cfi_offset w21, -24 -; CHECK-NEXT: .cfi_offset w30, -32 -; CHECK-NEXT: add x0, sp, #28 ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-NEXT: // kill: def $s0 killed $s0 killed $q0 ; CHECK-NEXT: bl frexpf @@ -1092,18 +880,13 @@ define <4 x i32> @test_frexp_v4f32_v4i32_only_use_exp(<4 x float> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v4f32_v4i32_only_use_exp: -; WINDOWS: .seh_proc test_frexp_v4f32_v4i32_only_use_exp -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #64 -; WINDOWS-NEXT: .seh_stackalloc 64 -; WINDOWS-NEXT: stp x19, x20, [sp, #32] // 16-byte Folded Spill -; WINDOWS-NEXT: .seh_save_regp x19, 32 -; WINDOWS-NEXT: stp x21, x30, [sp, #48] // 16-byte Folded Spill -; WINDOWS-NEXT: .seh_save_lrpair x21, 48 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: str q0, [sp] // 16-byte Folded Spill ; WINDOWS-NEXT: fcvt d0, s0 ; WINDOWS-NEXT: add x0, sp, #16 +; WINDOWS-NEXT: stp x30, x21, [sp, #32] // 16-byte Folded Spill +; WINDOWS-NEXT: stp x20, x19, [sp, #48] // 16-byte Folded Spill ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr q0, [sp] // 16-byte Folded Reload ; WINDOWS-NEXT: add x0, sp, #20 @@ -1126,29 +909,20 @@ define <4 x i32> @test_frexp_v4f32_v4i32_only_use_exp(<4 x float> %a) { ; WINDOWS-NEXT: ldr s0, [sp, #16] ; WINDOWS-NEXT: ld1 { v0.s }[1], [x19] ; WINDOWS-NEXT: ld1 { v0.s }[2], [x20] +; WINDOWS-NEXT: ldp x20, x19, [sp, #48] // 16-byte Folded Reload ; WINDOWS-NEXT: ld1 { v0.s }[3], [x21] -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldp x21, x30, [sp, #48] // 16-byte Folded Reload -; WINDOWS-NEXT: .seh_save_lrpair x21, 48 -; WINDOWS-NEXT: ldp x19, x20, [sp, #32] // 16-byte Folded Reload -; WINDOWS-NEXT: .seh_save_regp x19, 32 +; WINDOWS-NEXT: ldp x30, x21, [sp, #32] // 16-byte Folded Reload ; WINDOWS-NEXT: add sp, sp, #64 -; WINDOWS-NEXT: .seh_stackalloc 64 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <4 x float>, <4 x i32> } @llvm.frexp.v4f32.v4i32(<4 x float> %a) %result.1 = extractvalue { <4 x float>, <4 x i32> } %result, 1 ret <4 x i32> %result.1 } -define { double, i32 } @test_frexp_f64_i32(double %a) { +define { double, i32 } @test_frexp_f64_i32(double %a) nounwind { ; CHECK-LABEL: test_frexp_f64_i32: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: bl frexp ; CHECK-NEXT: ldr w0, [sp, #12] @@ -1156,62 +930,42 @@ define { double, i32 } @test_frexp_f64_i32(double %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_f64_i32: -; WINDOWS: .seh_proc test_frexp_f64_i32 -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: add x0, sp, #12 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr w0, [sp, #12] -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { double, i32 } @llvm.frexp.f64.i32(double %a) ret { double, i32 } %result } -define double @test_frexp_f64_i32_only_use_fract(double %a) { +define double @test_frexp_f64_i32_only_use_fract(double %a) nounwind { ; CHECK-LABEL: test_frexp_f64_i32_only_use_fract: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: bl frexp ; CHECK-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_f64_i32_only_use_fract: -; WINDOWS: .seh_proc test_frexp_f64_i32_only_use_fract -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: add x0, sp, #12 ; WINDOWS-NEXT: bl frexp -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { double, i32 } @llvm.frexp.f64.i32(double %a) %result.0 = extractvalue { double, i32 } %result, 0 ret double %result.0 } -define i32 @test_frexp_f64_i32_only_use_exp(double %a) { +define i32 @test_frexp_f64_i32_only_use_exp(double %a) nounwind { ; CHECK-LABEL: test_frexp_f64_i32_only_use_exp: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: bl frexp ; CHECK-NEXT: ldr w0, [sp, #12] @@ -1219,37 +973,26 @@ define i32 @test_frexp_f64_i32_only_use_exp(double %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_f64_i32_only_use_exp: -; WINDOWS: .seh_proc test_frexp_f64_i32_only_use_exp -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: add x0, sp, #12 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr w0, [sp, #12] -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg_x x30, 16 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { double, i32 } @llvm.frexp.f64.i32(double %a) %result.0 = extractvalue { double, i32 } %result, 1 ret i32 %result.0 } -define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) { +define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f64_v2i32: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #64 -; CHECK-NEXT: stp x30, x19, [sp, #48] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 64 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-NEXT: mov d0, v0.d[1] ; CHECK-NEXT: add x0, sp, #40 +; CHECK-NEXT: stp x30, x19, [sp, #48] // 16-byte Folded Spill ; CHECK-NEXT: add x19, sp, #40 ; CHECK-NEXT: bl frexp ; CHECK-NEXT: // kill: def $d0 killed $d0 def $q0 @@ -1269,18 +1012,12 @@ define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v2f64_v2i32: -; WINDOWS: .seh_proc test_frexp_v2f64_v2i32 -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #64 -; WINDOWS-NEXT: .seh_stackalloc 64 -; WINDOWS-NEXT: str x19, [sp, #48] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x19, 48 -; WINDOWS-NEXT: str x30, [sp, #56] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x30, 56 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: str q0, [sp] // 16-byte Folded Spill ; WINDOWS-NEXT: mov d0, v0.d[1] ; WINDOWS-NEXT: add x0, sp, #40 +; WINDOWS-NEXT: stp x30, x19, [sp, #48] // 16-byte Folded Spill ; WINDOWS-NEXT: add x19, sp, #40 ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: // kill: def $d0 killed $d0 def $q0 @@ -1293,33 +1030,23 @@ define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) { ; WINDOWS-NEXT: ldr q2, [sp, #16] // 16-byte Folded Reload ; WINDOWS-NEXT: // kill: def $d0 killed $d0 def $q0 ; WINDOWS-NEXT: ld1 { v1.s }[1], [x19] +; WINDOWS-NEXT: ldp x30, x19, [sp, #48] // 16-byte Folded Reload ; WINDOWS-NEXT: mov v0.d[1], v2.d[0] ; WINDOWS-NEXT: // kill: def $d1 killed $d1 killed $q1 -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldr x30, [sp, #56] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x30, 56 -; WINDOWS-NEXT: ldr x19, [sp, #48] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x19, 48 ; WINDOWS-NEXT: add sp, sp, #64 -; WINDOWS-NEXT: .seh_stackalloc 64 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a) ret { <2 x double>, <2 x i32> } %result } -define <2 x double> @test_frexp_v2f64_v2i32_only_use_fract(<2 x double> %a) { +define <2 x double> @test_frexp_v2f64_v2i32_only_use_fract(<2 x double> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f64_v2i32_only_use_fract: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #48 -; CHECK-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; CHECK-NEXT: mov d0, v0.d[1] ; CHECK-NEXT: add x0, sp, #40 +; CHECK-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-NEXT: bl frexp ; CHECK-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -1335,16 +1062,12 @@ define <2 x double> @test_frexp_v2f64_v2i32_only_use_fract(<2 x double> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v2f64_v2i32_only_use_fract: -; WINDOWS: .seh_proc test_frexp_v2f64_v2i32_only_use_fract -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #48 -; WINDOWS-NEXT: .seh_stackalloc 48 -; WINDOWS-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x30, 32 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: str q0, [sp, #16] // 16-byte Folded Spill ; WINDOWS-NEXT: mov d0, v0.d[1] ; WINDOWS-NEXT: add x0, sp, #40 +; WINDOWS-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: // kill: def $d0 killed $d0 def $q0 ; WINDOWS-NEXT: str q0, [sp] // 16-byte Folded Spill @@ -1354,30 +1077,21 @@ define <2 x double> @test_frexp_v2f64_v2i32_only_use_fract(<2 x double> %a) { ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr q1, [sp] // 16-byte Folded Reload ; WINDOWS-NEXT: // kill: def $d0 killed $d0 def $q0 -; WINDOWS-NEXT: mov v0.d[1], v1.d[0] -; WINDOWS-NEXT: .seh_startepilogue ; WINDOWS-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x30, 32 +; WINDOWS-NEXT: mov v0.d[1], v1.d[0] ; WINDOWS-NEXT: add sp, sp, #48 -; WINDOWS-NEXT: .seh_stackalloc 48 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a) %result.0 = extractvalue { <2 x double>, <2 x i32> } %result, 0 ret <2 x double> %result.0 } -define <2 x i32> @test_frexp_v2f64_v2i32_only_use_exp(<2 x double> %a) { +define <2 x i32> @test_frexp_v2f64_v2i32_only_use_exp(<2 x double> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f64_v2i32_only_use_exp: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #48 -; CHECK-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: add x0, sp, #28 +; CHECK-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-NEXT: // kill: def $d0 killed $d0 killed $q0 ; CHECK-NEXT: bl frexp @@ -1394,16 +1108,10 @@ define <2 x i32> @test_frexp_v2f64_v2i32_only_use_exp(<2 x double> %a) { ; CHECK-NEXT: ret ; ; WINDOWS-LABEL: test_frexp_v2f64_v2i32_only_use_exp: -; WINDOWS: .seh_proc test_frexp_v2f64_v2i32_only_use_exp -; WINDOWS-NEXT: // %bb.0: +; WINDOWS: // %bb.0: ; WINDOWS-NEXT: sub sp, sp, #48 -; WINDOWS-NEXT: .seh_stackalloc 48 -; WINDOWS-NEXT: str x19, [sp, #32] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x19, 32 -; WINDOWS-NEXT: str x30, [sp, #40] // 8-byte Folded Spill -; WINDOWS-NEXT: .seh_save_reg x30, 40 -; WINDOWS-NEXT: .seh_endprologue ; WINDOWS-NEXT: add x0, sp, #28 +; WINDOWS-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill ; WINDOWS-NEXT: str q0, [sp] // 16-byte Folded Spill ; WINDOWS-NEXT: // kill: def $d0 killed $d0 killed $q0 ; WINDOWS-NEXT: bl frexp @@ -1414,18 +1122,10 @@ define <2 x i32> @test_frexp_v2f64_v2i32_only_use_exp(<2 x double> %a) { ; WINDOWS-NEXT: bl frexp ; WINDOWS-NEXT: ldr s0, [sp, #28] ; WINDOWS-NEXT: ld1 { v0.s }[1], [x19] +; WINDOWS-NEXT: ldp x30, x19, [sp, #32] // 16-byte Folded Reload ; WINDOWS-NEXT: // kill: def $d0 killed $d0 killed $q0 -; WINDOWS-NEXT: .seh_startepilogue -; WINDOWS-NEXT: ldr x30, [sp, #40] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x30, 40 -; WINDOWS-NEXT: ldr x19, [sp, #32] // 8-byte Folded Reload -; WINDOWS-NEXT: .seh_save_reg x19, 32 ; WINDOWS-NEXT: add sp, sp, #48 -; WINDOWS-NEXT: .seh_stackalloc 48 -; WINDOWS-NEXT: .seh_endepilogue ; WINDOWS-NEXT: ret -; WINDOWS-NEXT: .seh_endfunclet -; WINDOWS-NEXT: .seh_endproc %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a) %result.1 = extractvalue { <2 x double>, <2 x i32> } %result, 1 ret <2 x i32> %result.1 diff --git a/llvm/test/CodeGen/AArch64/llvm.sincos.ll b/llvm/test/CodeGen/AArch64/llvm.sincos.ll index c5efc796e7a3c..f1dcb2a478a0d 100644 --- a/llvm/test/CodeGen/AArch64/llvm.sincos.ll +++ b/llvm/test/CodeGen/AArch64/llvm.sincos.ll @@ -2,12 +2,10 @@ ; RUN: llc -mtriple=aarch64-gnu-linux < %s | FileCheck -check-prefixes=CHECK %s ; RUN: llc -mtriple=aarch64-none-linux < %s | FileCheck -check-prefixes=NO-LIBCALL %s -define { half, half } @test_sincos_f16(half %a) { +define { half, half } @test_sincos_f16(half %a) nounwind { ; CHECK-LABEL: test_sincos_f16: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: fcvt s0, h0 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: add x1, sp, #8 @@ -21,12 +19,8 @@ define { half, half } @test_sincos_f16(half %a) { ; NO-LIBCALL-LABEL: test_sincos_f16: ; NO-LIBCALL: // %bb.0: ; NO-LIBCALL-NEXT: stp d9, d8, [sp, #-32]! // 16-byte Folded Spill -; NO-LIBCALL-NEXT: str x30, [sp, #16] // 8-byte Folded Spill -; NO-LIBCALL-NEXT: .cfi_def_cfa_offset 32 -; NO-LIBCALL-NEXT: .cfi_offset w30, -16 -; NO-LIBCALL-NEXT: .cfi_offset b8, -24 -; NO-LIBCALL-NEXT: .cfi_offset b9, -32 ; NO-LIBCALL-NEXT: fcvt s8, h0 +; NO-LIBCALL-NEXT: str x30, [sp, #16] // 8-byte Folded Spill ; NO-LIBCALL-NEXT: fmov s0, s8 ; NO-LIBCALL-NEXT: bl sinf ; NO-LIBCALL-NEXT: fcvt h9, s0 @@ -42,12 +36,10 @@ define { half, half } @test_sincos_f16(half %a) { ret { half, half } %result } -define half @test_sincos_f16_only_use_sin(half %a) { +define half @test_sincos_f16_only_use_sin(half %a) nounwind { ; CHECK-LABEL: test_sincos_f16_only_use_sin: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: fcvt s0, h0 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: add x1, sp, #8 @@ -60,8 +52,6 @@ define half @test_sincos_f16_only_use_sin(half %a) { ; NO-LIBCALL-LABEL: test_sincos_f16_only_use_sin: ; NO-LIBCALL: // %bb.0: ; NO-LIBCALL-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; NO-LIBCALL-NEXT: .cfi_def_cfa_offset 16 -; NO-LIBCALL-NEXT: .cfi_offset w30, -16 ; NO-LIBCALL-NEXT: fcvt s0, h0 ; NO-LIBCALL-NEXT: bl sinf ; NO-LIBCALL-NEXT: fcvt h0, s0 @@ -72,12 +62,10 @@ define half @test_sincos_f16_only_use_sin(half %a) { ret half %result.0 } -define half @test_sincos_f16_only_use_cos(half %a) { +define half @test_sincos_f16_only_use_cos(half %a) nounwind { ; CHECK-LABEL: test_sincos_f16_only_use_cos: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: fcvt s0, h0 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: add x1, sp, #8 @@ -90,8 +78,6 @@ define half @test_sincos_f16_only_use_cos(half %a) { ; NO-LIBCALL-LABEL: test_sincos_f16_only_use_cos: ; NO-LIBCALL: // %bb.0: ; NO-LIBCALL-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; NO-LIBCALL-NEXT: .cfi_def_cfa_offset 16 -; NO-LIBCALL-NEXT: .cfi_offset w30, -16 ; NO-LIBCALL-NEXT: fcvt s0, h0 ; NO-LIBCALL-NEXT: bl cosf ; NO-LIBCALL-NEXT: fcvt h0, s0 @@ -102,18 +88,16 @@ define half @test_sincos_f16_only_use_cos(half %a) { ret half %result.1 } -define { <2 x half>, <2 x half> } @test_sincos_v2f16(<2 x half> %a) { +define { <2 x half>, <2 x half> } @test_sincos_v2f16(<2 x half> %a) nounwind { ; CHECK-LABEL: test_sincos_v2f16: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #64 -; CHECK-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 64 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-NEXT: mov h1, v0.h[1] ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-NEXT: add x0, sp, #36 ; CHECK-NEXT: add x1, sp, #32 +; CHECK-NEXT: str x30, [sp, #48] // 8-byte Folded Spill ; CHECK-NEXT: fcvt s0, h1 ; CHECK-NEXT: bl sincosf ; CHECK-NEXT: ldr q0, [sp] // 16-byte Folded Reload @@ -160,18 +144,12 @@ define { <2 x half>, <2 x half> } @test_sincos_v2f16(<2 x half> %a) { ; NO-LIBCALL-LABEL: test_sincos_v2f16: ; NO-LIBCALL: // %bb.0: ; NO-LIBCALL-NEXT: sub sp, sp, #80 -; NO-LIBCALL-NEXT: stp d11, d10, [sp, #32] // 16-byte Folded Spill -; NO-LIBCALL-NEXT: stp d9, d8, [sp, #48] // 16-byte Folded Spill -; NO-LIBCALL-NEXT: str x30, [sp, #64] // 8-byte Folded Spill -; NO-LIBCALL-NEXT: .cfi_def_cfa_offset 80 -; NO-LIBCALL-NEXT: .cfi_offset w30, -16 -; NO-LIBCALL-NEXT: .cfi_offset b8, -24 -; NO-LIBCALL-NEXT: .cfi_offset b9, -32 -; NO-LIBCALL-NEXT: .cfi_offset b10, -40 -; NO-LIBCALL-NEXT: .cfi_offset b11, -48 ; NO-LIBCALL-NEXT: // kill: def $d0 killed $d0 def $q0 ; NO-LIBCALL-NEXT: mov h1, v0.h[1] +; NO-LIBCALL-NEXT: stp d9, d8, [sp, #48] // 16-byte Folded Spill ; NO-LIBCALL-NEXT: str q0, [sp] // 16-byte Folded Spill +; NO-LIBCALL-NEXT: stp d11, d10, [sp, #32] // 16-byte Folded Spill +; NO-LIBCALL-NEXT: str x30, [sp, #64] // 8-byte Folded Spill ; NO-LIBCALL-NEXT: fcvt s8, h1 ; NO-LIBCALL-NEXT: fmov s0, s8 ; NO-LIBCALL-NEXT: bl sinf @@ -237,12 +215,10 @@ define { <2 x half>, <2 x half> } @test_sincos_v2f16(<2 x half> %a) { ret { <2 x half>, <2 x half> } %result } -define { float, float } @test_sincos_f32(float %a) { +define { float, float } @test_sincos_f32(float %a) nounwind { ; CHECK-LABEL: test_sincos_f32: ; CHECK: // %bb.0: ; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 16 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: add x0, sp, #12 ; CHECK-NEXT: add x1, sp, #8 ; CHECK-NEXT: bl sincosf @@ -254,10 +230,6 @@ define { float, float } @test_sincos_f32(float %a) { ; NO-LIBCALL: // %bb.0: ; NO-LIBCALL-NEXT: stp d9, d8, [sp, #-32]! // 16-byte Folded Spill ; NO-LIBCALL-NEXT: str x30, [sp, #16] // 8-byte Folded Spill -; NO-LIBCALL-NEXT: .cfi_def_cfa_offset 32 -; NO-LIBCALL-NEXT: .cfi_offset w30, -16 -; NO-LIBCALL-NEXT: .cfi_offset b8, -24 -; NO-LIBCALL-NEXT: .cfi_offset b9, -32 ; NO-LIBCALL-NEXT: fmov s8, s0 ; NO-LIBCALL-NEXT: bl sinf ; NO-LIBCALL-NEXT: fmov s9, s0 @@ -272,21 +244,15 @@ define { float, float } @test_sincos_f32(float %a) { ret { float, float } %result } -define { <3 x float>, <3 x float> } @test_sincos_v3f32(<3 x float> %a) { +define { <3 x float>, <3 x float> } @test_sincos_v3f32(<3 x float> %a) nounwind { ; CHECK-LABEL: test_sincos_v3f32: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #80 +; CHECK-NEXT: add x0, sp, #20 +; CHECK-NEXT: add x1, sp, #16 ; CHECK-NEXT: str x30, [sp, #32] // 8-byte Folded Spill ; CHECK-NEXT: stp x22, x21, [sp, #48] // 16-byte Folded Spill ; CHECK-NEXT: stp x20, x19, [sp, #64] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 80 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w20, -16 -; CHECK-NEXT: .cfi_offset w21, -24 -; CHECK-NEXT: .cfi_offset w22, -32 -; CHECK-NEXT: .cfi_offset w30, -48 -; CHECK-NEXT: add x0, sp, #20 -; CHECK-NEXT: add x1, sp, #16 ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-NEXT: // kill: def $s0 killed $s0 killed $q0 ; CHECK-NEXT: bl sincosf @@ -319,13 +285,9 @@ define { <3 x float>, <3 x float> } @test_sincos_v3f32(<3 x float> %a) { ; NO-LIBCALL: // %bb.0: ; NO-LIBCALL-NEXT: sub sp, sp, #80 ; NO-LIBCALL-NEXT: stp d9, d8, [sp, #48] // 16-byte Folded Spill -; NO-LIBCALL-NEXT: str x30, [sp, #64] // 8-byte Folded Spill -; NO-LIBCALL-NEXT: .cfi_def_cfa_offset 80 -; NO-LIBCALL-NEXT: .cfi_offset w30, -16 -; NO-LIBCALL-NEXT: .cfi_offset b8, -24 -; NO-LIBCALL-NEXT: .cfi_offset b9, -32 ; NO-LIBCALL-NEXT: mov s8, v0.s[1] ; NO-LIBCALL-NEXT: str q0, [sp, #32] // 16-byte Folded Spill +; NO-LIBCALL-NEXT: str x30, [sp, #64] // 8-byte Folded Spill ; NO-LIBCALL-NEXT: fmov s0, s8 ; NO-LIBCALL-NEXT: bl sinf ; NO-LIBCALL-NEXT: // kill: def $s0 killed $s0 def $q0 @@ -369,19 +331,15 @@ define { <3 x float>, <3 x float> } @test_sincos_v3f32(<3 x float> %a) { ret { <3 x float>, <3 x float> } %result } -define { <2 x float>, <2 x float> } @test_sincos_v2f32(<2 x float> %a) { +define { <2 x float>, <2 x float> } @test_sincos_v2f32(<2 x float> %a) nounwind { ; CHECK-LABEL: test_sincos_v2f32: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #64 -; CHECK-NEXT: str x30, [sp, #32] // 8-byte Folded Spill -; CHECK-NEXT: stp x20, x19, [sp, #48] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 64 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w20, -16 -; CHECK-NEXT: .cfi_offset w30, -32 ; CHECK-NEXT: // kill: def $d0 killed $d0 def $q0 ; CHECK-NEXT: add x0, sp, #44 ; CHECK-NEXT: add x1, sp, #40 +; CHECK-NEXT: str x30, [sp, #32] // 8-byte Folded Spill +; CHECK-NEXT: stp x20, x19, [sp, #48] // 16-byte Folded Spill ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-NEXT: // kill: def $s0 killed $s0 killed $q0 ; CHECK-NEXT: bl sincosf @@ -406,13 +364,10 @@ define { <2 x float>, <2 x float> } @test_sincos_v2f32(<2 x float> %a) { ; NO-LIBCALL: // %bb.0: ; NO-LIBCALL-NEXT: sub sp, sp, #64 ; NO-LIBCALL-NEXT: str d8, [sp, #48] // 8-byte Folded Spill -; NO-LIBCALL-NEXT: str x30, [sp, #56] // 8-byte Folded Spill -; NO-LIBCALL-NEXT: .cfi_def_cfa_offset 64 -; NO-LIBCALL-NEXT: .cfi_offset w30, -8 -; NO-LIBCALL-NEXT: .cfi_offset b8, -16 ; NO-LIBCALL-NEXT: // kill: def $d0 killed $d0 def $q0 ; NO-LIBCALL-NEXT: mov s8, v0.s[1] ; NO-LIBCALL-NEXT: str q0, [sp, #32] // 16-byte Folded Spill +; NO-LIBCALL-NEXT: str x30, [sp, #56] // 8-byte Folded Spill ; NO-LIBCALL-NEXT: fmov s0, s8 ; NO-LIBCALL-NEXT: bl sinf ; NO-LIBCALL-NEXT: // kill: def $s0 killed $s0 def $q0 @@ -444,15 +399,13 @@ define { <2 x float>, <2 x float> } @test_sincos_v2f32(<2 x float> %a) { ret { <2 x float>, <2 x float> } %result } -define { double, double } @test_sincos_f64(double %a) { +define { double, double } @test_sincos_f64(double %a) nounwind { ; CHECK-LABEL: test_sincos_f64: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #32 -; CHECK-NEXT: str x30, [sp, #16] // 8-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset w30, -16 ; CHECK-NEXT: add x0, sp, #24 ; CHECK-NEXT: add x1, sp, #8 +; CHECK-NEXT: str x30, [sp, #16] // 8-byte Folded Spill ; CHECK-NEXT: bl sincos ; CHECK-NEXT: ldr d0, [sp, #24] ; CHECK-NEXT: ldr d1, [sp, #8] @@ -464,10 +417,6 @@ define { double, double } @test_sincos_f64(double %a) { ; NO-LIBCALL: // %bb.0: ; NO-LIBCALL-NEXT: stp d9, d8, [sp, #-32]! // 16-byte Folded Spill ; NO-LIBCALL-NEXT: str x30, [sp, #16] // 8-byte Folded Spill -; NO-LIBCALL-NEXT: .cfi_def_cfa_offset 32 -; NO-LIBCALL-NEXT: .cfi_offset w30, -16 -; NO-LIBCALL-NEXT: .cfi_offset b8, -24 -; NO-LIBCALL-NEXT: .cfi_offset b9, -32 ; NO-LIBCALL-NEXT: fmov d8, d0 ; NO-LIBCALL-NEXT: bl sin ; NO-LIBCALL-NEXT: fmov d9, d0 @@ -482,18 +431,14 @@ define { double, double } @test_sincos_f64(double %a) { ret { double, double } %result } -define { <2 x double>, <2 x double> } @test_sincos_v2f64(<2 x double> %a) { +define { <2 x double>, <2 x double> } @test_sincos_v2f64(<2 x double> %a) nounwind { ; CHECK-LABEL: test_sincos_v2f64: ; CHECK: // %bb.0: ; CHECK-NEXT: sub sp, sp, #80 -; CHECK-NEXT: str x30, [sp, #48] // 8-byte Folded Spill -; CHECK-NEXT: stp x20, x19, [sp, #64] // 16-byte Folded Spill -; CHECK-NEXT: .cfi_def_cfa_offset 80 -; CHECK-NEXT: .cfi_offset w19, -8 -; CHECK-NEXT: .cfi_offset w20, -16 -; CHECK-NEXT: .cfi_offset w30, -32 ; CHECK-NEXT: add x0, sp, #56 ; CHECK-NEXT: add x1, sp, #40 +; CHECK-NEXT: str x30, [sp, #48] // 8-byte Folded Spill +; CHECK-NEXT: stp x20, x19, [sp, #64] // 16-byte Folded Spill ; CHECK-NEXT: str q0, [sp] // 16-byte Folded Spill ; CHECK-NEXT: // kill: def $d0 killed $d0 killed $q0 ; CHECK-NEXT: bl sincos @@ -517,12 +462,9 @@ define { <2 x double>, <2 x double> } @test_sincos_v2f64(<2 x double> %a) { ; NO-LIBCALL: // %bb.0: ; NO-LIBCALL-NEXT: sub sp, sp, #64 ; NO-LIBCALL-NEXT: str d8, [sp, #48] // 8-byte Folded Spill -; NO-LIBCALL-NEXT: str x30, [sp, #56] // 8-byte Folded Spill -; NO-LIBCALL-NEXT: .cfi_def_cfa_offset 64 -; NO-LIBCALL-NEXT: .cfi_offset w30, -8 -; NO-LIBCALL-NEXT: .cfi_offset b8, -16 ; NO-LIBCALL-NEXT: mov d8, v0.d[1] ; NO-LIBCALL-NEXT: str q0, [sp, #32] // 16-byte Folded Spill +; NO-LIBCALL-NEXT: str x30, [sp, #56] // 8-byte Folded Spill ; NO-LIBCALL-NEXT: fmov d0, d8 ; NO-LIBCALL-NEXT: bl sin ; NO-LIBCALL-NEXT: // kill: def $d0 killed $d0 def $q0 diff --git a/llvm/test/CodeGen/Mips/ldexp.ll b/llvm/test/CodeGen/Mips/ldexp.ll index 4debc6ddce4aa..d321cdb828e43 100644 --- a/llvm/test/CodeGen/Mips/ldexp.ll +++ b/llvm/test/CodeGen/Mips/ldexp.ll @@ -1,13 +1,11 @@ ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 2 ; RUN: llc -mtriple=mips-- -mattr=+soft-float < %s | FileCheck -check-prefix=SOFT %s -define float @ldexp_f32(i8 zeroext %x) { +define float @ldexp_f32(i8 zeroext %x) nounwind { ; SOFT-LABEL: ldexp_f32: ; SOFT: # %bb.0: ; SOFT-NEXT: addiu $sp, $sp, -24 -; SOFT-NEXT: .cfi_def_cfa_offset 24 ; SOFT-NEXT: sw $ra, 20($sp) # 4-byte Folded Spill -; SOFT-NEXT: .cfi_offset 31, -4 ; SOFT-NEXT: move $5, $4 ; SOFT-NEXT: jal ldexpf ; SOFT-NEXT: lui $4, 16256 @@ -19,13 +17,11 @@ define float @ldexp_f32(i8 zeroext %x) { ret float %ldexp } -define double @ldexp_f64(i8 zeroext %x) { +define double @ldexp_f64(i8 zeroext %x) nounwind { ; SOFT-LABEL: ldexp_f64: ; SOFT: # %bb.0: ; SOFT-NEXT: addiu $sp, $sp, -24 -; SOFT-NEXT: .cfi_def_cfa_offset 24 ; SOFT-NEXT: sw $ra, 20($sp) # 4-byte Folded Spill -; SOFT-NEXT: .cfi_offset 31, -4 ; SOFT-NEXT: move $6, $4 ; SOFT-NEXT: lui $4, 16368 ; SOFT-NEXT: jal ldexp @@ -38,17 +34,13 @@ define double @ldexp_f64(i8 zeroext %x) { ret double %ldexp } -define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) { +define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) nounwind { ; SOFT-LABEL: ldexp_v2f32: ; SOFT: # %bb.0: ; SOFT-NEXT: addiu $sp, $sp, -32 -; SOFT-NEXT: .cfi_def_cfa_offset 32 ; SOFT-NEXT: sw $ra, 28($sp) # 4-byte Folded Spill ; SOFT-NEXT: sw $17, 24($sp) # 4-byte Folded Spill ; SOFT-NEXT: sw $16, 20($sp) # 4-byte Folded Spill -; SOFT-NEXT: .cfi_offset 31, -4 -; SOFT-NEXT: .cfi_offset 17, -8 -; SOFT-NEXT: .cfi_offset 16, -12 ; SOFT-NEXT: move $16, $6 ; SOFT-NEXT: move $17, $4 ; SOFT-NEXT: lw $5, 52($sp) @@ -68,23 +60,16 @@ define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) { ret <2 x float> %1 } -define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) { +define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) nounwind { ; SOFT-LABEL: ldexp_v4f32: ; SOFT: # %bb.0: ; SOFT-NEXT: addiu $sp, $sp, -40 -; SOFT-NEXT: .cfi_def_cfa_offset 40 ; SOFT-NEXT: sw $ra, 36($sp) # 4-byte Folded Spill ; SOFT-NEXT: sw $20, 32($sp) # 4-byte Folded Spill ; SOFT-NEXT: sw $19, 28($sp) # 4-byte Folded Spill ; SOFT-NEXT: sw $18, 24($sp) # 4-byte Folded Spill ; SOFT-NEXT: sw $17, 20($sp) # 4-byte Folded Spill ; SOFT-NEXT: sw $16, 16($sp) # 4-byte Folded Spill -; SOFT-NEXT: .cfi_offset 31, -4 -; SOFT-NEXT: .cfi_offset 20, -8 -; SOFT-NEXT: .cfi_offset 19, -12 -; SOFT-NEXT: .cfi_offset 18, -16 -; SOFT-NEXT: .cfi_offset 17, -20 -; SOFT-NEXT: .cfi_offset 16, -24 ; SOFT-NEXT: move $16, $7 ; SOFT-NEXT: move $18, $4 ; SOFT-NEXT: lw $4, 60($sp) @@ -118,15 +103,12 @@ define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) { ret <4 x float> %1 } -define half @ldexp_f16(half %arg0, i32 %arg1) { +define half @ldexp_f16(half %arg0, i32 %arg1) nounwind { ; SOFT-LABEL: ldexp_f16: ; SOFT: # %bb.0: ; SOFT-NEXT: addiu $sp, $sp, -24 -; SOFT-NEXT: .cfi_def_cfa_offset 24 ; SOFT-NEXT: sw $ra, 20($sp) # 4-byte Folded Spill ; SOFT-NEXT: sw $16, 16($sp) # 4-byte Folded Spill -; SOFT-NEXT: .cfi_offset 31, -4 -; SOFT-NEXT: .cfi_offset 16, -8 ; SOFT-NEXT: move $16, $5 ; SOFT-NEXT: jal __extendhfsf2 ; SOFT-NEXT: andi $4, $4, 65535 @@ -143,13 +125,11 @@ define half @ldexp_f16(half %arg0, i32 %arg1) { ret half %ldexp } -define x86_fp80 @ldexp_f80(x86_fp80 %arg0, i32 %arg1) { +define x86_fp80 @ldexp_f80(x86_fp80 %arg0, i32 %arg1) nounwind { ; SOFT-LABEL: ldexp_f80: ; SOFT: # %bb.0: ; SOFT-NEXT: addiu $sp, $sp, -24 -; SOFT-NEXT: .cfi_def_cfa_offset 24 ; SOFT-NEXT: sw $ra, 20($sp) # 4-byte Folded Spill -; SOFT-NEXT: .cfi_offset 31, -4 ; SOFT-NEXT: jal ldexpl ; SOFT-NEXT: andi $4, $4, 65535 ; SOFT-NEXT: move $4, $2 diff --git a/llvm/test/CodeGen/PowerPC/exp10-libcall.ll b/llvm/test/CodeGen/PowerPC/exp10-libcall.ll index 49a1ac3025c07..68f701cab5a35 100644 --- a/llvm/test/CodeGen/PowerPC/exp10-libcall.ll +++ b/llvm/test/CodeGen/PowerPC/exp10-libcall.ll @@ -2,14 +2,12 @@ ; RUN: llc -mcpu=pwr9 -mtriple=powerpc64le-unknown-unknown \ ; RUN: -ppc-vsr-nums-as-vr -ppc-asm-full-reg-names < %s | FileCheck %s -define float @call_exp10f(float %a) { +define float @call_exp10f(float %a) nounwind { ; CHECK-LABEL: call_exp10f: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -32(r1) ; CHECK-NEXT: std r0, 48(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: bl exp10f ; CHECK-NEXT: nop ; CHECK-NEXT: addi r1, r1, 32 @@ -20,14 +18,12 @@ define float @call_exp10f(float %a) { ret float %result } -define double @call_exp10(double %a) { +define double @call_exp10(double %a) nounwind { ; CHECK-LABEL: call_exp10: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -32(r1) ; CHECK-NEXT: std r0, 48(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: bl exp10 ; CHECK-NEXT: nop ; CHECK-NEXT: addi r1, r1, 32 @@ -38,14 +34,12 @@ define double @call_exp10(double %a) { ret double %result } -define ppc_fp128 @call_exp10l(ppc_fp128 %a) { +define ppc_fp128 @call_exp10l(ppc_fp128 %a) nounwind { ; CHECK-LABEL: call_exp10l: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -32(r1) ; CHECK-NEXT: std r0, 48(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: bl exp10l ; CHECK-NEXT: nop ; CHECK-NEXT: addi r1, r1, 32 diff --git a/llvm/test/CodeGen/PowerPC/ldexp-libcall.ll b/llvm/test/CodeGen/PowerPC/ldexp-libcall.ll index e531516c37e87..680c99bd1e98d 100644 --- a/llvm/test/CodeGen/PowerPC/ldexp-libcall.ll +++ b/llvm/test/CodeGen/PowerPC/ldexp-libcall.ll @@ -2,15 +2,13 @@ ; RUN: llc -mcpu=pwr9 -mtriple=powerpc64le-unknown-unknown \ ; RUN: -ppc-vsr-nums-as-vr -ppc-asm-full-reg-names < %s | FileCheck %s -define float @call_ldexpf(float %a, i32 %b) { +define float @call_ldexpf(float %a, i32 %b) nounwind { ; CHECK-LABEL: call_ldexpf: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -32(r1) -; CHECK-NEXT: std r0, 48(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: extsw r4, r4 +; CHECK-NEXT: std r0, 48(r1) ; CHECK-NEXT: bl ldexpf ; CHECK-NEXT: nop ; CHECK-NEXT: addi r1, r1, 32 @@ -21,15 +19,13 @@ define float @call_ldexpf(float %a, i32 %b) { ret float %result } -define double @call_ldexp(double %a, i32 %b) { +define double @call_ldexp(double %a, i32 %b) nounwind { ; CHECK-LABEL: call_ldexp: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -32(r1) -; CHECK-NEXT: std r0, 48(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: extsw r4, r4 +; CHECK-NEXT: std r0, 48(r1) ; CHECK-NEXT: bl ldexp ; CHECK-NEXT: nop ; CHECK-NEXT: addi r1, r1, 32 @@ -40,15 +36,13 @@ define double @call_ldexp(double %a, i32 %b) { ret double %result } -define ppc_fp128 @call_ldexpl(ppc_fp128 %a, i32 %b) { +define ppc_fp128 @call_ldexpl(ppc_fp128 %a, i32 %b) nounwind { ; CHECK-LABEL: call_ldexpl: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -32(r1) -; CHECK-NEXT: std r0, 48(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: clrldi r5, r5, 32 +; CHECK-NEXT: std r0, 48(r1) ; CHECK-NEXT: bl ldexpl ; CHECK-NEXT: nop ; CHECK-NEXT: addi r1, r1, 32 diff --git a/llvm/test/CodeGen/PowerPC/ldexp.ll b/llvm/test/CodeGen/PowerPC/ldexp.ll index ffc826cc86de5..8d7253b5ce8e3 100644 --- a/llvm/test/CodeGen/PowerPC/ldexp.ll +++ b/llvm/test/CodeGen/PowerPC/ldexp.ll @@ -2,16 +2,14 @@ ; RUN: llc -mcpu=pwr9 -mtriple=powerpc64le-unknown-unknown \ ; RUN: -ppc-vsr-nums-as-vr -ppc-asm-full-reg-names < %s | FileCheck %s -define float @ldexp_f32(i8 zeroext %x) { +define float @ldexp_f32(i8 zeroext %x) nounwind { ; CHECK-LABEL: ldexp_f32: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -32(r1) -; CHECK-NEXT: std r0, 48(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: vspltisw v2, 1 ; CHECK-NEXT: mr r4, r3 +; CHECK-NEXT: std r0, 48(r1) ; CHECK-NEXT: xvcvsxwdp vs1, v2 ; CHECK-NEXT: bl ldexpf ; CHECK-NEXT: nop @@ -24,16 +22,14 @@ define float @ldexp_f32(i8 zeroext %x) { ret float %ldexp } -define double @ldexp_f64(i8 zeroext %x) { +define double @ldexp_f64(i8 zeroext %x) nounwind { ; CHECK-LABEL: ldexp_f64: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -32(r1) -; CHECK-NEXT: std r0, 48(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: vspltisw v2, 1 ; CHECK-NEXT: mr r4, r3 +; CHECK-NEXT: std r0, 48(r1) ; CHECK-NEXT: xvcvsxwdp vs1, v2 ; CHECK-NEXT: bl ldexp ; CHECK-NEXT: nop @@ -46,27 +42,22 @@ define double @ldexp_f64(i8 zeroext %x) { ret double %ldexp } -define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) { +define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) nounwind { ; CHECK-LABEL: ldexp_v2f32: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -80(r1) -; CHECK-NEXT: std r0, 96(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 80 -; CHECK-NEXT: .cfi_offset lr, 16 -; CHECK-NEXT: .cfi_offset v29, -48 -; CHECK-NEXT: .cfi_offset v30, -32 -; CHECK-NEXT: .cfi_offset v31, -16 ; CHECK-NEXT: li r3, 0 ; CHECK-NEXT: xxsldwi vs0, v2, v2, 3 -; CHECK-NEXT: stxv v29, 32(r1) # 16-byte Folded Spill +; CHECK-NEXT: std r0, 96(r1) ; CHECK-NEXT: xscvspdpn f1, vs0 ; CHECK-NEXT: vextuwrx r3, r3, v3 +; CHECK-NEXT: stxv v29, 32(r1) # 16-byte Folded Spill ; CHECK-NEXT: stxv v30, 48(r1) # 16-byte Folded Spill ; CHECK-NEXT: stxv v31, 64(r1) # 16-byte Folded Spill -; CHECK-NEXT: extsw r4, r3 ; CHECK-NEXT: vmr v31, v3 ; CHECK-NEXT: vmr v30, v2 +; CHECK-NEXT: extsw r4, r3 ; CHECK-NEXT: bl ldexpf ; CHECK-NEXT: nop ; CHECK-NEXT: li r3, 4 @@ -90,23 +81,17 @@ define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) { ret <2 x float> %1 } -define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) { +define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) nounwind { ; CHECK-LABEL: ldexp_v4f32: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -96(r1) -; CHECK-NEXT: std r0, 112(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 96 -; CHECK-NEXT: .cfi_offset lr, 16 -; CHECK-NEXT: .cfi_offset v28, -64 -; CHECK-NEXT: .cfi_offset v29, -48 -; CHECK-NEXT: .cfi_offset v30, -32 -; CHECK-NEXT: .cfi_offset v31, -16 ; CHECK-NEXT: li r3, 4 ; CHECK-NEXT: xxswapd vs0, v2 -; CHECK-NEXT: stxv v28, 32(r1) # 16-byte Folded Spill +; CHECK-NEXT: std r0, 112(r1) ; CHECK-NEXT: xscvspdpn f1, vs0 ; CHECK-NEXT: vextuwrx r3, r3, v3 +; CHECK-NEXT: stxv v28, 32(r1) # 16-byte Folded Spill ; CHECK-NEXT: stxv v29, 48(r1) # 16-byte Folded Spill ; CHECK-NEXT: stxv v30, 64(r1) # 16-byte Folded Spill ; CHECK-NEXT: stxv v31, 80(r1) # 16-byte Folded Spill @@ -153,14 +138,12 @@ define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) { ret <4 x float> %1 } -define half @ldexp_f16(half %arg0, i32 %arg1) { +define half @ldexp_f16(half %arg0, i32 %arg1) nounwind { ; CHECK-LABEL: ldexp_f16: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -32(r1) ; CHECK-NEXT: std r0, 48(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: xscvdphp f0, f1 ; CHECK-NEXT: extsw r4, r4 ; CHECK-NEXT: mffprwz r3, f0 @@ -177,15 +160,13 @@ define half @ldexp_f16(half %arg0, i32 %arg1) { ret half %ldexp } -define ppc_fp128 @ldexp_fp128(ppc_fp128 %arg0, i32 %arg1) { +define ppc_fp128 @ldexp_fp128(ppc_fp128 %arg0, i32 %arg1) nounwind { ; CHECK-LABEL: ldexp_fp128: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -32(r1) -; CHECK-NEXT: std r0, 48(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 32 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: clrldi r5, r5, 32 +; CHECK-NEXT: std r0, 48(r1) ; CHECK-NEXT: bl ldexpl ; CHECK-NEXT: nop ; CHECK-NEXT: addi r1, r1, 32 diff --git a/llvm/test/CodeGen/PowerPC/llvm.frexp.ll b/llvm/test/CodeGen/PowerPC/llvm.frexp.ll index 2c522c4d10cda..95d763d7179ed 100644 --- a/llvm/test/CodeGen/PowerPC/llvm.frexp.ll +++ b/llvm/test/CodeGen/PowerPC/llvm.frexp.ll @@ -2,14 +2,12 @@ ; RUN: llc -mcpu=pwr9 -mtriple=powerpc64le-unknown-unknown \ ; RUN: -ppc-vsr-nums-as-vr -ppc-asm-full-reg-names < %s | FileCheck %s -define { half, i32 } @test_frexp_f16_i32(half %a) { +define { half, i32 } @test_frexp_f16_i32(half %a) nounwind { ; CHECK-LABEL: test_frexp_f16_i32: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -48(r1) ; CHECK-NEXT: std r0, 64(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: xscvdphp f0, f1 ; CHECK-NEXT: addi r4, r1, 44 ; CHECK-NEXT: mffprwz r3, f0 @@ -27,14 +25,12 @@ define { half, i32 } @test_frexp_f16_i32(half %a) { ret { half, i32 } %result } -define half @test_frexp_f16_i32_only_use_fract(half %a) { +define half @test_frexp_f16_i32_only_use_fract(half %a) nounwind { ; CHECK-LABEL: test_frexp_f16_i32_only_use_fract: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -48(r1) ; CHECK-NEXT: std r0, 64(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: xscvdphp f0, f1 ; CHECK-NEXT: addi r4, r1, 44 ; CHECK-NEXT: mffprwz r3, f0 @@ -52,14 +48,12 @@ define half @test_frexp_f16_i32_only_use_fract(half %a) { ret half %result.0 } -define i32 @test_frexp_f16_i32_only_use_exp(half %a) { +define i32 @test_frexp_f16_i32_only_use_exp(half %a) nounwind { ; CHECK-LABEL: test_frexp_f16_i32_only_use_exp: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -48(r1) ; CHECK-NEXT: std r0, 64(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: xscvdphp f0, f1 ; CHECK-NEXT: addi r4, r1, 44 ; CHECK-NEXT: mffprwz r3, f0 @@ -78,16 +72,10 @@ define i32 @test_frexp_f16_i32_only_use_exp(half %a) { ret i32 %result.0 } -define { <2 x half>, <2 x i32> } @test_frexp_v2f16_v2i32(<2 x half> %a) { +define { <2 x half>, <2 x i32> } @test_frexp_v2f16_v2i32(<2 x half> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f16_v2i32: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 -; CHECK-NEXT: .cfi_def_cfa_offset 80 -; CHECK-NEXT: .cfi_offset lr, 16 -; CHECK-NEXT: .cfi_offset r29, -40 -; CHECK-NEXT: .cfi_offset r30, -32 -; CHECK-NEXT: .cfi_offset f30, -16 -; CHECK-NEXT: .cfi_offset f31, -8 ; CHECK-NEXT: std r29, -40(r1) # 8-byte Folded Spill ; CHECK-NEXT: std r30, -32(r1) # 8-byte Folded Spill ; CHECK-NEXT: stfd f30, -16(r1) # 8-byte Folded Spill @@ -131,14 +119,10 @@ define { <2 x half>, <2 x i32> } @test_frexp_v2f16_v2i32(<2 x half> %a) { ret { <2 x half>, <2 x i32> } %result } -define <2 x half> @test_frexp_v2f16_v2i32_only_use_fract(<2 x half> %a) { +define <2 x half> @test_frexp_v2f16_v2i32_only_use_fract(<2 x half> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f16_v2i32_only_use_fract: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 -; CHECK-NEXT: .cfi_def_cfa_offset 64 -; CHECK-NEXT: .cfi_offset lr, 16 -; CHECK-NEXT: .cfi_offset f30, -16 -; CHECK-NEXT: .cfi_offset f31, -8 ; CHECK-NEXT: stfd f30, -16(r1) # 8-byte Folded Spill ; CHECK-NEXT: stfd f31, -8(r1) # 8-byte Folded Spill ; CHECK-NEXT: stdu r1, -64(r1) @@ -174,15 +158,10 @@ define <2 x half> @test_frexp_v2f16_v2i32_only_use_fract(<2 x half> %a) { ret <2 x half> %result.0 } -define <2 x i32> @test_frexp_v2f16_v2i32_only_use_exp(<2 x half> %a) { +define <2 x i32> @test_frexp_v2f16_v2i32_only_use_exp(<2 x half> %a) nounwind { ; CHECK-LABEL: test_frexp_v2f16_v2i32_only_use_exp: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 -; CHECK-NEXT: .cfi_def_cfa_offset 80 -; CHECK-NEXT: .cfi_offset lr, 16 -; CHECK-NEXT: .cfi_offset r29, -32 -; CHECK-NEXT: .cfi_offset r30, -24 -; CHECK-NEXT: .cfi_offset f31, -8 ; CHECK-NEXT: std r29, -32(r1) # 8-byte Folded Spill ; CHECK-NEXT: std r30, -24(r1) # 8-byte Folded Spill ; CHECK-NEXT: stfd f31, -8(r1) # 8-byte Folded Spill @@ -222,15 +201,13 @@ define <2 x i32> @test_frexp_v2f16_v2i32_only_use_exp(<2 x half> %a) { ret <2 x i32> %result.1 } -define { float, i32 } @test_frexp_f32_i32(float %a) { +define { float, i32 } @test_frexp_f32_i32(float %a) nounwind { ; CHECK-LABEL: test_frexp_f32_i32: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -48(r1) -; CHECK-NEXT: std r0, 64(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: addi r4, r1, 44 +; CHECK-NEXT: std r0, 64(r1) ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: nop ; CHECK-NEXT: lwz r3, 44(r1) @@ -242,15 +219,13 @@ define { float, i32 } @test_frexp_f32_i32(float %a) { ret { float, i32 } %result } -define float @test_frexp_f32_i32_only_use_fract(float %a) { +define float @test_frexp_f32_i32_only_use_fract(float %a) nounwind { ; CHECK-LABEL: test_frexp_f32_i32_only_use_fract: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -48(r1) -; CHECK-NEXT: std r0, 64(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: addi r4, r1, 44 +; CHECK-NEXT: std r0, 64(r1) ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: nop ; CHECK-NEXT: addi r1, r1, 48 @@ -262,15 +237,13 @@ define float @test_frexp_f32_i32_only_use_fract(float %a) { ret float %result.0 } -define i32 @test_frexp_f32_i32_only_use_exp(float %a) { +define i32 @test_frexp_f32_i32_only_use_exp(float %a) nounwind { ; CHECK-LABEL: test_frexp_f32_i32_only_use_exp: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -48(r1) -; CHECK-NEXT: std r0, 64(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: addi r4, r1, 44 +; CHECK-NEXT: std r0, 64(r1) ; CHECK-NEXT: bl frexpf ; CHECK-NEXT: nop ; CHECK-NEXT: lwz r3, 44(r1) @@ -284,32 +257,30 @@ define i32 @test_frexp_f32_i32_only_use_exp(float %a) { } ; FIXME -; define { <2 x float>, <2 x i32> } @test_frexp_v2f32_v2i32(<2 x float> %a) { +; define { <2 x float>, <2 x i32> } @test_frexp_v2f32_v2i32(<2 x float> %a) nounwind { ; %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a) ; ret { <2 x float>, <2 x i32> } %result ; } -; define <2 x float> @test_frexp_v2f32_v2i32_only_use_fract(<2 x float> %a) { +; define <2 x float> @test_frexp_v2f32_v2i32_only_use_fract(<2 x float> %a) nounwind { ; %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a) ; %result.0 = extractvalue { <2 x float>, <2 x i32> } %result, 0 ; ret <2 x float> %result.0 ; } -; define <2 x i32> @test_frexp_v2f32_v2i32_only_use_exp(<2 x float> %a) { +; define <2 x i32> @test_frexp_v2f32_v2i32_only_use_exp(<2 x float> %a) nounwind { ; %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a) ; %result.1 = extractvalue { <2 x float>, <2 x i32> } %result, 1 ; ret <2 x i32> %result.1 ; } -define { double, i32 } @test_frexp_f64_i32(double %a) { +define { double, i32 } @test_frexp_f64_i32(double %a) nounwind { ; CHECK-LABEL: test_frexp_f64_i32: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -48(r1) -; CHECK-NEXT: std r0, 64(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: addi r4, r1, 44 +; CHECK-NEXT: std r0, 64(r1) ; CHECK-NEXT: bl frexp ; CHECK-NEXT: nop ; CHECK-NEXT: lwz r3, 44(r1) @@ -321,15 +292,13 @@ define { double, i32 } @test_frexp_f64_i32(double %a) { ret { double, i32 } %result } -define double @test_frexp_f64_i32_only_use_fract(double %a) { +define double @test_frexp_f64_i32_only_use_fract(double %a) nounwind { ; CHECK-LABEL: test_frexp_f64_i32_only_use_fract: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -48(r1) -; CHECK-NEXT: std r0, 64(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: addi r4, r1, 44 +; CHECK-NEXT: std r0, 64(r1) ; CHECK-NEXT: bl frexp ; CHECK-NEXT: nop ; CHECK-NEXT: addi r1, r1, 48 @@ -341,15 +310,13 @@ define double @test_frexp_f64_i32_only_use_fract(double %a) { ret double %result.0 } -define i32 @test_frexp_f64_i32_only_use_exp(double %a) { +define i32 @test_frexp_f64_i32_only_use_exp(double %a) nounwind { ; CHECK-LABEL: test_frexp_f64_i32_only_use_exp: ; CHECK: # %bb.0: ; CHECK-NEXT: mflr r0 ; CHECK-NEXT: stdu r1, -48(r1) -; CHECK-NEXT: std r0, 64(r1) -; CHECK-NEXT: .cfi_def_cfa_offset 48 -; CHECK-NEXT: .cfi_offset lr, 16 ; CHECK-NEXT: addi r4, r1, 44 +; CHECK-NEXT: std r0, 64(r1) ; CHECK-NEXT: bl frexp ; CHECK-NEXT: nop ; CHECK-NEXT: lwz r3, 44(r1) @@ -363,36 +330,36 @@ define i32 @test_frexp_f64_i32_only_use_exp(double %a) { } ; FIXME: Widen vector result -; define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) { +; define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) nounwind { ; %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a) ; ret { <2 x double>, <2 x i32> } %result ; } -; define <2 x double> @test_frexp_v2f64_v2i32_only_use_fract(<2 x double> %a) { +; define <2 x double> @test_frexp_v2f64_v2i32_only_use_fract(<2 x double> %a) nounwind { ; %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a) ; %result.0 = extractvalue { <2 x double>, <2 x i32> } %result, 0 ; ret <2 x double> %result.0 ; } -; define <2 x i32> @test_frexp_v2f64_v2i32_only_use_exp(<2 x double> %a) { +; define <2 x i32> @test_frexp_v2f64_v2i32_only_use_exp(<2 x double> %a) nounwind { ; %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a) ; %result.1 = extractvalue { <2 x double>, <2 x i32> } %result, 1 ; ret <2 x i32> %result.1 ; } ; FIXME: f128 ExpandFloatResult -; define { ppc_fp128, i32 } @test_frexp_f128_i32(ppc_fp128 %a) { +; define { ppc_fp128, i32 } @test_frexp_f128_i32(ppc_fp128 %a) nounwind { ; %result = call { ppc_fp128, i32 } @llvm.frexp.f128.i32(ppc_fp128 %a) ; ret { ppc_fp128, i32 } %result ; } -; define ppc_fp128 @test_frexp_f128_i32_only_use_fract(ppc_fp128 %a) { +; define ppc_fp128 @test_frexp_f128_i32_only_use_fract(ppc_fp128 %a) nounwind { ; %result = call { ppc_fp128, i32 } @llvm.frexp.f128.i32(ppc_fp128 %a) ; %result.0 = extractvalue { ppc_fp128, i32 } %result, 0 ; ret ppc_fp128 %result.0 ; } -; define i32 @test_frexp_f128_i32_only_use_exp(ppc_fp128 %a) { +; define i32 @test_frexp_f128_i32_only_use_exp(ppc_fp128 %a) nounwind { ; %result = call { ppc_fp128, i32 } @llvm.frexp.f128.i32(ppc_fp128 %a) ; %result.0 = extractvalue { ppc_fp128, i32 } %result, 1 ; ret i32 %result.0 diff --git a/llvm/test/CodeGen/SystemZ/fp-half-libcall.ll b/llvm/test/CodeGen/SystemZ/fp-half-libcall.ll index d8db549388c46..9f86d24a9e717 100644 --- a/llvm/test/CodeGen/SystemZ/fp-half-libcall.ll +++ b/llvm/test/CodeGen/SystemZ/fp-half-libcall.ll @@ -3,15 +3,11 @@ ; ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s -define half @f1(half %x, i16 %y) { +define half @f1(half %x, i16 %y) nounwind { ; CHECK-LABEL: f1: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r13, %r15, 104(%r15) -; CHECK-NEXT: .cfi_offset %r13, -56 -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -160 -; CHECK-NEXT: .cfi_def_cfa_offset 320 ; CHECK-NEXT: lhr %r13, %r2 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: llgfr %r2, %r13 @@ -23,18 +19,13 @@ define half @f1(half %x, i16 %y) { ret half %tmp } -define half @f2(half %x, half %y) { +define half @f2(half %x, half %y) nounwind { ; CHECK-LABEL: f2: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -176 -; CHECK-NEXT: .cfi_def_cfa_offset 336 ; CHECK-NEXT: std %f8, 168(%r15) # 8-byte Spill ; CHECK-NEXT: std %f9, 160(%r15) # 8-byte Spill -; CHECK-NEXT: .cfi_offset %f8, -168 -; CHECK-NEXT: .cfi_offset %f9, -176 ; CHECK-NEXT: ler %f8, %f2 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: ler %f9, %f0 @@ -52,14 +43,11 @@ define half @f2(half %x, half %y) { ret half %tmp } -define half @f3(half %x) { +define half @f3(half %x) nounwind { ; CHECK-LABEL: f3: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -160 -; CHECK-NEXT: .cfi_def_cfa_offset 320 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: brasl %r14, sinf@PLT ; CHECK-NEXT: brasl %r14, __truncsfhf2@PLT @@ -69,14 +57,11 @@ define half @f3(half %x) { ret half %tmp } -define half @f4(half %x) { +define half @f4(half %x) nounwind { ; CHECK-LABEL: f4: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -160 -; CHECK-NEXT: .cfi_def_cfa_offset 320 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: brasl %r14, cosf@PLT ; CHECK-NEXT: brasl %r14, __truncsfhf2@PLT @@ -86,14 +71,11 @@ define half @f4(half %x) { ret half %tmp } -define half @f5(half %x) { +define half @f5(half %x) nounwind { ; CHECK-LABEL: f5: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -160 -; CHECK-NEXT: .cfi_def_cfa_offset 320 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: brasl %r14, expf@PLT ; CHECK-NEXT: brasl %r14, __truncsfhf2@PLT @@ -103,14 +85,11 @@ define half @f5(half %x) { ret half %tmp } -define half @f6(half %x) { +define half @f6(half %x) nounwind { ; CHECK-LABEL: f6: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -160 -; CHECK-NEXT: .cfi_def_cfa_offset 320 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: brasl %r14, exp2f@PLT ; CHECK-NEXT: brasl %r14, __truncsfhf2@PLT @@ -120,14 +99,11 @@ define half @f6(half %x) { ret half %tmp } -define half @f7(half %x) { +define half @f7(half %x) nounwind { ; CHECK-LABEL: f7: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -160 -; CHECK-NEXT: .cfi_def_cfa_offset 320 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: brasl %r14, logf@PLT ; CHECK-NEXT: brasl %r14, __truncsfhf2@PLT @@ -137,14 +113,11 @@ define half @f7(half %x) { ret half %tmp } -define half @f8(half %x) { +define half @f8(half %x) nounwind { ; CHECK-LABEL: f8: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -160 -; CHECK-NEXT: .cfi_def_cfa_offset 320 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: brasl %r14, log2f@PLT ; CHECK-NEXT: brasl %r14, __truncsfhf2@PLT @@ -154,14 +127,11 @@ define half @f8(half %x) { ret half %tmp } -define half @f9(half %x) { +define half @f9(half %x) nounwind { ; CHECK-LABEL: f9: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -160 -; CHECK-NEXT: .cfi_def_cfa_offset 320 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: brasl %r14, log10f@PLT ; CHECK-NEXT: brasl %r14, __truncsfhf2@PLT @@ -171,18 +141,13 @@ define half @f9(half %x) { ret half %tmp } -define half @f10(half %x, half %y) { +define half @f10(half %x, half %y) nounwind { ; CHECK-LABEL: f10: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -176 -; CHECK-NEXT: .cfi_def_cfa_offset 336 ; CHECK-NEXT: std %f8, 168(%r15) # 8-byte Spill ; CHECK-NEXT: std %f9, 160(%r15) # 8-byte Spill -; CHECK-NEXT: .cfi_offset %f8, -168 -; CHECK-NEXT: .cfi_offset %f9, -176 ; CHECK-NEXT: ler %f8, %f2 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: ler %f9, %f0 @@ -200,18 +165,13 @@ define half @f10(half %x, half %y) { ret half %tmp } -define half @f11(half %x, half %y) { +define half @f11(half %x, half %y) nounwind { ; CHECK-LABEL: f11: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -176 -; CHECK-NEXT: .cfi_def_cfa_offset 336 ; CHECK-NEXT: std %f8, 168(%r15) # 8-byte Spill ; CHECK-NEXT: std %f9, 160(%r15) # 8-byte Spill -; CHECK-NEXT: .cfi_offset %f8, -168 -; CHECK-NEXT: .cfi_offset %f9, -176 ; CHECK-NEXT: ler %f8, %f2 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT ; CHECK-NEXT: ler %f9, %f0 @@ -231,18 +191,13 @@ define half @f11(half %x, half %y) { ; Verify that "nnan" minnum/maxnum calls are transformed to ; compare+select sequences instead of libcalls. -define half @f12(half %x, half %y) { +define half @f12(half %x, half %y) nounwind { ; CHECK-LABEL: f12: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -176 -; CHECK-NEXT: .cfi_def_cfa_offset 336 ; CHECK-NEXT: std %f8, 168(%r15) # 8-byte Spill ; CHECK-NEXT: std %f9, 160(%r15) # 8-byte Spill -; CHECK-NEXT: .cfi_offset %f8, -168 -; CHECK-NEXT: .cfi_offset %f9, -176 ; CHECK-NEXT: ler %f9, %f0 ; CHECK-NEXT: ler %f0, %f2 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT @@ -263,18 +218,13 @@ define half @f12(half %x, half %y) { ret half %tmp } -define half @f13(half %x, half %y) { +define half @f13(half %x, half %y) nounwind { ; CHECK-LABEL: f13: ; CHECK: # %bb.0: ; CHECK-NEXT: stmg %r14, %r15, 112(%r15) -; CHECK-NEXT: .cfi_offset %r14, -48 -; CHECK-NEXT: .cfi_offset %r15, -40 ; CHECK-NEXT: aghi %r15, -176 -; CHECK-NEXT: .cfi_def_cfa_offset 336 ; CHECK-NEXT: std %f8, 168(%r15) # 8-byte Spill ; CHECK-NEXT: std %f9, 160(%r15) # 8-byte Spill -; CHECK-NEXT: .cfi_offset %f8, -168 -; CHECK-NEXT: .cfi_offset %f9, -176 ; CHECK-NEXT: ler %f9, %f0 ; CHECK-NEXT: ler %f0, %f2 ; CHECK-NEXT: brasl %r14, __extendhfsf2@PLT diff --git a/llvm/test/CodeGen/X86/exp10-libcall.ll b/llvm/test/CodeGen/X86/exp10-libcall.ll index a6959ace073f8..4abf6b360ca34 100644 --- a/llvm/test/CodeGen/X86/exp10-libcall.ll +++ b/llvm/test/CodeGen/X86/exp10-libcall.ll @@ -2,14 +2,12 @@ ; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s ; RUN: llc < %s -mtriple=i386-pc-win32 | FileCheck %s -check-prefix=CHECK-WIN -define float @call_exp10f(float %a) { +define float @call_exp10f(float %a) nounwind { ; CHECK-LABEL: call_exp10f: ; CHECK: # %bb.0: ; CHECK-NEXT: pushq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: callq exp10f@PLT ; CHECK-NEXT: popq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 8 ; CHECK-NEXT: retq ; ; CHECK-WIN-LABEL: call_exp10f: @@ -24,14 +22,12 @@ define float @call_exp10f(float %a) { ret float %result } -define double @call_exp10(double %a) { +define double @call_exp10(double %a) nounwind { ; CHECK-LABEL: call_exp10: ; CHECK: # %bb.0: ; CHECK-NEXT: pushq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: callq exp10@PLT ; CHECK-NEXT: popq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 8 ; CHECK-NEXT: retq ; ; CHECK-WIN-LABEL: call_exp10: @@ -46,16 +42,14 @@ define double @call_exp10(double %a) { ret double %result } -define x86_fp80 @call_exp10l(x86_fp80 %a) { +define x86_fp80 @call_exp10l(x86_fp80 %a) nounwind { ; CHECK-LABEL: call_exp10l: ; CHECK: # %bb.0: ; CHECK-NEXT: subq $24, %rsp -; CHECK-NEXT: .cfi_def_cfa_offset 32 ; CHECK-NEXT: fldt {{[0-9]+}}(%rsp) ; CHECK-NEXT: fstpt (%rsp) ; CHECK-NEXT: callq exp10l@PLT ; CHECK-NEXT: addq $24, %rsp -; CHECK-NEXT: .cfi_def_cfa_offset 8 ; CHECK-NEXT: retq ; ; CHECK-WIN-LABEL: call_exp10l: diff --git a/llvm/test/CodeGen/X86/ldexp-f80.ll b/llvm/test/CodeGen/X86/ldexp-f80.ll index 3a10eab2f47cb..84d18d5888cf5 100644 --- a/llvm/test/CodeGen/X86/ldexp-f80.ll +++ b/llvm/test/CodeGen/X86/ldexp-f80.ll @@ -3,33 +3,29 @@ ; FIXME: Expansion without libcall ; XUN: llc -mtriple=i386-pc-win32 < %s | FileCheck -check-prefix=WIN32 %s -define x86_fp80 @ldexp_f80(x86_fp80 %arg0, i32 %arg1) { +define x86_fp80 @ldexp_f80(x86_fp80 %arg0, i32 %arg1) nounwind { ; X64-LABEL: ldexp_f80: ; X64: # %bb.0: ; X64-NEXT: subq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 32 ; X64-NEXT: fldt {{[0-9]+}}(%rsp) ; X64-NEXT: fstpt (%rsp) ; X64-NEXT: callq ldexpl@PLT ; X64-NEXT: addq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq %ldexp = call x86_fp80 @llvm.ldexp.f80.i32(x86_fp80 %arg0, i32 %arg1) ret x86_fp80 %ldexp } -define x86_fp80 @test_strict_ldexp_f80_i32(ptr addrspace(1) %out, x86_fp80 %a, i32 %b) #2 { +define x86_fp80 @test_strict_ldexp_f80_i32(ptr addrspace(1) %out, x86_fp80 %a, i32 %b) nounwind #2 { ; X64-LABEL: test_strict_ldexp_f80_i32: ; X64: # %bb.0: ; X64-NEXT: subq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 32 ; X64-NEXT: movl %esi, %edi ; X64-NEXT: fldt {{[0-9]+}}(%rsp) ; X64-NEXT: fstpt (%rsp) ; X64-NEXT: wait ; X64-NEXT: callq ldexpl@PLT ; X64-NEXT: addq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq %result = call x86_fp80 @llvm.experimental.constrained.ldexp.f80.i32(x86_fp80 %a, i32 %b, metadata !"round.dynamic", metadata !"fpexcept.strict") ret x86_fp80 %result diff --git a/llvm/test/CodeGen/X86/ldexp-libcall.ll b/llvm/test/CodeGen/X86/ldexp-libcall.ll index 3aec4960383f6..74256c801d029 100644 --- a/llvm/test/CodeGen/X86/ldexp-libcall.ll +++ b/llvm/test/CodeGen/X86/ldexp-libcall.ll @@ -2,7 +2,7 @@ ; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s ; RUN: llc < %s -mtriple=i386-pc-win32 | FileCheck %s -check-prefix=CHECK-WIN -define float @call_ldexpf(float %a, i32 %b) { +define float @call_ldexpf(float %a, i32 %b) nounwind { ; CHECK-LABEL: call_ldexpf: ; CHECK: # %bb.0: ; CHECK-NEXT: jmp ldexpf@PLT # TAILCALL @@ -21,7 +21,7 @@ define float @call_ldexpf(float %a, i32 %b) { ret float %result } -define double @call_ldexp(double %a, i32 %b) { +define double @call_ldexp(double %a, i32 %b) nounwind { ; CHECK-LABEL: call_ldexp: ; CHECK: # %bb.0: ; CHECK-NEXT: jmp ldexp@PLT # TAILCALL @@ -40,16 +40,14 @@ define double @call_ldexp(double %a, i32 %b) { ret double %result } -define x86_fp80 @call_ldexpl(x86_fp80 %a, i32 %b) { +define x86_fp80 @call_ldexpl(x86_fp80 %a, i32 %b) nounwind { ; CHECK-LABEL: call_ldexpl: ; CHECK: # %bb.0: ; CHECK-NEXT: subq $24, %rsp -; CHECK-NEXT: .cfi_def_cfa_offset 32 ; CHECK-NEXT: fldt {{[0-9]+}}(%rsp) ; CHECK-NEXT: fstpt (%rsp) ; CHECK-NEXT: callq ldexpl@PLT ; CHECK-NEXT: addq $24, %rsp -; CHECK-NEXT: .cfi_def_cfa_offset 8 ; CHECK-NEXT: retq ; ; CHECK-WIN-LABEL: call_ldexpl: diff --git a/llvm/test/CodeGen/X86/ldexp-not-readonly.ll b/llvm/test/CodeGen/X86/ldexp-not-readonly.ll index aec777375925c..9a67cf8b31714 100644 --- a/llvm/test/CodeGen/X86/ldexp-not-readonly.ll +++ b/llvm/test/CodeGen/X86/ldexp-not-readonly.ll @@ -2,14 +2,12 @@ ; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s ; RUN: llc < %s -mtriple=i386-pc-win32 | FileCheck %s -check-prefix=CHECK-WIN -define float @call_ldexpf(float %a, i32 %b) { +define float @call_ldexpf(float %a, i32 %b) nounwind { ; CHECK-LABEL: call_ldexpf: ; CHECK: # %bb.0: ; CHECK-NEXT: pushq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: callq ldexpf@PLT ; CHECK-NEXT: popq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 8 ; CHECK-NEXT: retq ; ; CHECK-WIN-LABEL: call_ldexpf: @@ -26,14 +24,12 @@ define float @call_ldexpf(float %a, i32 %b) { ret float %result } -define double @call_ldexp(double %a, i32 %b) { +define double @call_ldexp(double %a, i32 %b) nounwind { ; CHECK-LABEL: call_ldexp: ; CHECK: # %bb.0: ; CHECK-NEXT: pushq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: callq ldexp@PLT ; CHECK-NEXT: popq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 8 ; CHECK-NEXT: retq ; ; CHECK-WIN-LABEL: call_ldexp: diff --git a/llvm/test/CodeGen/X86/ldexp-strict.ll b/llvm/test/CodeGen/X86/ldexp-strict.ll index 67e348cb95ff9..f13c59da46c23 100644 --- a/llvm/test/CodeGen/X86/ldexp-strict.ll +++ b/llvm/test/CodeGen/X86/ldexp-strict.ll @@ -4,45 +4,40 @@ ; FIXME: Expansion support without libcalls ; FIXME: Implement f16->f32 promotion for strictfp -; define half @test_strict_ldexp_f16_i32(ptr addrspace(1) %out, half %a, i32 %b) #2 { +; define half @test_strict_ldexp_f16_i32(ptr addrspace(1) %out, half %a, i32 %b) nounwind #2 { ; %result = call half @llvm.experimental.constrained.ldexp.f16.i32(half %a, i32 %b, metadata !"round.dynamic", metadata !"fpexcept.strict") ; ret half %result ; } -define float @test_strict_ldexp_f32_i32(ptr addrspace(1) %out, float %a, i32 %b) #2 { +define float @test_strict_ldexp_f32_i32(ptr addrspace(1) %out, float %a, i32 %b) nounwind #2 { ; X64-LABEL: test_strict_ldexp_f32_i32: ; X64: # %bb.0: ; X64-NEXT: pushq %rax -; X64-NEXT: .cfi_def_cfa_offset 16 ; X64-NEXT: movl %esi, %edi ; X64-NEXT: callq ldexpf@PLT ; X64-NEXT: popq %rax -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq %result = call float @llvm.experimental.constrained.ldexp.f32.i32(float %a, i32 %b, metadata !"round.dynamic", metadata !"fpexcept.strict") ret float %result } -define double @test_strict_ldexp_f64_i32(ptr addrspace(1) %out, double %a, i32 %b) #2 { +define double @test_strict_ldexp_f64_i32(ptr addrspace(1) %out, double %a, i32 %b) nounwind #2 { ; X64-LABEL: test_strict_ldexp_f64_i32: ; X64: # %bb.0: ; X64-NEXT: pushq %rax -; X64-NEXT: .cfi_def_cfa_offset 16 ; X64-NEXT: movl %esi, %edi ; X64-NEXT: callq ldexp@PLT ; X64-NEXT: popq %rax -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq %result = call double @llvm.experimental.constrained.ldexp.f64.i32(double %a, i32 %b, metadata !"round.dynamic", metadata !"fpexcept.strict") ret double %result } -define <2 x float> @test_strict_ldexp_v2f32_v2i32(ptr addrspace(1) %out, <2 x float> %a, <2 x i32> %b) #2 { +define <2 x float> @test_strict_ldexp_v2f32_v2i32(ptr addrspace(1) %out, <2 x float> %a, <2 x i32> %b) nounwind #2 { ; X64-LABEL: test_strict_ldexp_v2f32_v2i32: ; X64: # %bb.0: ; X64-NEXT: subq $56, %rsp -; X64-NEXT: .cfi_def_cfa_offset 64 ; X64-NEXT: movdqa %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; X64-NEXT: movaps %xmm0, (%rsp) # 16-byte Spill ; X64-NEXT: movd %xmm1, %edi @@ -58,7 +53,6 @@ define <2 x float> @test_strict_ldexp_v2f32_v2i32(ptr addrspace(1) %out, <2 x fl ; X64-NEXT: unpcklps {{.*#+}} xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1] ; X64-NEXT: movaps %xmm1, %xmm0 ; X64-NEXT: addq $56, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq %result = call <2 x float> @llvm.experimental.constrained.ldexp.v2f32.v2i32(<2 x float> %a, <2 x i32> %b, metadata !"round.dynamic", metadata !"fpexcept.strict") ret <2 x float> %result diff --git a/llvm/test/CodeGen/X86/ldexp-wrong-signature.ll b/llvm/test/CodeGen/X86/ldexp-wrong-signature.ll index ac58bb53b1747..b4ba53f80ad5b 100644 --- a/llvm/test/CodeGen/X86/ldexp-wrong-signature.ll +++ b/llvm/test/CodeGen/X86/ldexp-wrong-signature.ll @@ -2,14 +2,12 @@ ; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s ; RUN: llc < %s -mtriple=i386-pc-win32 | FileCheck %s -check-prefix=CHECK-WIN -define float @ldexpf_too_many_args(float %a, i32 %b, i32 %c) { +define float @ldexpf_too_many_args(float %a, i32 %b, i32 %c) nounwind { ; CHECK-LABEL: ldexpf_too_many_args: ; CHECK: # %bb.0: ; CHECK-NEXT: pushq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: callq ldexpf@PLT ; CHECK-NEXT: popq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 8 ; CHECK-NEXT: retq ; ; CHECK-WIN-LABEL: ldexpf_too_many_args: @@ -28,14 +26,12 @@ define float @ldexpf_too_many_args(float %a, i32 %b, i32 %c) { ret float %result } -define float @ldexp_wrong_fp_type(float %a, i32 %b) { +define float @ldexp_wrong_fp_type(float %a, i32 %b) nounwind { ; CHECK-LABEL: ldexp_wrong_fp_type: ; CHECK: # %bb.0: ; CHECK-NEXT: pushq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: callq ldexp@PLT ; CHECK-NEXT: popq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 8 ; CHECK-NEXT: retq ; ; CHECK-WIN-LABEL: ldexp_wrong_fp_type: diff --git a/llvm/test/CodeGen/X86/ldexp-wrong-signature2.ll b/llvm/test/CodeGen/X86/ldexp-wrong-signature2.ll index ac79973106ac1..d48c1c2e0a9a7 100644 --- a/llvm/test/CodeGen/X86/ldexp-wrong-signature2.ll +++ b/llvm/test/CodeGen/X86/ldexp-wrong-signature2.ll @@ -2,14 +2,12 @@ ; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s ; RUN: llc < %s -mtriple=i386-pc-win32 | FileCheck %s -check-prefix=CHECK-WIN -define i32 @ldexpf_not_fp(i32 %a, i32 %b) { +define i32 @ldexpf_not_fp(i32 %a, i32 %b) nounwind { ; CHECK-LABEL: ldexpf_not_fp: ; CHECK: # %bb.0: ; CHECK-NEXT: pushq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: callq ldexpf@PLT ; CHECK-NEXT: popq %rcx -; CHECK-NEXT: .cfi_def_cfa_offset 8 ; CHECK-NEXT: retq ; ; CHECK-WIN-LABEL: ldexpf_not_fp: @@ -23,14 +21,12 @@ define i32 @ldexpf_not_fp(i32 %a, i32 %b) { ret i32 %result } -define float @ldexp_not_int(float %a, float %b) { +define float @ldexp_not_int(float %a, float %b) nounwind { ; CHECK-LABEL: ldexp_not_int: ; CHECK: # %bb.0: ; CHECK-NEXT: pushq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: callq ldexp@PLT ; CHECK-NEXT: popq %rax -; CHECK-NEXT: .cfi_def_cfa_offset 8 ; CHECK-NEXT: retq ; ; CHECK-WIN-LABEL: ldexp_not_int: diff --git a/llvm/test/CodeGen/X86/ldexp.ll b/llvm/test/CodeGen/X86/ldexp.ll index 859139463b7e3..59ec7bfcaa910 100644 --- a/llvm/test/CodeGen/X86/ldexp.ll +++ b/llvm/test/CodeGen/X86/ldexp.ll @@ -3,7 +3,7 @@ ; RUN: llc -mtriple=x86_64-pc-win32 -verify-machineinstrs < %s | FileCheck -check-prefixes=WIN64 %s ; RUN: llc -mtriple=i386-pc-win32 -verify-machineinstrs < %s | FileCheck -check-prefix=WIN32 %s -define float @ldexp_f32(i8 zeroext %x) { +define float @ldexp_f32(i8 zeroext %x) nounwind { ; X64-LABEL: ldexp_f32: ; X64: # %bb.0: ; X64-NEXT: movss {{.*#+}} xmm0 = [1.0E+0,0.0E+0,0.0E+0,0.0E+0] @@ -12,17 +12,12 @@ define float @ldexp_f32(i8 zeroext %x) { ; WIN64-LABEL: ldexp_f32: ; WIN64: # %bb.0: ; WIN64-NEXT: subq $40, %rsp -; WIN64-NEXT: .seh_stackalloc 40 -; WIN64-NEXT: .seh_endprologue ; WIN64-NEXT: movzbl %cl, %edx ; WIN64-NEXT: movsd {{.*#+}} xmm0 = [1.0E+0,0.0E+0] ; WIN64-NEXT: callq ldexp ; WIN64-NEXT: cvtsd2ss %xmm0, %xmm0 -; WIN64-NEXT: .seh_startepilogue ; WIN64-NEXT: addq $40, %rsp -; WIN64-NEXT: .seh_endepilogue ; WIN64-NEXT: retq -; WIN64-NEXT: .seh_endproc ; ; WIN32-LABEL: ldexp_f32: ; WIN32: # %bb.0: @@ -41,7 +36,7 @@ define float @ldexp_f32(i8 zeroext %x) { ret float %ldexp } -define double @ldexp_f64(i8 zeroext %x) { +define double @ldexp_f64(i8 zeroext %x) nounwind { ; X64-LABEL: ldexp_f64: ; X64: # %bb.0: ; X64-NEXT: movsd {{.*#+}} xmm0 = [1.0E+0,0.0E+0] @@ -68,11 +63,10 @@ define double @ldexp_f64(i8 zeroext %x) { ret double %ldexp } -define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) { +define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) nounwind { ; X64-LABEL: ldexp_v2f32: ; X64: # %bb.0: ; X64-NEXT: subq $56, %rsp -; X64-NEXT: .cfi_def_cfa_offset 64 ; X64-NEXT: movdqa %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; X64-NEXT: movaps %xmm0, (%rsp) # 16-byte Spill ; X64-NEXT: movd %xmm1, %edi @@ -88,22 +82,15 @@ define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) { ; X64-NEXT: unpcklps {{.*#+}} xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1] ; X64-NEXT: movaps %xmm1, %xmm0 ; X64-NEXT: addq $56, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN64-LABEL: ldexp_v2f32: ; WIN64: # %bb.0: ; WIN64-NEXT: pushq %rsi -; WIN64-NEXT: .seh_pushreg %rsi ; WIN64-NEXT: subq $80, %rsp -; WIN64-NEXT: .seh_stackalloc 80 ; WIN64-NEXT: movaps %xmm8, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm8, 64 ; WIN64-NEXT: movaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm7, 48 ; WIN64-NEXT: movaps %xmm6, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm6, 32 -; WIN64-NEXT: .seh_endprologue ; WIN64-NEXT: movq %rdx, %rsi ; WIN64-NEXT: movaps (%rcx), %xmm7 ; WIN64-NEXT: movl 12(%rdx), %edx @@ -140,12 +127,9 @@ define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) { ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm6 # 16-byte Reload ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm8 # 16-byte Reload -; WIN64-NEXT: .seh_startepilogue ; WIN64-NEXT: addq $80, %rsp ; WIN64-NEXT: popq %rsi -; WIN64-NEXT: .seh_endepilogue ; WIN64-NEXT: retq -; WIN64-NEXT: .seh_endproc ; ; WIN32-LABEL: ldexp_v2f32: ; WIN32: # %bb.0: @@ -172,11 +156,10 @@ define <2 x float> @ldexp_v2f32(<2 x float> %val, <2 x i32> %exp) { ret <2 x float> %1 } -define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) { +define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) nounwind { ; X64-LABEL: ldexp_v4f32: ; X64: # %bb.0: ; X64-NEXT: subq $72, %rsp -; X64-NEXT: .cfi_def_cfa_offset 80 ; X64-NEXT: movdqa %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; X64-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; X64-NEXT: shufps {{.*#+}} xmm0 = xmm0[3,3,3,3] @@ -210,22 +193,15 @@ define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) { ; X64-NEXT: # xmm1 = xmm1[0],mem[0] ; X64-NEXT: movaps %xmm1, %xmm0 ; X64-NEXT: addq $72, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN64-LABEL: ldexp_v4f32: ; WIN64: # %bb.0: ; WIN64-NEXT: pushq %rsi -; WIN64-NEXT: .seh_pushreg %rsi ; WIN64-NEXT: subq $80, %rsp -; WIN64-NEXT: .seh_stackalloc 80 ; WIN64-NEXT: movaps %xmm8, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm8, 64 ; WIN64-NEXT: movaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm7, 48 ; WIN64-NEXT: movaps %xmm6, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm6, 32 -; WIN64-NEXT: .seh_endprologue ; WIN64-NEXT: movq %rdx, %rsi ; WIN64-NEXT: movaps (%rcx), %xmm7 ; WIN64-NEXT: movl 12(%rdx), %edx @@ -262,12 +238,9 @@ define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) { ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm6 # 16-byte Reload ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm8 # 16-byte Reload -; WIN64-NEXT: .seh_startepilogue ; WIN64-NEXT: addq $80, %rsp ; WIN64-NEXT: popq %rsi -; WIN64-NEXT: .seh_endepilogue ; WIN64-NEXT: retq -; WIN64-NEXT: .seh_endproc ; ; WIN32-LABEL: ldexp_v4f32: ; WIN32: # %bb.0: @@ -324,11 +297,10 @@ define <4 x float> @ldexp_v4f32(<4 x float> %val, <4 x i32> %exp) { ret <4 x float> %1 } -define <2 x double> @ldexp_v2f64(<2 x double> %val, <2 x i32> %exp) { +define <2 x double> @ldexp_v2f64(<2 x double> %val, <2 x i32> %exp) nounwind { ; X64-LABEL: ldexp_v2f64: ; X64: # %bb.0: ; X64-NEXT: subq $56, %rsp -; X64-NEXT: .cfi_def_cfa_offset 64 ; X64-NEXT: movdqa %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; X64-NEXT: movaps %xmm0, (%rsp) # 16-byte Spill ; X64-NEXT: movd %xmm1, %edi @@ -344,20 +316,14 @@ define <2 x double> @ldexp_v2f64(<2 x double> %val, <2 x i32> %exp) { ; X64-NEXT: movlhps {{.*#+}} xmm1 = xmm1[0],xmm0[0] ; X64-NEXT: movaps %xmm1, %xmm0 ; X64-NEXT: addq $56, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN64-LABEL: ldexp_v2f64: ; WIN64: # %bb.0: ; WIN64-NEXT: pushq %rsi -; WIN64-NEXT: .seh_pushreg %rsi ; WIN64-NEXT: subq $64, %rsp -; WIN64-NEXT: .seh_stackalloc 64 ; WIN64-NEXT: movaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm7, 48 ; WIN64-NEXT: movaps %xmm6, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm6, 32 -; WIN64-NEXT: .seh_endprologue ; WIN64-NEXT: movaps (%rcx), %xmm6 ; WIN64-NEXT: movl (%rdx), %eax ; WIN64-NEXT: movl 4(%rdx), %esi @@ -373,12 +339,9 @@ define <2 x double> @ldexp_v2f64(<2 x double> %val, <2 x i32> %exp) { ; WIN64-NEXT: movaps %xmm7, %xmm0 ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm6 # 16-byte Reload ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload -; WIN64-NEXT: .seh_startepilogue ; WIN64-NEXT: addq $64, %rsp ; WIN64-NEXT: popq %rsi -; WIN64-NEXT: .seh_endepilogue ; WIN64-NEXT: retq -; WIN64-NEXT: .seh_endproc ; ; WIN32-LABEL: ldexp_v2f64: ; WIN32: # %bb.0: @@ -406,17 +369,12 @@ define <2 x double> @ldexp_v2f64(<2 x double> %val, <2 x i32> %exp) { ret <2 x double> %1 } -define <4 x double> @ldexp_v4f64(<4 x double> %val, <4 x i32> %exp) { +define <4 x double> @ldexp_v4f64(<4 x double> %val, <4 x i32> %exp) nounwind { ; X64-LABEL: ldexp_v4f64: ; X64: # %bb.0: ; X64-NEXT: pushq %rbp -; X64-NEXT: .cfi_def_cfa_offset 16 ; X64-NEXT: pushq %rbx -; X64-NEXT: .cfi_def_cfa_offset 24 ; X64-NEXT: subq $72, %rsp -; X64-NEXT: .cfi_def_cfa_offset 96 -; X64-NEXT: .cfi_offset %rbx, -24 -; X64-NEXT: .cfi_offset %rbp, -16 ; X64-NEXT: movaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; X64-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; X64-NEXT: movdqa %xmm2, (%rsp) # 16-byte Spill @@ -449,30 +407,19 @@ define <4 x double> @ldexp_v4f64(<4 x double> %val, <4 x i32> %exp) { ; X64-NEXT: # xmm1 = xmm1[0],mem[0] ; X64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload ; X64-NEXT: addq $72, %rsp -; X64-NEXT: .cfi_def_cfa_offset 24 ; X64-NEXT: popq %rbx -; X64-NEXT: .cfi_def_cfa_offset 16 ; X64-NEXT: popq %rbp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN64-LABEL: ldexp_v4f64: ; WIN64: # %bb.0: ; WIN64-NEXT: pushq %rsi -; WIN64-NEXT: .seh_pushreg %rsi ; WIN64-NEXT: pushq %rdi -; WIN64-NEXT: .seh_pushreg %rdi ; WIN64-NEXT: pushq %rbx -; WIN64-NEXT: .seh_pushreg %rbx ; WIN64-NEXT: subq $80, %rsp -; WIN64-NEXT: .seh_stackalloc 80 ; WIN64-NEXT: movaps %xmm8, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm8, 64 ; WIN64-NEXT: movaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm7, 48 ; WIN64-NEXT: movaps %xmm6, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill -; WIN64-NEXT: .seh_savexmm %xmm6, 32 -; WIN64-NEXT: .seh_endprologue ; WIN64-NEXT: movl 12(%r8), %esi ; WIN64-NEXT: movl 8(%r8), %edi ; WIN64-NEXT: movaps (%rdx), %xmm6 @@ -501,14 +448,11 @@ define <4 x double> @ldexp_v4f64(<4 x double> %val, <4 x i32> %exp) { ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm6 # 16-byte Reload ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload ; WIN64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm8 # 16-byte Reload -; WIN64-NEXT: .seh_startepilogue ; WIN64-NEXT: addq $80, %rsp ; WIN64-NEXT: popq %rbx ; WIN64-NEXT: popq %rdi ; WIN64-NEXT: popq %rsi -; WIN64-NEXT: .seh_endepilogue ; WIN64-NEXT: retq -; WIN64-NEXT: .seh_endproc ; ; WIN32-LABEL: ldexp_v4f64: ; WIN32: # %bb.0: @@ -565,41 +509,31 @@ define <4 x double> @ldexp_v4f64(<4 x double> %val, <4 x i32> %exp) { ret <4 x double> %1 } -define half @ldexp_f16(half %arg0, i32 %arg1) { +define half @ldexp_f16(half %arg0, i32 %arg1) nounwind { ; X64-LABEL: ldexp_f16: ; X64: # %bb.0: ; X64-NEXT: pushq %rbx -; X64-NEXT: .cfi_def_cfa_offset 16 -; X64-NEXT: .cfi_offset %rbx, -16 ; X64-NEXT: movl %edi, %ebx ; X64-NEXT: callq __extendhfsf2@PLT ; X64-NEXT: movl %ebx, %edi ; X64-NEXT: callq ldexpf@PLT ; X64-NEXT: callq __truncsfhf2@PLT ; X64-NEXT: popq %rbx -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN64-LABEL: ldexp_f16: ; WIN64: # %bb.0: ; WIN64-NEXT: pushq %rsi -; WIN64-NEXT: .seh_pushreg %rsi ; WIN64-NEXT: subq $32, %rsp -; WIN64-NEXT: .seh_stackalloc 32 -; WIN64-NEXT: .seh_endprologue ; WIN64-NEXT: movl %edx, %esi ; WIN64-NEXT: callq __extendhfsf2 ; WIN64-NEXT: cvtss2sd %xmm0, %xmm0 ; WIN64-NEXT: movl %esi, %edx ; WIN64-NEXT: callq ldexp ; WIN64-NEXT: callq __truncdfhf2 -; WIN64-NEXT: nop -; WIN64-NEXT: .seh_startepilogue ; WIN64-NEXT: addq $32, %rsp ; WIN64-NEXT: popq %rsi -; WIN64-NEXT: .seh_endepilogue ; WIN64-NEXT: retq -; WIN64-NEXT: .seh_endproc ; ; WIN32-LABEL: ldexp_f16: ; WIN32: # %bb.0: diff --git a/llvm/test/CodeGen/X86/llvm.frexp.f80.ll b/llvm/test/CodeGen/X86/llvm.frexp.f80.ll index 92d8c53c8182e..61e2bba822017 100644 --- a/llvm/test/CodeGen/X86/llvm.frexp.f80.ll +++ b/llvm/test/CodeGen/X86/llvm.frexp.f80.ll @@ -3,52 +3,46 @@ ; RUN: llc -mtriple=x86_64-unknown-unknown < %s | FileCheck -check-prefixes=X64 %s ; XUN: llc -mtriple=i386-pc-win32 < %s | FileCheck -check-prefix=X64 %s -define { x86_fp80, i32 } @test_frexp_f80_i32(x86_fp80 %a) { +define { x86_fp80, i32 } @test_frexp_f80_i32(x86_fp80 %a) nounwind { ; X64-LABEL: test_frexp_f80_i32: ; X64: # %bb.0: ; X64-NEXT: subq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 32 ; X64-NEXT: fldt {{[0-9]+}}(%rsp) ; X64-NEXT: fstpt (%rsp) ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi ; X64-NEXT: callq frexpl@PLT ; X64-NEXT: movl {{[0-9]+}}(%rsp), %eax ; X64-NEXT: addq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq %result = call { x86_fp80, i32 } @llvm.frexp.f80.i32(x86_fp80 %a) ret { x86_fp80, i32 } %result } -define x86_fp80 @test_frexp_f80_i32_only_use_fract(x86_fp80 %a) { +define x86_fp80 @test_frexp_f80_i32_only_use_fract(x86_fp80 %a) nounwind { ; X64-LABEL: test_frexp_f80_i32_only_use_fract: ; X64: # %bb.0: ; X64-NEXT: subq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 32 ; X64-NEXT: fldt {{[0-9]+}}(%rsp) ; X64-NEXT: fstpt (%rsp) ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi ; X64-NEXT: callq frexpl@PLT ; X64-NEXT: addq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq %result = call { x86_fp80, i32 } @llvm.frexp.f80.i32(x86_fp80 %a) %result.0 = extractvalue { x86_fp80, i32 } %result, 0 ret x86_fp80 %result.0 } -define x86_fp80 @test_frexp_f80_i32_only_use_fract_math(x86_fp80 %a) { +define x86_fp80 @test_frexp_f80_i32_only_use_fract_math(x86_fp80 %a) nounwind { ; X64-LABEL: test_frexp_f80_i32_only_use_fract_math: ; X64: # %bb.0: ; X64-NEXT: subq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 32 ; X64-NEXT: fldt {{[0-9]+}}(%rsp) ; X64-NEXT: fstpt (%rsp) ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi ; X64-NEXT: callq frexpl@PLT ; X64-NEXT: fadd %st, %st(0) ; X64-NEXT: addq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq %result = call { x86_fp80, i32 } @llvm.frexp.f80.i32(x86_fp80 %a) %result.0 = extractvalue { x86_fp80, i32 } %result, 0 @@ -56,11 +50,10 @@ define x86_fp80 @test_frexp_f80_i32_only_use_fract_math(x86_fp80 %a) { ret x86_fp80 %add } -define i32 @test_frexp_f80_i32_only_use_exp(x86_fp80 %a) { +define i32 @test_frexp_f80_i32_only_use_exp(x86_fp80 %a) nounwind { ; X64-LABEL: test_frexp_f80_i32_only_use_exp: ; X64: # %bb.0: ; X64-NEXT: subq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 32 ; X64-NEXT: fldt {{[0-9]+}}(%rsp) ; X64-NEXT: fstpt (%rsp) ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi @@ -68,7 +61,6 @@ define i32 @test_frexp_f80_i32_only_use_exp(x86_fp80 %a) { ; X64-NEXT: fstp %st(0) ; X64-NEXT: movl {{[0-9]+}}(%rsp), %eax ; X64-NEXT: addq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq %result = call { x86_fp80, i32 } @llvm.frexp.f80.i32(x86_fp80 %a) %result.0 = extractvalue { x86_fp80, i32 } %result, 1 diff --git a/llvm/test/CodeGen/X86/llvm.frexp.ll b/llvm/test/CodeGen/X86/llvm.frexp.ll index 8436c1052552e..83840dd85c533 100644 --- a/llvm/test/CodeGen/X86/llvm.frexp.ll +++ b/llvm/test/CodeGen/X86/llvm.frexp.ll @@ -2,11 +2,10 @@ ; RUN: llc -mtriple=x86_64-unknown-unknown < %s | FileCheck -check-prefixes=X64 %s ; RUN: llc -mtriple=i386-pc-win32 < %s | FileCheck -check-prefix=WIN32 %s -define { half, i32 } @test_frexp_f16_i32(half %a) { +define { half, i32 } @test_frexp_f16_i32(half %a) nounwind { ; X64-LABEL: test_frexp_f16_i32: ; X64: # %bb.0: ; X64-NEXT: subq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 32 ; X64-NEXT: movaps %xmm0, (%rsp) # 16-byte Spill ; X64-NEXT: callq __extendhfsf2@PLT ; X64-NEXT: mulss {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0 @@ -36,7 +35,6 @@ define { half, i32 } @test_frexp_f16_i32(half %a) { ; X64-NEXT: cmovbel %edx, %ecx ; X64-NEXT: pinsrw $0, %ecx, %xmm0 ; X64-NEXT: addq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_f16_i32: @@ -63,11 +61,10 @@ define { half, i32 } @test_frexp_f16_i32(half %a) { ret { half, i32 } %result } -define half @test_frexp_f16_i32_only_use_fract(half %a) { +define half @test_frexp_f16_i32_only_use_fract(half %a) nounwind { ; X64-LABEL: test_frexp_f16_i32_only_use_fract: ; X64: # %bb.0: ; X64-NEXT: subq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 32 ; X64-NEXT: movaps %xmm0, (%rsp) # 16-byte Spill ; X64-NEXT: callq __extendhfsf2@PLT ; X64-NEXT: mulss {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0 @@ -87,7 +84,6 @@ define half @test_frexp_f16_i32_only_use_fract(half %a) { ; X64-NEXT: cmovbel %ecx, %eax ; X64-NEXT: pinsrw $0, %eax, %xmm0 ; X64-NEXT: addq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_f16_i32_only_use_fract: @@ -111,11 +107,10 @@ define half @test_frexp_f16_i32_only_use_fract(half %a) { ret half %result.0 } -define i32 @test_frexp_f16_i32_only_use_exp(half %a) { +define i32 @test_frexp_f16_i32_only_use_exp(half %a) nounwind { ; X64-LABEL: test_frexp_f16_i32_only_use_exp: ; X64: # %bb.0: ; X64-NEXT: subq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 32 ; X64-NEXT: movaps %xmm0, (%rsp) # 16-byte Spill ; X64-NEXT: callq __extendhfsf2@PLT ; X64-NEXT: mulss {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0 @@ -138,7 +133,6 @@ define i32 @test_frexp_f16_i32_only_use_exp(half %a) { ; X64-NEXT: cmpl $33792, %ecx # imm = 0x8400 ; X64-NEXT: cmoval %edx, %eax ; X64-NEXT: addq $24, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_f16_i32_only_use_exp: @@ -161,33 +155,31 @@ define i32 @test_frexp_f16_i32_only_use_exp(half %a) { } ; FIXME -; define { <2 x half>, <2 x i32> } @test_frexp_v2f16_v2i32(<2 x half> %a) { +; define { <2 x half>, <2 x i32> } @test_frexp_v2f16_v2i32(<2 x half> %a) nounwind { ; %result = call { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half> %a) ; ret { <2 x half>, <2 x i32> } %result ; } -; define <2 x half> @test_frexp_v2f16_v2i32_only_use_fract(<2 x half> %a) { +; define <2 x half> @test_frexp_v2f16_v2i32_only_use_fract(<2 x half> %a) nounwind { ; %result = call { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half> %a) ; %result.0 = extractvalue { <2 x half>, <2 x i32> } %result, 0 ; ret <2 x half> %result.0 ; } -; define <2 x i32> @test_frexp_v2f16_v2i32_only_use_exp(<2 x half> %a) { +; define <2 x i32> @test_frexp_v2f16_v2i32_only_use_exp(<2 x half> %a) nounwind { ; %result = call { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half> %a) ; %result.1 = extractvalue { <2 x half>, <2 x i32> } %result, 1 ; ret <2 x i32> %result.1 ; } -define { float, i32 } @test_frexp_f32_i32(float %a) { +define { float, i32 } @test_frexp_f32_i32(float %a) nounwind { ; X64-LABEL: test_frexp_f32_i32: ; X64: # %bb.0: ; X64-NEXT: pushq %rax -; X64-NEXT: .cfi_def_cfa_offset 16 ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi ; X64-NEXT: callq frexpf@PLT ; X64-NEXT: movl {{[0-9]+}}(%rsp), %eax ; X64-NEXT: popq %rcx -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_f32_i32: @@ -207,15 +199,13 @@ define { float, i32 } @test_frexp_f32_i32(float %a) { ret { float, i32 } %result } -define float @test_frexp_f32_i32_only_use_fract(float %a) { +define float @test_frexp_f32_i32_only_use_fract(float %a) nounwind { ; X64-LABEL: test_frexp_f32_i32_only_use_fract: ; X64: # %bb.0: ; X64-NEXT: pushq %rax -; X64-NEXT: .cfi_def_cfa_offset 16 ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi ; X64-NEXT: callq frexpf@PLT ; X64-NEXT: popq %rax -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_f32_i32_only_use_fract: @@ -235,16 +225,14 @@ define float @test_frexp_f32_i32_only_use_fract(float %a) { ret float %result.0 } -define i32 @test_frexp_f32_i32_only_use_exp(float %a) { +define i32 @test_frexp_f32_i32_only_use_exp(float %a) nounwind { ; X64-LABEL: test_frexp_f32_i32_only_use_exp: ; X64: # %bb.0: ; X64-NEXT: pushq %rax -; X64-NEXT: .cfi_def_cfa_offset 16 ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi ; X64-NEXT: callq frexpf@PLT ; X64-NEXT: movl {{[0-9]+}}(%rsp), %eax ; X64-NEXT: popq %rcx -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_f32_i32_only_use_exp: @@ -265,28 +253,27 @@ define i32 @test_frexp_f32_i32_only_use_exp(float %a) { } ; FIXME: Widen vector result -; define { <2 x float>, <2 x i32> } @test_frexp_v2f32_v2i32(<2 x float> %a) { +; define { <2 x float>, <2 x i32> } @test_frexp_v2f32_v2i32(<2 x float> %a) nounwind { ; %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a) ; ret { <2 x float>, <2 x i32> } %result ; } -; define <2 x float> @test_frexp_v2f32_v2i32_only_use_fract(<2 x float> %a) { +; define <2 x float> @test_frexp_v2f32_v2i32_only_use_fract(<2 x float> %a) nounwind { ; %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a) ; %result.0 = extractvalue { <2 x float>, <2 x i32> } %result, 0 ; ret <2 x float> %result.0 ; } -; define <2 x i32> @test_frexp_v2f32_v2i32_only_use_exp(<2 x float> %a) { +; define <2 x i32> @test_frexp_v2f32_v2i32_only_use_exp(<2 x float> %a) nounwind { ; %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a) ; %result.1 = extractvalue { <2 x float>, <2 x i32> } %result, 1 ; ret <2 x i32> %result.1 ; } -define { <4 x float>, <4 x i32> } @test_frexp_v4f32_v4i32(<4 x float> %a) { +define { <4 x float>, <4 x i32> } @test_frexp_v4f32_v4i32(<4 x float> %a) nounwind { ; X64-LABEL: test_frexp_v4f32_v4i32: ; X64: # %bb.0: ; X64-NEXT: subq $72, %rsp -; X64-NEXT: .cfi_def_cfa_offset 80 ; X64-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; X64-NEXT: shufps {{.*#+}} xmm0 = xmm0[3,3,3,3] ; X64-NEXT: movq %rsp, %rdi @@ -320,7 +307,6 @@ define { <4 x float>, <4 x i32> } @test_frexp_v4f32_v4i32(<4 x float> %a) { ; X64-NEXT: unpcklps {{.*#+}} xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1] ; X64-NEXT: movlhps {{.*#+}} xmm1 = xmm1[0],xmm2[0] ; X64-NEXT: addq $72, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_v4f32_v4i32: @@ -372,11 +358,10 @@ define { <4 x float>, <4 x i32> } @test_frexp_v4f32_v4i32(<4 x float> %a) { ret { <4 x float>, <4 x i32> } %result } -define <4 x float> @test_frexp_v4f32_v4i32_only_use_fract(<4 x float> %a) { +define <4 x float> @test_frexp_v4f32_v4i32_only_use_fract(<4 x float> %a) nounwind { ; X64-LABEL: test_frexp_v4f32_v4i32_only_use_fract: ; X64: # %bb.0: ; X64-NEXT: subq $72, %rsp -; X64-NEXT: .cfi_def_cfa_offset 80 ; X64-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; X64-NEXT: shufps {{.*#+}} xmm0 = xmm0[3,3,3,3] ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi @@ -403,7 +388,6 @@ define <4 x float> @test_frexp_v4f32_v4i32_only_use_fract(<4 x float> %a) { ; X64-NEXT: # xmm1 = xmm1[0],mem[0] ; X64-NEXT: movaps %xmm1, %xmm0 ; X64-NEXT: addq $72, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_v4f32_v4i32_only_use_fract: @@ -456,11 +440,10 @@ define <4 x float> @test_frexp_v4f32_v4i32_only_use_fract(<4 x float> %a) { ret <4 x float> %result.0 } -define <4 x i32> @test_frexp_v4f32_v4i32_only_use_exp(<4 x float> %a) { +define <4 x i32> @test_frexp_v4f32_v4i32_only_use_exp(<4 x float> %a) nounwind { ; X64-LABEL: test_frexp_v4f32_v4i32_only_use_exp: ; X64: # %bb.0: ; X64-NEXT: subq $40, %rsp -; X64-NEXT: .cfi_def_cfa_offset 48 ; X64-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; X64-NEXT: shufps {{.*#+}} xmm0 = xmm0[3,3,3,3] ; X64-NEXT: movq %rsp, %rdi @@ -484,7 +467,6 @@ define <4 x i32> @test_frexp_v4f32_v4i32_only_use_exp(<4 x float> %a) { ; X64-NEXT: unpcklps {{.*#+}} xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1] ; X64-NEXT: movlhps {{.*#+}} xmm0 = xmm0[0],xmm1[0] ; X64-NEXT: addq $40, %rsp -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_v4f32_v4i32_only_use_exp: @@ -524,16 +506,14 @@ define <4 x i32> @test_frexp_v4f32_v4i32_only_use_exp(<4 x float> %a) { ret <4 x i32> %result.1 } -define { double, i32 } @test_frexp_f64_i32(double %a) { +define { double, i32 } @test_frexp_f64_i32(double %a) nounwind { ; X64-LABEL: test_frexp_f64_i32: ; X64: # %bb.0: ; X64-NEXT: pushq %rax -; X64-NEXT: .cfi_def_cfa_offset 16 ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi ; X64-NEXT: callq frexp@PLT ; X64-NEXT: movl {{[0-9]+}}(%rsp), %eax ; X64-NEXT: popq %rcx -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_f64_i32: @@ -551,15 +531,13 @@ define { double, i32 } @test_frexp_f64_i32(double %a) { ret { double, i32 } %result } -define double @test_frexp_f64_i32_only_use_fract(double %a) { +define double @test_frexp_f64_i32_only_use_fract(double %a) nounwind { ; X64-LABEL: test_frexp_f64_i32_only_use_fract: ; X64: # %bb.0: ; X64-NEXT: pushq %rax -; X64-NEXT: .cfi_def_cfa_offset 16 ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi ; X64-NEXT: callq frexp@PLT ; X64-NEXT: popq %rax -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_f64_i32_only_use_fract: @@ -577,16 +555,14 @@ define double @test_frexp_f64_i32_only_use_fract(double %a) { ret double %result.0 } -define i32 @test_frexp_f64_i32_only_use_exp(double %a) { +define i32 @test_frexp_f64_i32_only_use_exp(double %a) nounwind { ; X64-LABEL: test_frexp_f64_i32_only_use_exp: ; X64: # %bb.0: ; X64-NEXT: pushq %rax -; X64-NEXT: .cfi_def_cfa_offset 16 ; X64-NEXT: leaq {{[0-9]+}}(%rsp), %rdi ; X64-NEXT: callq frexp@PLT ; X64-NEXT: movl {{[0-9]+}}(%rsp), %eax ; X64-NEXT: popq %rcx -; X64-NEXT: .cfi_def_cfa_offset 8 ; X64-NEXT: retq ; ; WIN32-LABEL: test_frexp_f64_i32_only_use_exp: @@ -607,18 +583,18 @@ define i32 @test_frexp_f64_i32_only_use_exp(double %a) { } ; FIXME: Widen vector result -; define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) { +; define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) nounwind { ; %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a) ; ret { <2 x double>, <2 x i32> } %result ; } -; define <2 x double> @test_frexp_v2f64_v2i32_only_use_fract(<2 x double> %a) { +; define <2 x double> @test_frexp_v2f64_v2i32_only_use_fract(<2 x double> %a) nounwind { ; %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a) ; %result.0 = extractvalue { <2 x double>, <2 x i32> } %result, 0 ; ret <2 x double> %result.0 ; } -; define <2 x i32> @test_frexp_v2f64_v2i32_only_use_exp(<2 x double> %a) { +; define <2 x i32> @test_frexp_v2f64_v2i32_only_use_exp(<2 x double> %a) nounwind { ; %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a) ; %result.1 = extractvalue { <2 x double>, <2 x i32> } %result, 1 ; ret <2 x i32> %result.1 diff --git a/llvm/test/CodeGen/X86/sincos-stack-args.ll b/llvm/test/CodeGen/X86/sincos-stack-args.ll index fe15330833334..42c05a3e7a9be 100644 --- a/llvm/test/CodeGen/X86/sincos-stack-args.ll +++ b/llvm/test/CodeGen/X86/sincos-stack-args.ll @@ -7,11 +7,10 @@ declare double @g(double, double) ; Though not visible within the IR, this will lower to an FSINCOS node, with ; store users, that are within a (callseq_start, callseq_end) pair. In this ; case, the stores cannot be folded into the sincos call. -define double @negative_sincos_with_stores_within_call_sequence(double %a) { +define double @negative_sincos_with_stores_within_call_sequence(double %a) nounwind { ; CHECK-LABEL: negative_sincos_with_stores_within_call_sequence: ; CHECK: # %bb.0: # %entry ; CHECK-NEXT: subl $44, %esp -; CHECK-NEXT: .cfi_def_cfa_offset 48 ; CHECK-NEXT: fldl 48(%esp) ; CHECK-NEXT: leal 24(%esp), %eax ; CHECK-NEXT: movl %eax, 12(%esp) @@ -27,7 +26,6 @@ define double @negative_sincos_with_stores_within_call_sequence(double %a) { ; CHECK-NEXT: fstpl (%esp) ; CHECK-NEXT: calll g@PLT ; CHECK-NEXT: addl $44, %esp -; CHECK-NEXT: .cfi_def_cfa_offset 4 ; CHECK-NEXT: retl entry: %0 = tail call double @llvm.sin.f64(double %a) diff --git a/llvm/test/CodeGen/X86/sincos.ll b/llvm/test/CodeGen/X86/sincos.ll index 42b1555e78b17..79034077f1835 100644 --- a/llvm/test/CodeGen/X86/sincos.ll +++ b/llvm/test/CodeGen/X86/sincos.ll @@ -9,11 +9,10 @@ declare double @sin(double) readonly declare x86_fp80 @sinl(x86_fp80) readonly -define float @test1(float %X) { +define float @test1(float %X) nounwind { ; CHECK-LABEL: test1: ; CHECK: ## %bb.0: ; CHECK-NEXT: subl $12, %esp -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: flds {{[0-9]+}}(%esp) ; CHECK-NEXT: fstps (%esp) ; CHECK-NEXT: calll _sinf @@ -23,11 +22,10 @@ define float @test1(float %X) { ret float %Y } -define double @test2(double %X) { +define double @test2(double %X) nounwind { ; CHECK-LABEL: test2: ; CHECK: ## %bb.0: ; CHECK-NEXT: subl $12, %esp -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: fldl {{[0-9]+}}(%esp) ; CHECK-NEXT: fstpl (%esp) ; CHECK-NEXT: calll _sin @@ -37,11 +35,10 @@ define double @test2(double %X) { ret double %Y } -define x86_fp80 @test3(x86_fp80 %X) { +define x86_fp80 @test3(x86_fp80 %X) nounwind { ; CHECK-LABEL: test3: ; CHECK: ## %bb.0: ; CHECK-NEXT: subl $28, %esp -; CHECK-NEXT: .cfi_def_cfa_offset 32 ; CHECK-NEXT: fldt {{[0-9]+}}(%esp) ; CHECK-NEXT: fstpt (%esp) ; CHECK-NEXT: calll _sinl @@ -58,11 +55,10 @@ declare double @cos(double) readonly declare x86_fp80 @cosl(x86_fp80) readonly -define float @test4(float %X) { +define float @test4(float %X) nounwind { ; CHECK-LABEL: test4: ; CHECK: ## %bb.0: ; CHECK-NEXT: subl $12, %esp -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: flds {{[0-9]+}}(%esp) ; CHECK-NEXT: fstps (%esp) ; CHECK-NEXT: calll _cosf @@ -72,11 +68,10 @@ define float @test4(float %X) { ret float %Y } -define double @test5(double %X) { +define double @test5(double %X) nounwind { ; CHECK-LABEL: test5: ; CHECK: ## %bb.0: ; CHECK-NEXT: subl $12, %esp -; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: fldl {{[0-9]+}}(%esp) ; CHECK-NEXT: fstpl (%esp) ; CHECK-NEXT: calll _cos @@ -86,11 +81,10 @@ define double @test5(double %X) { ret double %Y } -define x86_fp80 @test6(x86_fp80 %X) { +define x86_fp80 @test6(x86_fp80 %X) nounwind { ; CHECK-LABEL: test6: ; CHECK: ## %bb.0: ; CHECK-NEXT: subl $28, %esp -; CHECK-NEXT: .cfi_def_cfa_offset 32 ; CHECK-NEXT: fldt {{[0-9]+}}(%esp) ; CHECK-NEXT: fstpt (%esp) ; CHECK-NEXT: calll _cosl