summaryrefslogtreecommitdiffstats
path: root/arch/x86/include/asm/calling.h
blob: 0e63c9a2a8d0d722d2eba8afafc175f48096698d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
/*

 x86 function call convention, 64-bit:
 -------------------------------------
  arguments           |  callee-saved      | extra caller-saved | return
 [callee-clobbered]   |                    | [callee-clobbered] |
 ---------------------------------------------------------------------------
 rdi rsi rdx rcx r8-9 | rbx rbp [*] r12-15 | r10-11             | rax, rdx [**]

 ( rsp is obviously invariant across normal function calls. (gcc can 'merge'
   functions when it sees tail-call optimization possibilities) rflags is
   clobbered. Leftover arguments are passed over the stack frame.)

 [*]  In the frame-pointers case rbp is fixed to the stack frame.

 [**] for struct return values wider than 64 bits the return convention is a
      bit more complex: up to 128 bits width we return small structures
      straight in rax, rdx. For structures larger than that (3 words or
      larger) the caller puts a pointer to an on-stack return struct
      [allocated in the caller's stack frame] into the first argument - i.e.
      into rdi. All other arguments shift up by one in this case.
      Fortunately this case is rare in the kernel.

For 32-bit we have the following conventions - kernel is built with
-mregparm=3 and -freg-struct-return:

 x86 function calling convention, 32-bit:
 ----------------------------------------
  arguments         | callee-saved        | extra caller-saved | return
 [callee-clobbered] |                     | [callee-clobbered] |
 -------------------------------------------------------------------------
 eax edx ecx        | ebx edi esi ebp [*] | <none>             | eax, edx [**]

 ( here too esp is obviously invariant across normal function calls. eflags
   is clobbered. Leftover arguments are passed over the stack frame. )

 [*]  In the frame-pointers case ebp is fixed to the stack frame.

 [**] We build with -freg-struct-return, which on 32-bit means similar
      semantics as on 64-bit: edx can be used for a second return value
      (i.e. covering integer and structure sizes up to 64 bits) - after that
      it gets more complex and more expensive: 3-word or larger struct returns
      get done in the caller's frame and the pointer to the return struct goes
      into regparm0, i.e. eax - the other arguments shift up and the
      function's register parameters degenerate to regparm=2 in essence.

*/


/*
 * 64-bit system call stack frame layout defines and helpers,
 * for assembly code:
 */

#define R15		  0
#define R14		  8
#define R13		 16
#define R12		 24
#define RBP		 32
#define RBX		 40

/* arguments: interrupts/non tracing syscalls only save up to here: */
#define R11		 48
#define R10		 56
#define R9		 64
#define R8		 72
#define RAX		 80
#define RCX		 88
#define RDX		 96
#define RSI		104
#define RDI		112
#define ORIG_RAX	120       /* + error_code */
/* end of arguments */

/* cpu exception frame or undefined in case of fast syscall: */
#define RIP		128
#define CS		136
#define EFLAGS		144
#define RSP		152
#define SS		160

#define ARGOFFSET	R11
#define SWFRAME		ORIG_RAX

	.macro SAVE_ARGS addskip=0, norcx=0, nor891011=0
	subq  $9*8+\addskip, %rsp
	CFI_ADJUST_CFA_OFFSET	9*8+\addskip
	movq  %rdi, 8*8(%rsp)
	CFI_REL_OFFSET	rdi, 8*8
	movq  %rsi, 7*8(%rsp)
	CFI_REL_OFFSET	rsi, 7*8
	movq  %rdx, 6*8(%rsp)
	CFI_REL_OFFSET	rdx, 6*8
	.if \norcx
	.else
	movq  %rcx, 5*8(%rsp)
	CFI_REL_OFFSET	rcx, 5*8
	.endif
	movq  %rax, 4*8(%rsp)
	CFI_REL_OFFSET	rax, 4*8
	.if \nor891011
	.else
	movq  %r8, 3*8(%rsp)
	CFI_REL_OFFSET	r8,  3*8
	movq  %r9, 2*8(%rsp)
	CFI_REL_OFFSET	r9,  2*8
	movq  %r10, 1*8(%rsp)
	CFI_REL_OFFSET	r10, 1*8
	movq  %r11, (%rsp)
	CFI_REL_OFFSET	r11, 0*8
	.endif
	.endm

