]>
Commit | Line | Data |
---|---|---|
ffa8d2a0 | 1 | /* Copyright (C) 2001,02 Free Software Foundation, Inc. |
c9cf6dde AJ |
2 | This file is part of the GNU C Library. |
3 | ||
4 | The GNU C Library is free software; you can redistribute it and/or | |
5 | modify it under the terms of the GNU Lesser General Public | |
6 | License as published by the Free Software Foundation; either | |
7 | version 2.1 of the License, or (at your option) any later version. | |
8 | ||
9 | The GNU C Library is distributed in the hope that it will be useful, | |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
12 | Lesser General Public License for more details. | |
13 | ||
14 | You should have received a copy of the GNU Lesser General Public | |
15 | License along with the GNU C Library; if not, write to the Free | |
16 | Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |
17 | 02111-1307 USA. */ | |
18 | ||
19 | #ifndef _LINUX_X86_64_SYSDEP_H | |
20 | #define _LINUX_X86_64_SYSDEP_H 1 | |
21 | ||
22 | /* There is some commonality. */ | |
23 | #include <sysdeps/unix/x86_64/sysdep.h> | |
24 | #include <bp-sym.h> | |
25 | #include <bp-asm.h> | |
89b91a92 | 26 | #include <tls.h> |
c9cf6dde | 27 | |
ce460d04 RM |
28 | #ifdef IS_IN_rtld |
29 | # include <dl-sysdep.h> /* Defines RTLD_PRIVATE_ERRNO. */ | |
30 | #endif | |
31 | ||
c9cf6dde AJ |
32 | /* For Linux we can use the system call table in the header file |
33 | /usr/include/asm/unistd.h | |
34 | of the kernel. But these symbols do not follow the SYS_* syntax | |
35 | so we have to redefine the `SYS_ify' macro here. */ | |
36 | #undef SYS_ify | |
37 | #define SYS_ify(syscall_name) __NR_##syscall_name | |
38 | ||
3899afcb RM |
39 | /* This is a kludge to make syscalls.list find these under the names |
40 | pread and pwrite, since some kernel headers define those names | |
41 | and some define the *64 names for the same system calls. */ | |
42 | #if !defined __NR_pread && defined __NR_pread64 | |
43 | # define __NR_pread __NR_pread64 | |
44 | #endif | |
45 | #if !defined __NR_pwrite && defined __NR_pwrite64 | |
46 | # define __NR_pwrite __NR_pwrite64 | |
47 | #endif | |
48 | ||
c9cf6dde AJ |
49 | #ifdef __ASSEMBLER__ |
50 | ||
51 | /* Linux uses a negative return value to indicate syscall errors, | |
52 | unlike most Unices, which use the condition codes' carry flag. | |
53 | ||
54 | Since version 2.1 the return value of a system call might be | |
55 | negative even if the call succeeded. E.g., the `lseek' system call | |
56 | might return a large offset. Therefore we must not anymore test | |
57 | for < 0, but test for a real error by making sure the value in %eax | |
58 | is a real error number. Linus said he will make sure the no syscall | |
59 | returns a value in -1 .. -4095 as a valid result so we can savely | |
60 | test with -4095. */ | |
61 | ||
62 | /* We don't want the label for the error handle to be global when we define | |
63 | it here. */ | |
64 | #ifdef PIC | |
65 | # define SYSCALL_ERROR_LABEL 0f | |
66 | #else | |
67 | # define SYSCALL_ERROR_LABEL syscall_error | |
68 | #endif | |
69 | ||
70 | #undef PSEUDO | |
71 | #define PSEUDO(name, syscall_name, args) \ | |
72 | .text; \ | |
73 | ENTRY (name) \ | |
ffa8d2a0 | 74 | DO_CALL (syscall_name, args); \ |
c9cf6dde AJ |
75 | cmpq $-4095, %rax; \ |
76 | jae SYSCALL_ERROR_LABEL; \ | |
77 | L(pseudo_end): | |
78 | ||
79 | #undef PSEUDO_END | |
80 | #define PSEUDO_END(name) \ | |
81 | SYSCALL_ERROR_HANDLER \ | |
82 | END (name) | |
83 | ||
84 | #ifndef PIC | |
85 | #define SYSCALL_ERROR_HANDLER /* Nothing here; code in sysdep.S is used. */ | |
89b91a92 | 86 | #elif RTLD_PRIVATE_ERRNO |
3efdff78 | 87 | # define SYSCALL_ERROR_HANDLER \ |
1077a5f2 | 88 | 0: \ |
89b91a92 | 89 | leaq errno(%rip), %rcx; \ |
3efdff78 RM |
90 | xorq %rdx, %rdx; \ |
91 | subq %rax, %rdx; \ | |
89b91a92 | 92 | movl %edx, (%rcx); \ |
5232c939 RM |
93 | orq $-1, %rax; \ |
94 | jmp L(pseudo_end); | |
89b91a92 | 95 | #elif USE___THREAD |
0a951d0e RM |
96 | # ifndef NOT_IN_libc |
97 | # define SYSCALL_ERROR_ERRNO __libc_errno | |
98 | # else | |
99 | # define SYSCALL_ERROR_ERRNO errno | |
100 | # endif | |
ce460d04 | 101 | # define SYSCALL_ERROR_HANDLER \ |
1077a5f2 | 102 | 0: \ |
0a951d0e | 103 | movq SYSCALL_ERROR_ERRNO@GOTTPOFF(%rip), %rcx;\ |
ce460d04 RM |
104 | xorq %rdx, %rdx; \ |
105 | subq %rax, %rdx; \ | |
89b91a92 | 106 | movl %edx, %fs:(%rcx); \ |
5232c939 RM |
107 | orq $-1, %rax; \ |
108 | jmp L(pseudo_end); | |
3efdff78 RM |
109 | #elif defined _LIBC_REENTRANT |
110 | /* Store (- %rax) into errno through the GOT. | |
111 | Note that errno occupies only 4 bytes. */ | |
112 | # define SYSCALL_ERROR_HANDLER \ | |
c9cf6dde AJ |
113 | 0: \ |
114 | xorq %rdx, %rdx; \ | |
115 | subq %rax, %rdx; \ | |
116 | pushq %rdx \ | |
117 | PUSH_ERRNO_LOCATION_RETURN; \ | |
118 | call BP_SYM (__errno_location)@PLT; \ | |
119 | POP_ERRNO_LOCATION_RETURN; \ | |
120 | popq %rdx; \ | |
5d865001 | 121 | movl %edx, (%rax); \ |
c9cf6dde AJ |
122 | orq $-1, %rax; \ |
123 | jmp L(pseudo_end); | |
124 | ||
125 | /* A quick note: it is assumed that the call to `__errno_location' does | |
126 | not modify the stack! */ | |
3efdff78 RM |
127 | #else /* Not _LIBC_REENTRANT. */ |
128 | # define SYSCALL_ERROR_HANDLER \ | |
c9cf6dde AJ |
129 | 0:movq errno@GOTPCREL(%RIP), %rcx; \ |
130 | xorq %rdx, %rdx; \ | |
131 | subq %rax, %rdx; \ | |
5d865001 | 132 | movl %edx, (%rcx); \ |
c9cf6dde AJ |
133 | orq $-1, %rax; \ |
134 | jmp L(pseudo_end); | |
c9cf6dde AJ |
135 | #endif /* PIC */ |
136 | ||
137 | /* Linux/x86-64 takes system call arguments in registers: | |
138 | ||
139 | Register setup: | |
140 | system call number rax | |
141 | arg 1 rdi | |
142 | arg 2 rsi | |
143 | arg 3 rdx | |
144 | arg 4 rcx | |
145 | arg 5 r8 | |
146 | arg 6 r9 | |
147 | ||
148 | return address from | |
149 | syscall rcx | |
150 | additionally clobered: r12-r15,rbx,rbp | |
151 | eflags from syscall r11 | |
152 | ||
153 | The compiler is going to form a call by coming here, through PSEUDO, with arguments: | |
154 | ||
155 | syscall number in the DO_CALL macro | |
156 | arg 1 rdi | |
157 | arg 2 rsi | |
158 | arg 3 rdx | |
159 | arg 4 r10 | |
160 | arg 5 r8 | |
161 | arg 6 r9 | |
162 | ||
163 | We have to take care that the stack is alignedto 16 bytes. When | |
164 | called the stack is not aligned since the return address has just | |
165 | been pushed. | |
166 | ||
167 | Syscalls of more than 6 arguments are not supported. */ | |
168 | ||
169 | #undef DO_CALL | |
ffa8d2a0 | 170 | #define DO_CALL(syscall_name, args) \ |
c9cf6dde AJ |
171 | DOARGS_##args \ |
172 | movq $SYS_ify (syscall_name), %rax; \ | |
173 | syscall; | |
174 | ||
175 | #define DOARGS_0 /* nothing */ | |
176 | #define DOARGS_1 /* nothing */ | |
177 | #define DOARGS_2 /* nothing */ | |
178 | #define DOARGS_3 /* nothing */ | |
179 | #define DOARGS_4 movq %rcx, %r10; | |
180 | #define DOARGS_5 DOARGS_4 | |
181 | #define DOARGS_6 DOARGS_5 | |
182 | ||
183 | #else /* !__ASSEMBLER__ */ | |
184 | /* Define a macro which expands inline into the wrapper code for a system | |
185 | call. */ | |
186 | #undef INLINE_SYSCALL | |
187 | #define INLINE_SYSCALL(name, nr, args...) \ | |
188 | ({ \ | |
189 | unsigned long resultvar; \ | |
190 | LOAD_ARGS_##nr (args) \ | |
191 | asm volatile ( \ | |
192 | "movq %1, %%rax\n\t" \ | |
193 | "syscall\n\t" \ | |
194 | : "=a" (resultvar) \ | |
195 | : "i" (__NR_##name) ASM_ARGS_##nr : "memory", "cc", "r11", "cx"); \ | |
196 | if (resultvar >= (unsigned long) -4095) \ | |
197 | { \ | |
198 | __set_errno (-resultvar); \ | |
199 | resultvar = (unsigned long) -1; \ | |
200 | } \ | |
201 | (long) resultvar; }) | |
202 | ||
203 | #define LOAD_ARGS_0() | |
204 | #define ASM_ARGS_0 | |
205 | ||
206 | #define LOAD_ARGS_1(a1) \ | |
207 | register long int _a1 asm ("rdi") = (long) (a1); \ | |
208 | LOAD_ARGS_0 () | |
209 | #define ASM_ARGS_1 ASM_ARGS_0, "r" (_a1) | |
210 | ||
211 | #define LOAD_ARGS_2(a1, a2) \ | |
212 | register long int _a2 asm ("rsi") = (long) (a2); \ | |
213 | LOAD_ARGS_1 (a1) | |
214 | #define ASM_ARGS_2 ASM_ARGS_1, "r" (_a2) | |
215 | ||
216 | #define LOAD_ARGS_3(a1, a2, a3) \ | |
217 | register long int _a3 asm ("rdx") = (long) (a3); \ | |
218 | LOAD_ARGS_2 (a1, a2) | |
219 | #define ASM_ARGS_3 ASM_ARGS_2, "r" (_a3) | |
220 | ||
221 | #define LOAD_ARGS_4(a1, a2, a3, a4) \ | |
222 | register long int _a4 asm ("r10") = (long) (a4); \ | |
223 | LOAD_ARGS_3 (a1, a2, a3) | |
224 | #define ASM_ARGS_4 ASM_ARGS_3, "r" (_a4) | |
225 | ||
226 | #define LOAD_ARGS_5(a1, a2, a3, a4, a5) \ | |
227 | register long int _a5 asm ("r8") = (long) (a5); \ | |
228 | LOAD_ARGS_4 (a1, a2, a3, a4) | |
229 | #define ASM_ARGS_5 ASM_ARGS_4, "r" (_a5) | |
230 | ||
231 | #define LOAD_ARGS_6(a1, a2, a3, a4, a5, a6) \ | |
232 | register long int _a6 asm ("r9") = (long) (a6); \ | |
233 | LOAD_ARGS_5 (a1, a2, a3, a4, a5) | |
234 | #define ASM_ARGS_6 ASM_ARGS_5, "r" (_a6) | |
235 | ||
236 | #endif /* __ASSEMBLER__ */ | |
237 | ||
238 | #endif /* linux/x86_64/sysdep.h */ |