Skip to content

[Test] Mark a number of libcall tests nounwind #148329

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Merged
merged 1 commit into from
Jul 12, 2025
Merged

[Test] Mark a number of libcall tests nounwind #148329

merged 1 commit into from
Jul 12, 2025
+373 −1,195

Conversation

tgross35
Copy link
Contributor

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.

@tgross35
[Test] Mark a number of libcall tests nounwind
c122c77 
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.
@llvmbot
Copy link
Member

llvmbot commented Jul 12, 2025 •
edited
Loading

@llvm/pr-subscribers-backend-aarch64
@llvm/pr-subscribers-backend-x86

@llvm/pr-subscribers-backend-mips

Author: Trevor Gross (tgross35)

Changes

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.

Patch is 177.30 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/148329.diff

21 Files Affected:

  • (modified) llvm/test/CodeGen/AArch64/fsincos.ll (+129-323)
  • (modified) llvm/test/CodeGen/AArch64/llvm.frexp.ll (+94-394)
  • (modified) llvm/test/CodeGen/AArch64/llvm.sincos.ll (+24-82)
  • (modified) llvm/test/CodeGen/Mips/ldexp.ll (+6-26)
  • (modified) llvm/test/CodeGen/PowerPC/exp10-libcall.ll (+3-9)
  • (modified) llvm/test/CodeGen/PowerPC/ldexp-libcall.ll (+6-12)
  • (modified) llvm/test/CodeGen/PowerPC/ldexp.ll (+14-33)
  • (modified) llvm/test/CodeGen/PowerPC/llvm.frexp.ll (+27-60)
  • (modified) llvm/test/CodeGen/SystemZ/fp-half-libcall.ll (+13-63)
  • (modified) llvm/test/CodeGen/X86/exp10-libcall.ll (+3-9)
  • (modified) llvm/test/CodeGen/X86/ldexp-f80.ll (+2-6)
  • (modified) llvm/test/CodeGen/X86/ldexp-libcall.ll (+3-5)
  • (modified) llvm/test/CodeGen/X86/ldexp-not-readonly.ll (+2-6)
  • (modified) llvm/test/CodeGen/X86/ldexp-strict.ll (+4-10)
  • (modified) llvm/test/CodeGen/X86/ldexp-wrong-signature.ll (+2-6)
  • (modified) llvm/test/CodeGen/X86/ldexp-wrong-signature2.ll (+2-6)
  • (modified) llvm/test/CodeGen/X86/ldexp.ll (+7-73)
  • (modified) llvm/test/CodeGen/X86/llvm.frexp.f80.ll (+4-12)
  • (modified) llvm/test/CodeGen/X86/llvm.frexp.ll (+21-45)
  • (modified) llvm/test/CodeGen/X86/sincos-stack-args.ll (+1-3)
  • (modified) llvm/test/CodeGen/X86/sincos.ll (+6-12)
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, #...
[truncated]

@llvmbot
Copy link
Member

llvmbot commented Jul 12, 2025

@llvm/pr-subscribers-backend-systemz

Author: Trevor Gross (tgross35)

Changes

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.

Patch is 177.30 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/148329.diff

