1 ; RUN: llc < %s -enable-tail-merge=0 -mtriple=x86_64-linux | FileCheck %s --check-prefix=LINUX
2 ; RUN: llc < %s -enable-tail-merge=0 -mtriple=x86_64-windows | FileCheck %s --check-prefix=WINDOWS
4 ; Test that we actually spill and reload all arguments in the variadic argument
5 ; pack. Doing a normal call will clobber all argument registers, and we will
6 ; spill around it. A simple adjustment should not require any XMM spills.
8 declare void(i8*, ...)* @get_f(i8* %this)
10 define void @f_thunk(i8* %this, ...) {
11 %fptr = call void(i8*, ...)*(i8*)* @get_f(i8* %this)
12 musttail call void (i8*, ...)* %fptr(i8* %this, ...)
16 ; Save and restore 6 GPRs, 8 XMMs, and AL around the call.
18 ; LINUX-LABEL: f_thunk:
19 ; LINUX-DAG: movq %rdi, {{.*}}
20 ; LINUX-DAG: movq %rsi, {{.*}}
21 ; LINUX-DAG: movq %rdx, {{.*}}
22 ; LINUX-DAG: movq %rcx, {{.*}}
23 ; LINUX-DAG: movq %r8, {{.*}}
24 ; LINUX-DAG: movq %r9, {{.*}}
25 ; LINUX-DAG: movb %al, {{.*}}
26 ; LINUX-DAG: movaps %xmm0, {{[0-9]*}}(%rsp)
27 ; LINUX-DAG: movaps %xmm1, {{[0-9]*}}(%rsp)
28 ; LINUX-DAG: movaps %xmm2, {{[0-9]*}}(%rsp)
29 ; LINUX-DAG: movaps %xmm3, {{[0-9]*}}(%rsp)
30 ; LINUX-DAG: movaps %xmm4, {{[0-9]*}}(%rsp)
31 ; LINUX-DAG: movaps %xmm5, {{[0-9]*}}(%rsp)
32 ; LINUX-DAG: movaps %xmm6, {{[0-9]*}}(%rsp)
33 ; LINUX-DAG: movaps %xmm7, {{[0-9]*}}(%rsp)
35 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm0
36 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm1
37 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm2
38 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm3
39 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm4
40 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm5
41 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm6
42 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm7
43 ; LINUX-DAG: movq {{.*}}, %rdi
44 ; LINUX-DAG: movq {{.*}}, %rsi
45 ; LINUX-DAG: movq {{.*}}, %rdx
46 ; LINUX-DAG: movq {{.*}}, %rcx
47 ; LINUX-DAG: movq {{.*}}, %r8
48 ; LINUX-DAG: movq {{.*}}, %r9
49 ; LINUX-DAG: movb {{.*}}, %al
50 ; LINUX: jmpq *{{.*}} # TAILCALL
52 ; WINDOWS-LABEL: f_thunk:
53 ; WINDOWS-NOT: mov{{.}}ps
54 ; WINDOWS-DAG: movq %rdx, {{.*}}
55 ; WINDOWS-DAG: movq %rcx, {{.*}}
56 ; WINDOWS-DAG: movq %r8, {{.*}}
57 ; WINDOWS-DAG: movq %r9, {{.*}}
58 ; WINDOWS-NOT: mov{{.}}ps
59 ; WINDOWS: callq get_f
60 ; WINDOWS-NOT: mov{{.}}ps
61 ; WINDOWS-DAG: movq {{.*}}, %rdx
62 ; WINDOWS-DAG: movq {{.*}}, %rcx
63 ; WINDOWS-DAG: movq {{.*}}, %r8
64 ; WINDOWS-DAG: movq {{.*}}, %r9
65 ; WINDOWS-NOT: mov{{.}}ps
66 ; WINDOWS: jmpq *{{.*}} # TAILCALL
68 ; This thunk shouldn't require any spills and reloads, assuming the register
69 ; allocator knows what it's doing.
71 define void @g_thunk(i8* %fptr_i8, ...) {
72 %fptr = bitcast i8* %fptr_i8 to void (i8*, ...)*
73 musttail call void (i8*, ...)* %fptr(i8* %fptr_i8, ...)
77 ; LINUX-LABEL: g_thunk:
79 ; LINUX: jmpq *%rdi # TAILCALL
81 ; WINDOWS-LABEL: g_thunk:
83 ; WINDOWS: jmpq *%rcx # TAILCALL
85 ; Do a simple multi-exit multi-bb test.
87 %struct.Foo = type { i1, i8*, i8* }
89 @g = external global i32
91 define void @h_thunk(%struct.Foo* %this, ...) {
92 %cond_p = getelementptr %struct.Foo* %this, i32 0, i32 0
93 %cond = load i1* %cond_p
94 br i1 %cond, label %then, label %else
97 %a_p = getelementptr %struct.Foo* %this, i32 0, i32 1
98 %a_i8 = load i8** %a_p
99 %a = bitcast i8* %a_i8 to void (%struct.Foo*, ...)*
100 musttail call void (%struct.Foo*, ...)* %a(%struct.Foo* %this, ...)
104 %b_p = getelementptr %struct.Foo* %this, i32 0, i32 2
105 %b_i8 = load i8** %b_p
106 %b = bitcast i8* %b_i8 to void (%struct.Foo*, ...)*
107 store i32 42, i32* @g
108 musttail call void (%struct.Foo*, ...)* %b(%struct.Foo* %this, ...)
112 ; LINUX-LABEL: h_thunk:
114 ; LINUX: jmpq *{{.*}} # TAILCALL
115 ; LINUX: jmpq *{{.*}} # TAILCALL
116 ; WINDOWS-LABEL: h_thunk:
118 ; WINDOWS: jmpq *{{.*}} # TAILCALL
119 ; WINDOWS: jmpq *{{.*}} # TAILCALL