[llvm] [Test] Mark a number of libcall tests `nounwind` (PR #148329)
Trevor Gross via llvm-commits
llvm-commits at lists.llvm.org
Fri Jul 11 19:43:22 PDT 2025
https://github.com/tgross35 created https://github.com/llvm/llvm-project/pull/148329
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.
>From c122c77f4466f865f39fe65eb592175be7891678 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross at umich.edu>
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 at 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 at 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 at PLT
; CHECK-NEXT: brasl %r14, sinf at PLT
; CHECK-NEXT: brasl %r14, __truncsfhf2 at 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 at PLT
; CHECK-NEXT: brasl %r14, cosf at PLT
; CHECK-NEXT: brasl %r14, __truncsfhf2 at 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 at PLT
; CHECK-NEXT: brasl %r14, expf at PLT
; CHECK-NEXT: brasl %r14, __truncsfhf2 at 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 at PLT
; CHECK-NEXT: brasl %r14, exp2f at PLT
; CHECK-NEXT: brasl %r14, __truncsfhf2 at 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 at PLT
; CHECK-NEXT: brasl %r14, logf at PLT
; CHECK-NEXT: brasl %r14, __truncsfhf2 at 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 at PLT
; CHECK-NEXT: brasl %r14, log2f at PLT
; CHECK-NEXT: brasl %r14, __truncsfhf2 at 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 at PLT
; CHECK-NEXT: brasl %r14, log10f at PLT
; CHECK-NEXT: brasl %r14, __truncsfhf2 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at PLT
; X64-NEXT: movl %ebx, %edi
; X64-NEXT: callq ldexpf at PLT
; X64-NEXT: callq __truncsfhf2 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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
More information about the llvm-commits
mailing list