copy arm byval musttail tests

folkertdev · folkertdev · commit 114e1365fa53 · 2025-11-23T15:30:36.000+01:00
diff --git a/llvm/lib/Target/X86/X86ISelLoweringCall.cpp b/llvm/lib/Target/X86/X86ISelLoweringCall.cpp
@@ -2544,6 +2544,10 @@ X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
           NeedsStackCopy = !isTailCall;
         }
 
+        // FIXME: contrary to the arm backend, with the current logic we always
+        // seem to need a stack copy.
+        (void)NeedsStackCopy;
+
         auto PtrVT = getPointerTy(DAG.getDataLayout());
         SDValue DstAddr = DAG.getFrameIndex(FI, PtrVT);
 
diff --git a/llvm/test/CodeGen/X86/musttail-struct.ll b/llvm/test/CodeGen/X86/musttail-struct.ll
@@ -72,17 +72,17 @@ entry:
 }
 
 define dso_local i32 @swapByValArguments(ptr byval(%struct.1xi32) %0, ptr byval(%struct.1xi32) %1) {
-; CHECK-LABEL: swapArguments:
+; CHECK-LABEL: swapByValArguments:
 ; CHECK:       # %bb.0:
-
 ; CHECK-NEXT:    mov eax, dword ptr [rsp + 8]
 ; CHECK-NEXT:    mov dword ptr [rsp - 16], eax
 ; CHECK-NEXT:    mov ecx, dword ptr [rsp + 16]
 ; CHECK-NEXT:    mov dword ptr [rsp - 8], ecx
-
 ; CHECK-NEXT:    mov dword ptr [rsp + 8], ecx
 ; CHECK-NEXT:    mov dword ptr [rsp + 16], eax
 ; CHECK-NEXT:    jmp swap # TAILCALL
+
+
   %r = musttail call i32 @swap(ptr byval(%struct.1xi32) %1, ptr byval(%struct.1xi32) %0)
   ret i32 %r
 }
@@ -95,37 +95,12 @@ declare void @large_callee(%twenty_bytes* byval(%twenty_bytes) align 4)
 
 ; Functions with byval parameters can be tail-called, because the value is
 ; actually passed in registers and the stack in the same way for the caller and
-; callee. Within @large_caller the first 16 bytes of the argument are spilled
-; to the local stack frame, but for the tail-call they are passed in r0-r3, so
-; it's safe to de-allocate that memory before the call.
-; TODO: The SUB and STM instructions are unnecessary and could be optimised
-; out, but the behaviour of this is still correct.
+; callee. On x86 byval arguments are never (partially) passed via registers.
 define void @large_caller(%twenty_bytes* byval(%twenty_bytes) align 4 %a) {
 ; CHECK-LABEL: large_caller:
-; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    .pad #16
-; CHECK-NEXT:    sub sp, sp, #16
-; CHECK-NEXT:    stm sp!, {r0, r1, r2, r3}
-; CHECK-NEXT:    b large_callee
-entry:
-  musttail call void @large_callee(%twenty_bytes* byval(%twenty_bytes) align 4 %a)
-  ret void
-}
-
-; As above, but with some inline asm to test that the arguments in r0-r3 are
-; re-loaded before the call.
-define void @large_caller_check_regs(%twenty_bytes* byval(%twenty_bytes) align 4 %a) {
-; CHECK-LABEL: large_caller_check_regs:
-; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    .pad #16
-; CHECK-NEXT:    sub sp, sp, #16
-; CHECK-NEXT:    stm sp, {r0, r1, r2, r3}
-; CHECK-NEXT:    @APP
-; CHECK-NEXT:    @NO_APP
-; CHECK-NEXT:    pop {r0, r1, r2, r3}
-; CHECK-NEXT:    b large_callee
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    jmp large_callee@PLT # TAILCALL
 entry:
-  tail call void asm sideeffect "", "~{r0},~{r1},~{r2},~{r3}"()
   musttail call void @large_callee(%twenty_bytes* byval(%twenty_bytes) align 4 %a)
   ret void
 }
