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
3 ; RUN: llc < %s -enable-tail-merge=0 -mtriple=i686-windows | FileCheck %s --check-prefix=X86
5 ; Test that we actually spill and reload all arguments in the variadic argument
6 ; pack. Doing a normal call will clobber all argument registers, and we will
7 ; spill around it. A simple adjustment should not require any XMM spills.
9 declare void @llvm.va_start(i8*) nounwind
11 declare void(i8*, ...)* @get_f(i8* %this)
13 define void @f_thunk(i8* %this, ...) {
14 ; Use va_start so that we exercise the combination.
15 %ap = alloca [4 x i8*], align 16
16 %ap_i8 = bitcast [4 x i8*]* %ap to i8*
17 call void @llvm.va_start(i8* %ap_i8)
19 %fptr = call void(i8*, ...)*(i8*)* @get_f(i8* %this)
20 musttail call void (i8*, ...)* %fptr(i8* %this, ...)
24 ; Save and restore 6 GPRs, 8 XMMs, and AL around the call.
26 ; LINUX-LABEL: f_thunk:
27 ; LINUX-DAG: movq %rdi, {{.*}}
28 ; LINUX-DAG: movq %rsi, {{.*}}
29 ; LINUX-DAG: movq %rdx, {{.*}}
30 ; LINUX-DAG: movq %rcx, {{.*}}
31 ; LINUX-DAG: movq %r8, {{.*}}
32 ; LINUX-DAG: movq %r9, {{.*}}
33 ; LINUX-DAG: movb %al, {{.*}}
34 ; LINUX-DAG: movaps %xmm0, {{[0-9]*}}(%rsp)
35 ; LINUX-DAG: movaps %xmm1, {{[0-9]*}}(%rsp)
36 ; LINUX-DAG: movaps %xmm2, {{[0-9]*}}(%rsp)
37 ; LINUX-DAG: movaps %xmm3, {{[0-9]*}}(%rsp)
38 ; LINUX-DAG: movaps %xmm4, {{[0-9]*}}(%rsp)
39 ; LINUX-DAG: movaps %xmm5, {{[0-9]*}}(%rsp)
40 ; LINUX-DAG: movaps %xmm6, {{[0-9]*}}(%rsp)
41 ; LINUX-DAG: movaps %xmm7, {{[0-9]*}}(%rsp)
43 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm0
44 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm1
45 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm2
46 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm3
47 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm4
48 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm5
49 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm6
50 ; LINUX-DAG: movaps {{[0-9]*}}(%rsp), %xmm7
51 ; LINUX-DAG: movq {{.*}}, %rdi
52 ; LINUX-DAG: movq {{.*}}, %rsi
53 ; LINUX-DAG: movq {{.*}}, %rdx
54 ; LINUX-DAG: movq {{.*}}, %rcx
55 ; LINUX-DAG: movq {{.*}}, %r8
56 ; LINUX-DAG: movq {{.*}}, %r9
57 ; LINUX-DAG: movb {{.*}}, %al
58 ; LINUX: jmpq *{{.*}} # TAILCALL
60 ; WINDOWS-LABEL: f_thunk:
61 ; WINDOWS-NOT: mov{{.}}ps
62 ; WINDOWS-DAG: movq %rdx, {{.*}}
63 ; WINDOWS-DAG: movq %rcx, {{.*}}
64 ; WINDOWS-DAG: movq %r8, {{.*}}
65 ; WINDOWS-DAG: movq %r9, {{.*}}
66 ; WINDOWS-NOT: mov{{.}}ps
67 ; WINDOWS: callq get_f
68 ; WINDOWS-NOT: mov{{.}}ps
69 ; WINDOWS-DAG: movq {{.*}}, %rdx
70 ; WINDOWS-DAG: movq {{.*}}, %rcx
71 ; WINDOWS-DAG: movq {{.*}}, %r8
72 ; WINDOWS-DAG: movq {{.*}}, %r9
73 ; WINDOWS-NOT: mov{{.}}ps
74 ; WINDOWS: jmpq *{{.*}} # TAILCALL
76 ; No regparms on normal x86 conventions.
78 ; X86-LABEL: _f_thunk:
80 ; X86: jmpl *{{.*}} # TAILCALL
82 ; This thunk shouldn't require any spills and reloads, assuming the register
83 ; allocator knows what it's doing.
85 define void @g_thunk(i8* %fptr_i8, ...) {
86 %fptr = bitcast i8* %fptr_i8 to void (i8*, ...)*
87 musttail call void (i8*, ...)* %fptr(i8* %fptr_i8, ...)
91 ; LINUX-LABEL: g_thunk:
93 ; LINUX: jmpq *%rdi # TAILCALL
95 ; WINDOWS-LABEL: g_thunk:
97 ; WINDOWS: jmpq *%rcx # TAILCALL
99 ; X86-LABEL: _g_thunk:
100 ; X86: jmpl *%eax # TAILCALL
102 ; Do a simple multi-exit multi-bb test.
104 %struct.Foo = type { i1, i8*, i8* }
106 @g = external global i32
108 define void @h_thunk(%struct.Foo* %this, ...) {
109 %cond_p = getelementptr %struct.Foo, %struct.Foo* %this, i32 0, i32 0
110 %cond = load i1, i1* %cond_p
111 br i1 %cond, label %then, label %else
114 %a_p = getelementptr %struct.Foo, %struct.Foo* %this, i32 0, i32 1
115 %a_i8 = load i8*, i8** %a_p
116 %a = bitcast i8* %a_i8 to void (%struct.Foo*, ...)*
117 musttail call void (%struct.Foo*, ...)* %a(%struct.Foo* %this, ...)
121 %b_p = getelementptr %struct.Foo, %struct.Foo* %this, i32 0, i32 2
122 %b_i8 = load i8*, i8** %b_p
123 %b = bitcast i8* %b_i8 to void (%struct.Foo*, ...)*
124 store i32 42, i32* @g
125 musttail call void (%struct.Foo*, ...)* %b(%struct.Foo* %this, ...)
129 ; LINUX-LABEL: h_thunk:
131 ; LINUX: jmpq *{{.*}} # TAILCALL
132 ; LINUX: jmpq *{{.*}} # TAILCALL
133 ; WINDOWS-LABEL: h_thunk:
135 ; WINDOWS: jmpq *{{.*}} # TAILCALL
136 ; WINDOWS: jmpq *{{.*}} # TAILCALL
137 ; X86-LABEL: _h_thunk:
139 ; X86: jmpl *{{.*}} # TAILCALL
140 ; X86: jmpl *{{.*}} # TAILCALL