21 Files Affected:

  • (modified) llvm/test/CodeGen/AArch64/fsincos.ll (+129-323)
  • (modified) llvm/test/CodeGen/AArch64/llvm.frexp.ll (+94-394)
  • (modified) llvm/test/CodeGen/AArch64/llvm.sincos.ll (+24-82)
  • (modified) llvm/test/CodeGen/Mips/ldexp.ll (+6-26)
  • (modified) llvm/test/CodeGen/PowerPC/exp10-libcall.ll (+3-9)
  • (modified) llvm/test/CodeGen/PowerPC/ldexp-libcall.ll (+6-12)
  • (modified) llvm/test/CodeGen/PowerPC/ldexp.ll (+14-33)
  • (modified) llvm/test/CodeGen/PowerPC/llvm.frexp.ll (+27-60)
  • (modified) llvm/test/CodeGen/SystemZ/fp-half-libcall.ll (+13-63)
  • (modified) llvm/test/CodeGen/X86/exp10-libcall.ll (+3-9)
  • (modified) llvm/test/CodeGen/X86/ldexp-f80.ll (+2-6)
  • (modified) llvm/test/CodeGen/X86/ldexp-libcall.ll (+3-5)
  • (modified) llvm/test/CodeGen/X86/ldexp-not-readonly.ll (+2-6)
  • (modified) llvm/test/CodeGen/X86/ldexp-strict.ll (+4-10)
  • (modified) llvm/test/CodeGen/X86/ldexp-wrong-signature.ll (+2-6)
  • (modified) llvm/test/CodeGen/X86/ldexp-wrong-signature2.ll (+2-6)
  • (modified) llvm/test/CodeGen/X86/ldexp.ll (+7-73)
  • (modified) llvm/test/CodeGen/X86/llvm.frexp.f80.ll (+4-12)
  • (modified) llvm/test/CodeGen/X86/llvm.frexp.ll (+21-45)
  • (modified) llvm/test/CodeGen/X86/sincos-stack-args.ll (+1-3)
  • (modified) llvm/test/CodeGen/X86/sincos.ll (+6-12)
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, #...
[truncated]

@nikic nikic merged commit 0db197a into llvm:main Jul 12, 2025
15 checks passed
@tgross35 tgross35 deleted the test-nounwind branch July 12, 2025 10:02
@llvm-ci
Copy link
Collaborator

llvm-ci commented Jul 12, 2025

LLVM Buildbot has detected a new failure on builder llvm-clang-aarch64-darwin running on doug-worker-4 while building llvm at step 6 "test-build-unified-tree-check-all".

Full details are available at: https://lab.llvm.org/buildbot/#/builders/190/builds/23360

Here is the relevant piece of the build log for the reference 
Step 6 (test-build-unified-tree-check-all) failure: test (failure)
******************** TEST 'Clang-Unit :: ./AllClangUnitTests/15/48' FAILED ********************
Script(shard):
--
GTEST_OUTPUT=json:/Users/buildbot/buildbot-root/aarch64-darwin/build/tools/clang/unittests/./AllClangUnitTests-Clang-Unit-61031-15-48.json GTEST_SHUFFLE=0 GTEST_TOTAL_SHARDS=48 GTEST_SHARD_INDEX=15 /Users/buildbot/buildbot-root/aarch64-darwin/build/tools/clang/unittests/./AllClangUnitTests
--

Script:
--
/Users/buildbot/buildbot-root/aarch64-darwin/build/tools/clang/unittests/./AllClangUnitTests --gtest_filter=DirectoryWatcherTest.AddFiles
--
/Users/buildbot/buildbot-root/aarch64-darwin/llvm-project/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp:257: Failure
Value of: WaitForExpectedStateResult.wait_for(EventualResultTimeout) == std::future_status::ready
  Actual: false
Expected: true
The expected result state wasn't reached before the time-out.

/Users/buildbot/buildbot-root/aarch64-darwin/llvm-project/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp:260: Failure
Value of: TestConsumer.result().has_value()
  Actual: false
Expected: true


/Users/buildbot/buildbot-root/aarch64-darwin/llvm-project/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp:257
Value of: WaitForExpectedStateResult.wait_for(EventualResultTimeout) == std::future_status::ready
  Actual: false
Expected: true
The expected result state wasn't reached before the time-out.

/Users/buildbot/buildbot-root/aarch64-darwin/llvm-project/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp:260
Value of: TestConsumer.result().has_value()
  Actual: false
Expected: true



********************

@tgross35
Copy link
Contributor Author

That failure has to do with Clang unit tests, seems unrelated?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers

@nikic nikic nikic approved these changes

Assignees
No one assigned
Labels
backend:AArch64 backend:MIPS backend:PowerPC backend:SystemZ backend:X86
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
4 participants
@tgross35 @llvmbot @llvm-ci @nikic