@@ -136,32 +111,19 @@ entry:
 ; valid.
 define void @large_caller_new_value(%twenty_bytes* byval(%twenty_bytes) align 4 %a) {
 ; CHECK-LABEL: large_caller_new_value:
-; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    .pad #36
-; CHECK-NEXT:    sub sp, sp, #36
-; CHECK-NEXT:    add r12, sp, #20
-; CHECK-NEXT:    stm r12, {r0, r1, r2, r3}
-; CHECK-NEXT:    mov r0, #4
-; CHECK-NEXT:    add r1, sp, #36
-; CHECK-NEXT:    str r0, [sp, #16]
-; CHECK-NEXT:    mov r0, #3
-; CHECK-NEXT:    str r0, [sp, #12]
-; CHECK-NEXT:    mov r0, #2
-; CHECK-NEXT:    str r0, [sp, #8]
-; CHECK-NEXT:    mov r0, #1
-; CHECK-NEXT:    str r0, [sp, #4]
-; CHECK-NEXT:    mov r0, #0
-; CHECK-NEXT:    str r0, [sp]
-; CHECK-NEXT:    mov r0, sp
-; CHECK-NEXT:    add r0, r0, #16
-; CHECK-NEXT:    mov r3, #3
-; CHECK-NEXT:    ldr r2, [r0], #4
-; CHECK-NEXT:    str r2, [r1], #4
-; CHECK-NEXT:    mov r0, #0
-; CHECK-NEXT:    mov r1, #1
-; CHECK-NEXT:    mov r2, #2
-; CHECK-NEXT:    add sp, sp, #36
-; CHECK-NEXT:    b large_callee
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    movabs rax, 4294967296
+; CHECK-NEXT:    mov qword ptr [rsp - 20], rax
+; CHECK-NEXT:    movabs rcx, 12884901890
+; CHECK-NEXT:    mov qword ptr [rsp - 12], rcx
+; CHECK-NEXT:    mov dword ptr [rsp - 4], 4
+; CHECK-NEXT:    mov qword ptr [rsp - 40], rax
+; CHECK-NEXT:    mov qword ptr [rsp - 32], rcx
+; CHECK-NEXT:    mov qword ptr [rsp + 8], rax
+; CHECK-NEXT:    mov qword ptr [rsp + 16], rcx
+; CHECK-NEXT:    mov dword ptr [rsp - 24], 4
+; CHECK-NEXT:    mov dword ptr [rsp + 24], 4
+; CHECK-NEXT:    jmp large_callee@PLT # TAILCALL
 entry:
   %y = alloca %twenty_bytes, align 4
   store i32 0, ptr %y, align 4
@@ -180,103 +142,40 @@ entry:
 declare void @two_byvals_callee(%twenty_bytes* byval(%twenty_bytes) align 4, %twenty_bytes* byval(%twenty_bytes) align 4)
 define void @swap_byvals(%twenty_bytes* byval(%twenty_bytes) align 4 %a, %twenty_bytes* byval(%twenty_bytes) align 4 %b) {
 ; CHECK-LABEL: swap_byvals:
-; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    .pad #16
-; CHECK-NEXT:    sub sp, sp, #16
-; CHECK-NEXT:    .save {r4, r5, r11, lr}
-; CHECK-NEXT:    push {r4, r5, r11, lr}
-; CHECK-NEXT:    .pad #40
-; CHECK-NEXT:    sub sp, sp, #40
-; CHECK-NEXT:    add r12, sp, #56
-; CHECK-NEXT:    add lr, sp, #20
-; CHECK-NEXT:    stm r12, {r0, r1, r2, r3}
-; CHECK-NEXT:    add r0, sp, #56
-; CHECK-NEXT:    mov r12, sp
-; CHECK-NEXT:    ldr r1, [r0], #4
-; CHECK-NEXT:    mov r2, r12
-; CHECK-NEXT:    str r1, [r2], #4
-; CHECK-NEXT:    add r3, sp, #20
-; CHECK-NEXT:    ldr r1, [r0], #4
-; CHECK-NEXT:    add r4, sp, #76
-; CHECK-NEXT:    str r1, [r2], #4
-; CHECK-NEXT:    ldr r1, [r0], #4
-; CHECK-NEXT:    str r1, [r2], #4
-; CHECK-NEXT:    ldr r1, [r0], #4
-; CHECK-NEXT:    str r1, [r2], #4
-; CHECK-NEXT:    ldr r1, [r0], #4
-; CHECK-NEXT:    add r0, sp, #76
-; CHECK-NEXT:    str r1, [r2], #4
-; CHECK-NEXT:    mov r2, lr
-; CHECK-NEXT:    ldr r1, [r0], #4
-; CHECK-NEXT:    str r1, [r2], #4
-; CHECK-NEXT:    ldr r1, [r0], #4
-; CHECK-NEXT:    str r1, [r2], #4
-; CHECK-NEXT:    ldr r1, [r0], #4
-; CHECK-NEXT:    str r1, [r2], #4
-; CHECK-NEXT:    ldr r1, [r0], #4
-; CHECK-NEXT:    str r1, [r2], #4
-; CHECK-NEXT:    ldr r1, [r0], #4
-; CHECK-NEXT:    str r1, [r2], #4
-; CHECK-NEXT:    ldm r3, {r0, r1, r2, r3}
-; CHECK-NEXT:    ldr r5, [r12], #4
-; CHECK-NEXT:    str r5, [r4], #4
-; CHECK-NEXT:    ldr r5, [r12], #4
-; CHECK-NEXT:    str r5, [r4], #4
-; CHECK-NEXT:    ldr r5, [r12], #4
-; CHECK-NEXT:    str r5, [r4], #4
-; CHECK-NEXT:    ldr r5, [r12], #4
-; CHECK-NEXT:    str r5, [r4], #4
-; CHECK-NEXT:    ldr r5, [r12], #4
-; CHECK-NEXT:    str r5, [r4], #4
-; CHECK-NEXT:    add r5, lr, #16
-; CHECK-NEXT:    add r12, sp, #72
-; CHECK-NEXT:    ldr r4, [r5], #4
-; CHECK-NEXT:    str r4, [r12], #4
-; CHECK-NEXT:    add sp, sp, #40
-; CHECK-NEXT:    pop {r4, r5, r11, lr}
-; CHECK-NEXT:    add sp, sp, #16
-; CHECK-NEXT:    b two_byvals_callee
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    mov eax, dword ptr [rsp + 24]
+; CHECK-NEXT:    mov dword ptr [rsp - 8], eax
+; CHECK-NEXT:    movaps xmm0, xmmword ptr [rsp + 8]
+; CHECK-NEXT:    movaps xmmword ptr [rsp - 24], xmm0
+; CHECK-NEXT:    mov ecx, dword ptr [rsp + 48]
+; CHECK-NEXT:    mov dword ptr [rsp - 32], ecx
+; CHECK-NEXT:    mov rdx, qword ptr [rsp + 32]
+; CHECK-NEXT:    mov rsi, qword ptr [rsp + 40]
+; CHECK-NEXT:    mov qword ptr [rsp - 40], rsi
+; CHECK-NEXT:    mov qword ptr [rsp - 48], rdx
+; CHECK-NEXT:    mov qword ptr [rsp + 8], rdx
+; CHECK-NEXT:    mov qword ptr [rsp + 16], rsi
+; CHECK-NEXT:    mov dword ptr [rsp + 24], ecx
+; CHECK-NEXT:    mov rcx, qword ptr [rsp + 8]
+; CHECK-NEXT:    mov rdx, qword ptr [rsp + 16]
+; CHECK-NEXT:    mov qword ptr [rsp + 32], rcx
+; CHECK-NEXT:    mov qword ptr [rsp + 40], rdx
+; CHECK-NEXT:    mov dword ptr [rsp + 48], eax
+; CHECK-NEXT:    jmp two_byvals_callee@PLT # TAILCALL
 entry:
   musttail call void @two_byvals_callee(%twenty_bytes* byval(%twenty_bytes) align 4 %b, %twenty_bytes* byval(%twenty_bytes) align 4 %a)
   ret void
 }
 
-; A forwarded byval arg, but at a different offset on the stack, so it needs to
-; be copied to the local stack frame first. This can't be musttail because of
-; the different signatures, but is still tail-called as an optimisation.
+; A forwarded byval arg, but at a different argument position. Because
+; x86 does not (partially) pass byval arguments in registers, the byval
+; arg is in the correct position already, so this is not a sibcall but
+; can be tail-call optimized.
 declare void @shift_byval_callee(%twenty_bytes* byval(%twenty_bytes) align 4)
 define void @shift_byval(i32 %a, %twenty_bytes* byval(%twenty_bytes) align 4 %b) {
 ; CHECK-LABEL: shift_byval:
-; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    .pad #12
-; CHECK-NEXT:    sub sp, sp, #12
-; CHECK-NEXT:    .save {r4, lr}
-; CHECK-NEXT:    push {r4, lr}
-; CHECK-NEXT:    .pad #20
-; CHECK-NEXT:    sub sp, sp, #20
-; CHECK-NEXT:    add r0, sp, #28
-; CHECK-NEXT:    add lr, sp, #40
-; CHECK-NEXT:    stm r0, {r1, r2, r3}
-; CHECK-NEXT:    add r0, sp, #28
-; CHECK-NEXT:    mov r1, sp
-; CHECK-NEXT:    ldr r2, [r0], #4
-; CHECK-NEXT:    add r12, r1, #16
-; CHECK-NEXT:    str r2, [r1], #4
-; CHECK-NEXT:    ldr r2, [r0], #4
-; CHECK-NEXT:    str r2, [r1], #4
-; CHECK-NEXT:    ldr r2, [r0], #4
-; CHECK-NEXT:    str r2, [r1], #4
-; CHECK-NEXT:    ldr r2, [r0], #4
-; CHECK-NEXT:    str r2, [r1], #4
-; CHECK-NEXT:    ldr r2, [r0], #4
-; CHECK-NEXT:    str r2, [r1], #4
-; CHECK-NEXT:    ldm sp, {r0, r1, r2, r3}
-; CHECK-NEXT:    ldr r4, [r12], #4
-; CHECK-NEXT:    str r4, [lr], #4
-; CHECK-NEXT:    add sp, sp, #20
-; CHECK-NEXT:    pop {r4, lr}
-; CHECK-NEXT:    add sp, sp, #12
-; CHECK-NEXT:    b shift_byval_callee
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    jmp shift_byval_callee@PLT # TAILCALL
 entry:
   tail call void @shift_byval_callee(%twenty_bytes* byval(%twenty_bytes) align 4 %b)
   ret void
@@ -287,23 +186,15 @@ entry:
 @large_global = external global %twenty_bytes
 define void @large_caller_from_global(%twenty_bytes* byval(%twenty_bytes) align 4 %a) {
 ; CHECK-LABEL: large_caller_from_global:
-; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    .pad #16
-; CHECK-NEXT:    sub sp, sp, #16
-; CHECK-NEXT:    .save {r4, lr}
-; CHECK-NEXT:    push {r4, lr}
-; CHECK-NEXT:    add r12, sp, #8
-; CHECK-NEXT:    add lr, sp, #24
-; CHECK-NEXT:    stm r12, {r0, r1, r2, r3}
-; CHECK-NEXT:    movw r3, :lower16:large_global
-; CHECK-NEXT:    movt r3, :upper16:large_global
-; CHECK-NEXT:    add r12, r3, #16
-; CHECK-NEXT:    ldm r3, {r0, r1, r2, r3}
-; CHECK-NEXT:    ldr r4, [r12], #4
-; CHECK-NEXT:    str r4, [lr], #4
-; CHECK-NEXT:    pop {r4, lr}
-; CHECK-NEXT:    add sp, sp, #16
-; CHECK-NEXT:    b large_callee
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    mov rax, qword ptr [rip + large_global@GOTPCREL]
+; CHECK-NEXT:    mov ecx, dword ptr [rax + 16]
+; CHECK-NEXT:    mov dword ptr [rsp + 24], ecx
+; CHECK-NEXT:    mov rcx, qword ptr [rax]
+; CHECK-NEXT:    mov rax, qword ptr [rax + 8]
+; CHECK-NEXT:    mov qword ptr [rsp + 16], rax
+; CHECK-NEXT:    mov qword ptr [rsp + 8], rcx
+; CHECK-NEXT:    jmp large_callee@PLT # TAILCALL
 entry:
   musttail call void @large_callee(%twenty_bytes* byval(%twenty_bytes) align 4 @large_global)
   ret void

Original file line number	Diff line number	Diff line change
`@@ -2544,6 +2544,10 @@ X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,`
`2544`	`2544`	`NeedsStackCopy = !isTailCall;`
`2545`	`2545`	`}`
`2546`	`2546`
	`2547`	`+ // FIXME: contrary to the arm backend, with the current logic we always`
	`2548`	`+ // seem to need a stack copy.`
	`2549`	`+ (void)NeedsStackCopy;`
	`2550`	`+`
`2547`	`2551`	`auto PtrVT = getPointerTy(DAG.getDataLayout());`
`2548`	`2552`	`SDValue DstAddr = DAG.getFrameIndex(FI, PtrVT);`
`2549`	`2553`