#define ARG_SKIP	9*8

	.macro RESTORE_ARGS skiprax=0, addskip=0, skiprcx=0, skipr11=0, \
			    skipr8910=0, skiprdx=0
	.if \skipr11
	.else
	movq (%rsp), %r11
	CFI_RESTORE r11
	.endif
	.if \skipr8910
	.else
	movq 1*8(%rsp), %r10
	CFI_RESTORE r10
	movq 2*8(%rsp), %r9
	CFI_RESTORE r9
	movq 3*8(%rsp), %r8
	CFI_RESTORE r8
	.endif
	.if \skiprax
	.else
	movq 4*8(%rsp), %rax
	CFI_RESTORE rax
	.endif
	.if \skiprcx
	.else
	movq 5*8(%rsp), %rcx
	CFI_RESTORE rcx
	.endif
	.if \skiprdx
	.else
	movq 6*8(%rsp), %rdx
	CFI_RESTORE rdx
	.endif
	movq 7*8(%rsp), %rsi
	CFI_RESTORE rsi
	movq 8*8(%rsp), %rdi
	CFI_RESTORE rdi
	.if ARG_SKIP+\addskip > 0
	addq $ARG_SKIP+\addskip, %rsp
	CFI_ADJUST_CFA_OFFSET	-(ARG_SKIP+\addskip)
	.endif
	.endm

	.macro LOAD_ARGS offset, skiprax=0
	movq \offset(%rsp),    %r11
	movq \offset+8(%rsp),  %r10
	movq \offset+16(%rsp), %r9
	movq \offset+24(%rsp), %r8
	movq \offset+40(%rsp), %rcx
	movq \offset+48(%rsp), %rdx
	movq \offset+56(%rsp), %rsi
	movq \offset+64(%rsp), %rdi
	.if \skiprax
	.else
	movq \offset+72(%rsp), %rax
	.endif
	.endm

#define REST_SKIP	6*8

	.macro SAVE_REST
	subq $REST_SKIP, %rsp
	CFI_ADJUST_CFA_OFFSET	REST_SKIP
	movq %rbx, 5*8(%rsp)
	CFI_REL_OFFSET	rbx, 5*8
	movq %rbp, 4*8(%rsp)
	CFI_REL_OFFSET	rbp, 4*8
	movq %r12, 3*8(%rsp)
	CFI_REL_OFFSET	r12, 3*8
	movq %r13, 2*8(%rsp)
	CFI_REL_OFFSET	r13, 2*8
	movq %r14, 1*8(%rsp)
	CFI_REL_OFFSET	r14, 1*8
	movq %r15, (%rsp)
	CFI_REL_OFFSET	r15, 0*8
	.endm

	.macro RESTORE_REST
	movq (%rsp),     %r15
	CFI_RESTORE r15
	movq 1*8(%rsp),  %r14
	CFI_RESTORE r14
	movq 2*8(%rsp),  %r13
	CFI_RESTORE r13
	movq 3*8(%rsp),  %r12
	CFI_RESTORE r12
	movq 4*8(%rsp),  %rbp
	CFI_RESTORE rbp
	movq 5*8(%rsp),  %rbx
	CFI_RESTORE rbx
	addq $REST_SKIP, %rsp
	CFI_ADJUST_CFA_OFFSET	-(REST_SKIP)
	.endm

	.macro SAVE_ALL
	SAVE_ARGS
	SAVE_REST
	.endm

	.macro RESTORE_ALL addskip=0
	RESTORE_REST
	RESTORE_ARGS 0, \addskip
	.endm

	.macro icebp
	.byte 0xf1
	.endm