FreeVMS: starlet/src/sysdep.h Source File

00001 /* Copyright (C) 1992, 93, 95, 96, 97, 98, 99, 00 Free Software Foundation, Inc.
00002    This file is part of the GNU C Library.
00003    Contributed by Ulrich Drepper, <drepper@gnu.org>, August 1995.
00004 
00005    The GNU C Library is free software; you can redistribute it and/or
00006    modify it under the terms of the GNU Lesser General Public
00007    License as published by the Free Software Foundation; either
00008    version 2.1 of the License, or (at your option) any later version.
00009 
00010    The GNU C Library is distributed in the hope that it will be useful,
00011    but WITHOUT ANY WARRANTY; without even the implied warranty of
00012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013    Lesser General Public License for more details.
00014 
00015    You should have received a copy of the GNU Lesser General Public
00016    License along with the GNU C Library; if not, write to the Free
00017    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
00018    02111-1307 USA.  */
00019 
00020 #ifdef compile_um
00021 #include "sysdepum.h"
00022 #else
00023 
00024 #ifndef _LINUX_I386_SYSDEP_H
00025 #define _LINUX_I386_SYSDEP_H 1
00026 
00027 /* There is some commonality.  */
00028 //#include <sysdeps/unix/i386/sysdep.h>
00029 //#include <bp-sym.h>
00030 //#include <bp-asm.h>
00031 
00032 #ifdef __i386__
00033 /* For Linux we can use the system call table in the header file
00034         /usr/include/asm/unistd.h
00035    of the kernel.  But these symbols do not follow the SYS_* syntax
00036    so we have to redefine the `SYS_ify' macro here.  */
00037 #undef SYS_ify
00038 #define SYS_ify(syscall_name)   __NR_##syscall_name
00039 
00040 /* ELF-like local names start with `.L'.  */
00041 #undef L
00042 #define L(name) .L##name
00043 
00044 #ifdef __ASSEMBLER__
00045 
00046 /* Linux uses a negative return value to indicate syscall errors,
00047    unlike most Unices, which use the condition codes' carry flag.
00048 
00049    Since version 2.1 the return value of a system call might be
00050    negative even if the call succeeded.  E.g., the `lseek' system call
00051    might return a large offset.  Therefore we must not anymore test
00052    for < 0, but test for a real error by making sure the value in %eax
00053    is a real error number.  Linus said he will make sure the no syscall
00054    returns a value in -1 .. -4095 as a valid result so we can savely
00055    test with -4095.  */
00056 
00057 /* We don't want the label for the error handle to be global when we define
00058    it here.  */
00059 #ifdef PIC
00060 # define SYSCALL_ERROR_LABEL 0f
00061 #else
00062 # define SYSCALL_ERROR_LABEL syscall_error
00063 #endif
00064 
00065 #undef  PSEUDO
00066 #define PSEUDO(name, syscall_name, args)                                      \
00067   .text;                                                                      \
00068   ENTRY (name)                                                                \
00069     DO_CALL (args, syscall_name);                                             \
00070     cmpl _-4095, %eax;                                                        \
00071     jae SYSCALL_ERROR_LABEL;                                                  \
00072   L(pseudo_end):
00073 
00074 #undef  PSEUDO_END
00075 #define PSEUDO_END(name)                                                      \
00076   SYSCALL_ERROR_HANDLER                                                       \
00077   END (name)
00078 
00079 #ifndef PIC
00080 #define SYSCALL_ERROR_HANDLER   /* Nothing here; code in sysdep.S is used.  */
00081 #else
00082 /* Store (- %eax) into errno through the GOT.  */
00083 #ifdef _LIBC_REENTRANT
00084 #define SYSCALL_ERROR_HANDLER                                                 \
00085 0:pushl %ebx;                                                                 \
00086   call 1f;                                                                    \
00087 1:popl %ebx;                                                                  \
00088   xorl %edx, %edx;                                                            \
00089   addl __GLOBAL_OFFSET_TABLE_+[.-1b], %ebx;                                   \
00090   subl %eax, %edx;                                                            \
00091   pushl %edx;                                                                 \
00092   PUSH_ERRNO_LOCATION_RETURN;                                                 \
00093   call BP_SYM (__errno_location)@PLT;                                         \
00094   POP_ERRNO_LOCATION_RETURN;                                                  \
00095   popl %ecx;                                                                  \
00096   popl %ebx;                                                                  \
00097   movl %ecx, (%eax);                                                          \
00098   orl _-1, %eax;                                                              \
00099   jmp L(pseudo_end);
00100 /* A quick note: it is assumed that the call to `__errno_location' does
00101    not modify the stack!  */
00102 #else
00103 #define SYSCALL_ERROR_HANDLER                                                 \
00104 0:call 1f;                                                                    \
00105 1:popl %ecx;                                                                  \
00106   xorl %edx, %edx;                                                            \
00107   addl __GLOBAL_OFFSET_TABLE_+[.-1b], %ecx;                                   \
00108   subl %eax, %edx;                                                            \
00109   movl errno@GOT(%ecx), %ecx;                                                 \
00110   movl %edx, (%ecx);                                                          \
00111   orl _-1, %eax;                                                              \
00112   jmp L(pseudo_end);
00113 #endif  /* _LIBC_REENTRANT */
00114 #endif  /* PIC */
00115 
00116 /* Linux takes system call arguments in registers:
00117 
00118         syscall number  %eax         call-clobbered
00119         arg 1           %ebx         call-saved
00120         arg 2           %ecx         call-clobbered
00121         arg 3           %edx         call-clobbered
00122         arg 4           %esi         call-saved
00123         arg 5           %edi         call-saved
00124 
00125    The stack layout upon entering the function is:
00126 
00127         20(%esp)        Arg# 5
00128         16(%esp)        Arg# 4
00129         12(%esp)        Arg# 3
00130          8(%esp)        Arg# 2
00131          4(%esp)        Arg# 1
00132           (%esp)        Return address
00133 
00134    (Of course a function with say 3 arguments does not have entries for
00135    arguments 4 and 5.)
00136 
00137    The following code tries hard to be optimal.  A general assumption
00138    (which is true according to the data books I have) is that
00139 
00140         2 * xchg        is more expensive than  pushl + movl + popl
00141 
00142    Beside this a neat trick is used.  The calling conventions for Linux
00143    tell that among the registers used for parameters %ecx and %edx need
00144    not be saved.  Beside this we may clobber this registers even when
00145    they are not used for parameter passing.
00146 
00147    As a result one can see below that we save the content of the %ebx
00148    register in the %edx register when we have less than 3 arguments
00149    (2 * movl is less expensive than pushl + popl).
00150 
00151    Second unlike for the other registers we don't save the content of
00152    %ecx and %edx when we have more than 1 and 2 registers resp.
00153 
00154    The code below might look a bit long but we have to take care for
00155    the pipelined processors (i586).  Here the `pushl' and `popl'
00156    instructions are marked as NP (not pairable) but the exception is
00157    two consecutive of these instruction.  This gives no penalty on
00158    other processors though.  */
00159 
00160 #undef  DO_CALL
00161 #define DO_CALL(args, syscall_name)                                           \
00162     PUSHARGS_##args                                                           \
00163     DOARGS_##args                                                             \
00164     movl _SYS_ify (syscall_name), %eax;                                       \
00165     int _0x81                                                                 \
00166     POPARGS_##args
00167 
00168 #define PUSHARGS_0      /* No arguments to push.  */
00169 #define DOARGS_0        /* No arguments to frob.  */
00170 #define POPARGS_0       /* No arguments to pop.  */
00171 #define _PUSHARGS_0     /* No arguments to push.  */
00172 #define _DOARGS_0(n)    /* No arguments to frob.  */
00173 #define _POPARGS_0      /* No arguments to pop.  */
00174 
00175 #define PUSHARGS_1      movl %ebx, %edx; PUSHARGS_0
00176 #define DOARGS_1        _DOARGS_1 (4)
00177 #define POPARGS_1       POPARGS_0; movl %edx, %ebx
00178 #define _PUSHARGS_1     pushl %ebx; _PUSHARGS_0
00179 #define _DOARGS_1(n)    movl n(%esp), %ebx; _DOARGS_0(n-4)
00180 #define _POPARGS_1      _POPARGS_0; popl %ebx
00181 
00182 #define PUSHARGS_2      PUSHARGS_1
00183 #define DOARGS_2        _DOARGS_2 (8)
00184 #define POPARGS_2       POPARGS_1
00185 #define _PUSHARGS_2     _PUSHARGS_1
00186 #define _DOARGS_2(n)    movl n(%esp), %ecx; _DOARGS_1 (n-4)
00187 #define _POPARGS_2      _POPARGS_1
00188 
00189 #define PUSHARGS_3      _PUSHARGS_2
00190 #define DOARGS_3        _DOARGS_3 (16)
00191 #define POPARGS_3       _POPARGS_3
00192 #define _PUSHARGS_3     _PUSHARGS_2
00193 #define _DOARGS_3(n)    movl n(%esp), %edx; _DOARGS_2 (n-4)
00194 #define _POPARGS_3      _POPARGS_2
00195 
00196 #define PUSHARGS_4      _PUSHARGS_4
00197 #define DOARGS_4        _DOARGS_4 (24)
00198 #define POPARGS_4       _POPARGS_4
00199 #define _PUSHARGS_4     pushl %esi; _PUSHARGS_3
00200 #define _DOARGS_4(n)    movl n(%esp), %esi; _DOARGS_3 (n-4)
00201 #define _POPARGS_4      _POPARGS_3; popl %esi
00202 
00203 #define PUSHARGS_5      _PUSHARGS_5
00204 #define DOARGS_5        _DOARGS_5 (32)
00205 #define POPARGS_5       _POPARGS_5
00206 #define _PUSHARGS_5     pushl %edi; _PUSHARGS_4
00207 #define _DOARGS_5(n)    movl n(%esp), %edi; _DOARGS_4 (n-4)
00208 #define _POPARGS_5      _POPARGS_4; popl %edi
00209 
00210 #else   /* !__ASSEMBLER__ */
00211 
00212 /* We need some help from the assembler to generate optimal code.  We
00213    define some macros here which later will be used.  */
00214 asm (".L__X'%ebx = 1\n\t"
00215      ".L__X'%ecx = 2\n\t"
00216      ".L__X'%edx = 2\n\t"
00217      ".L__X'%eax = 3\n\t"
00218      ".L__X'%esi = 3\n\t"
00219      ".L__X'%edi = 3\n\t"
00220      ".L__X'%ebp = 3\n\t"
00221      ".L__X'%esp = 3\n\t"
00222      ".macro bpushl name reg\n\t"
00223      ".if 1 - \\name\n\t"
00224      ".if 2 - \\name\n\t"
00225      "pushl %ebx\n\t"
00226      ".else\n\t"
00227      "xchgl \\reg, %ebx\n\t"
00228      ".endif\n\t"
00229      ".endif\n\t"
00230      ".endm\n\t"
00231      ".macro bpopl name reg\n\t"
00232      ".if 1 - \\name\n\t"
00233      ".if 2 - \\name\n\t"
00234      "popl %ebx\n\t"
00235      ".else\n\t"
00236      "xchgl \\reg, %ebx\n\t"
00237      ".endif\n\t"
00238      ".endif\n\t"
00239      ".endm\n\t"
00240      ".macro bmovl name reg\n\t"
00241      ".if 1 - \\name\n\t"
00242      ".if 2 - \\name\n\t"
00243      "movl \\reg, %ebx\n\t"
00244      ".endif\n\t"
00245      ".endif\n\t"
00246      ".endm\n\t");
00247 
00248 //extern int errno;
00249 #ifndef __KERNEL__
00250 #include <errno.h>
00251 #else
00252 extern int kernel_errno;
00253 #define errno kernel_errno
00254 #endif
00255 
00256 /* Define a macro which expands inline into the wrapper code for a system
00257    call.  */
00258 #undef INLINE_SYSCALL
00259 #define INLINE_SYSCALL(name, nr, args...) \
00260   ({                                                                          \
00261     unsigned int resultvar;                                                   \
00262     asm volatile (                                                            \
00263     LOADARGS_##nr                                                             \
00264     "movl %1, %%eax\n\t"                                                      \
00265     "int _0x81\n\t"                                                           \
00266     RESTOREARGS_##nr                                                          \
00267     : "=a" (resultvar)                                                        \
00268     : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc");                  \
00269     if (resultvar >= 0xfffff001)                                              \
00270       {                                                                       \
00271         errno= (-resultvar);                                          \
00272         resultvar = 0xffffffff;                                               \
00273       }                                                                       \
00274     (int) resultvar; })
00275 
00276 #undef INLINE_SYSCALL1
00277 #define INLINE_SYSCALL1(name, nr, args...) \
00278   ({                                                                          \
00279     unsigned int resultvar;                                                   \
00280     asm volatile (                                                            \
00281     LOADARGS_##nr                                                             \
00282     "movl %1, %%eax\n\t"                                                      \
00283     "int _0x82\n\t"                                                           \
00284     RESTOREARGS_##nr                                                          \
00285     : "=a" (resultvar)                                                        \
00286     : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc");                  \
00287     if (resultvar >= 0xfffff001)                                              \
00288       {                                                                       \
00289         errno= (-resultvar);                                          \
00290         resultvar = 0xffffffff;                                               \
00291       }                                                                       \
00292     (int) resultvar; })
00293 
00294 #undef INLINE_SYSCALL3
00295 #define INLINE_SYSCALL3(name, nr, args...) \
00296   ({                                                                          \
00297     unsigned int resultvar;                                                   \
00298     asm volatile (                                                            \
00299     LOADARGS_##nr                                                             \
00300     "movl %1, %%eax\n\t"                                                      \
00301     "int _0x84\n\t"                                                           \
00302     RESTOREARGS_##nr                                                          \
00303     : "=a" (resultvar)                                                        \
00304     : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc");                  \
00305     if (resultvar >= 0xfffff001)                                              \
00306       {                                                                       \
00307         errno= (-resultvar);                                          \
00308         resultvar = 0xffffffff;                                               \
00309       }                                                                       \
00310     (int) resultvar; })
00311 
00312 #undef INLINE_SYSCALLTEST
00313 #define INLINE_SYSCALLTEST(name, nr, args...) \
00314   ({                                                                          \
00315     unsigned int resultvar;                                                   \
00316     asm volatile (                                                            \
00317     LOADARGS_##nr                                                             \
00318     "movl %1, %%eax\n\t"                                                      \
00319     "call 0xc0100010\n\t"                                                     \
00320     RESTOREARGS_##nr                                                          \
00321     : "=a" (resultvar)                                                        \
00322     : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc");                  \
00323     if (resultvar >= 0xfffff001)                                              \
00324       {                                                                       \
00325         errno= (-resultvar);                                          \
00326         resultvar = 0xffffffff;                                               \
00327       }                                                                       \
00328     (int) resultvar; })
00329 
00330 #define LOADARGS_0
00331 #define LOADARGS_1 \
00332     "bpushl .L__X'%k2, %k2\n\t"                                               \
00333     "bmovl .L__X'%k2, %k2\n\t"
00334 #define LOADARGS_2      LOADARGS_1
00335 #define LOADARGS_3      LOADARGS_1
00336 #define LOADARGS_4      LOADARGS_1
00337 #define LOADARGS_5      LOADARGS_1
00338 
00339 #define RESTOREARGS_0
00340 #define RESTOREARGS_1 \
00341     "bpopl .L__X'%k2, %k2\n\t"
00342 #define RESTOREARGS_2   RESTOREARGS_1
00343 #define RESTOREARGS_3   RESTOREARGS_1
00344 #define RESTOREARGS_4   RESTOREARGS_1
00345 #define RESTOREARGS_5   RESTOREARGS_1
00346 
00347 #define ASMFMT_0()
00348 #define ASMFMT_1(arg1) \
00349         , "acdSD" (arg1)
00350 #define ASMFMT_2(arg1, arg2) \
00351         , "adCD" (arg1), "c" (arg2)
00352 #define ASMFMT_3(arg1, arg2, arg3) \
00353         , "aCD" (arg1), "c" (arg2), "d" (arg3)
00354 #define ASMFMT_4(arg1, arg2, arg3, arg4) \
00355         , "aD" (arg1), "c" (arg2), "d" (arg3), "S" (arg4)
00356 #define ASMFMT_5(arg1, arg2, arg3, arg4, arg5) \
00357         , "a" (arg1), "c" (arg2), "d" (arg3), "S" (arg4), "D" (arg5)
00358 
00359 #endif  /* __ASSEMBLER__ */
00360 
00361 #endif /* __i386__ */
00362 #ifdef __x86_64__
00363 #if 1
00364 /* For Linux we can use the system call table in the header file
00365         /usr/include/asm/unistd.h
00366    of the kernel.  But these symbols do not follow the SYS_* syntax
00367    so we have to redefine the `SYS_ify' macro here.  */
00368 #undef SYS_ify
00369 #define SYS_ify(syscall_name)   __NR_##syscall_name
00370 
00371 /* This is a kludge to make syscalls.list find these under the names
00372    pread and pwrite, since some kernel headers define those names
00373    and some define the *64 names for the same system calls.  */
00374 #if !defined __NR_pread && defined __NR_pread64
00375 # define __NR_pread __NR_pread64
00376 #endif
00377 #if !defined __NR_pwrite && defined __NR_pwrite64
00378 # define __NR_pwrite __NR_pwrite64
00379 #endif
00380 
00381 /* This is to help the old kernel headers where __NR_semtimedop is not
00382    available.  */
00383 #ifndef __NR_semtimedop
00384 # define __NR_semtimedop 220
00385 #endif
00386 
00387 
00388 #ifdef __ASSEMBLER__
00389 
00390 /* Linux uses a negative return value to indicate syscall errors,
00391    unlike most Unices, which use the condition codes' carry flag.
00392 
00393    Since version 2.1 the return value of a system call might be
00394    negative even if the call succeeded.  E.g., the `lseek' system call
00395    might return a large offset.  Therefore we must not anymore test
00396    for < 0, but test for a real error by making sure the value in %eax
00397    is a real error number.  Linus said he will make sure the no syscall
00398    returns a value in -1 .. -4095 as a valid result so we can savely
00399    test with -4095.  */
00400 
00401 /* We don't want the label for the error handle to be global when we define
00402    it here.  */
00403 #ifdef PIC
00404 # define SYSCALL_ERROR_LABEL 0f
00405 #else
00406 # define SYSCALL_ERROR_LABEL syscall_error
00407 #endif
00408 
00409 #undef  PSEUDO
00410 #define PSEUDO(name, syscall_name, args)                                      \
00411   .text;                                                                      \
00412   ENTRY (name)                                                                \
00413     DO_CALL (syscall_name, args);                                             \
00414     cmpq _-4095, %rax;                                                        \
00415     jae SYSCALL_ERROR_LABEL;                                                  \
00416   L(pseudo_end):
00417 
00418 #undef  PSEUDO_END
00419 #define PSEUDO_END(name)                                                      \
00420   SYSCALL_ERROR_HANDLER                                                       \
00421   END (name)
00422 
00423 #undef  PSEUDO_NOERRNO
00424 #define PSEUDO_NOERRNO(name, syscall_name, args) \
00425   .text;                                                                      \
00426   ENTRY (name)                                                                \
00427     DO_CALL (syscall_name, args)
00428 
00429 #undef  PSEUDO_END_NOERRNO
00430 #define PSEUDO_END_NOERRNO(name) \
00431   END (name)
00432 
00433 #define ret_NOERRNO ret
00434 
00435 #undef  PSEUDO_ERRVAL
00436 #define PSEUDO_ERRVAL(name, syscall_name, args) \
00437   .text;                                                                      \
00438   ENTRY (name)                                                                \
00439     DO_CALL (syscall_name, args);                                             \
00440     negq %rax
00441 
00442 #undef  PSEUDO_END_ERRVAL
00443 #define PSEUDO_END_ERRVAL(name) \
00444   END (name)
00445 
00446 #define ret_ERRVAL ret
00447 
00448 #ifndef PIC
00449 #define SYSCALL_ERROR_HANDLER   /* Nothing here; code in sysdep.S is used.  */
00450 #elif RTLD_PRIVATE_ERRNO
00451 # define SYSCALL_ERROR_HANDLER                  \
00452 0:                                              \
00453   leaq errno(%rip), %rcx;                       \
00454   xorq %rdx, %rdx;                              \
00455   subq %rax, %rdx;                              \
00456   movl %edx, (%rcx);                            \
00457   orq _-1, %rax;                                \
00458   jmp L(pseudo_end);
00459 #elif USE___THREAD
00460 # ifndef NOT_IN_libc
00461 #  define SYSCALL_ERROR_ERRNO __libc_errno
00462 # else
00463 #  define SYSCALL_ERROR_ERRNO errno
00464 # endif
00465 # define SYSCALL_ERROR_HANDLER                  \
00466 0:                                              \
00467   movq SYSCALL_ERROR_ERRNO@GOTTPOFF(%rip), %rcx;\
00468   xorq %rdx, %rdx;                              \
00469   subq %rax, %rdx;                              \
00470   movl %edx, %fs:(%rcx);                        \
00471   orq _-1, %rax;                                \
00472   jmp L(pseudo_end);
00473 #elif defined _LIBC_REENTRANT
00474 /* Store (- %rax) into errno through the GOT.
00475    Note that errno occupies only 4 bytes.  */
00476 # define SYSCALL_ERROR_HANDLER                  \
00477 0:                                              \
00478   xorq %rdx, %rdx;                              \
00479   subq %rax, %rdx;                              \
00480   pushq %rdx;                                   \
00481   cfi_adjust_cfa_offset(8);                     \
00482   PUSH_ERRNO_LOCATION_RETURN;                   \
00483   call BP_SYM (__errno_location)@PLT;           \
00484   POP_ERRNO_LOCATION_RETURN;                    \
00485   popq %rdx;                                    \
00486   cfi_adjust_cfa_offset(-8);                    \
00487   movl %edx, (%rax);                            \
00488   orq _-1, %rax;                                \
00489   jmp L(pseudo_end);
00490 
00491 /* A quick note: it is assumed that the call to `__errno_location' does
00492    not modify the stack!  */
00493 #else /* Not _LIBC_REENTRANT.  */
00494 # define SYSCALL_ERROR_HANDLER                  \
00495 0:movq errno@GOTPCREL(%RIP), %rcx;              \
00496   xorq %rdx, %rdx;                              \
00497   subq %rax, %rdx;                              \
00498   movl %edx, (%rcx);                            \
00499   orq _-1, %rax;                                \
00500   jmp L(pseudo_end);
00501 #endif  /* PIC */
00502 
00503 /* The Linux/x86-64 kernel expects the system call parameters in
00504    registers according to the following table:
00505 
00506     syscall number      rax
00507     arg 1               rdi
00508     arg 2               rsi
00509     arg 3               rdx
00510     arg 4               r10
00511     arg 5               r8
00512     arg 6               r9
00513 
00514     The Linux kernel uses and destroys internally these registers:
00515     return address from
00516     syscall             rcx
00517     additionally clobered: r12-r15,rbx,rbp
00518     eflags from syscall r11
00519 
00520     Normal function call, including calls to the system call stub
00521     functions in the libc, get the first six parameters passed in
00522     registers and the seventh parameter and later on the stack.  The
00523     register use is as follows:
00524 
00525      system call number in the DO_CALL macro
00526      arg 1              rdi
00527      arg 2              rsi
00528      arg 3              rdx
00529      arg 4              rcx
00530      arg 5              r8
00531      arg 6              r9
00532 
00533     We have to take care that the stack is aligned to 16 bytes.  When
00534     called the stack is not aligned since the return address has just
00535     been pushed.
00536 
00537 
00538     Syscalls of more than 6 arguments are not supported.  */
00539 
00540 #undef  DO_CALL
00541 #define DO_CALL(syscall_name, args)             \
00542     DOARGS_##args                               \
00543     movq _SYS_ify (syscall_name), %rax;         \
00544     syscall;
00545 
00546 #define DOARGS_0 /* nothing */
00547 #define DOARGS_1 /* nothing */
00548 #define DOARGS_2 /* nothing */
00549 #define DOARGS_3 /* nothing */
00550 #define DOARGS_4 movq %rcx, %r10;
00551 #define DOARGS_5 DOARGS_4
00552 #define DOARGS_6 DOARGS_5
00553 
00554 #else   /* !__ASSEMBLER__ */
00555 /* Define a macro which expands inline into the wrapper code for a system
00556    call.  */
00557 #undef INLINE_SYSCALL
00558 #define INLINE_SYSCALL(name, nr, args...) \
00559   ({                                                                          \
00560     unsigned long resultvar = INTERNAL_SYSCALL (name, , nr, args);            \
00561     if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (resultvar, ), 0))         \
00562       {                                                                       \
00563         __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, ));                   \
00564         resultvar = (unsigned long) -1;                                       \
00565       }                                                                       \
00566     (long) resultvar; })
00567 
00568 #undef INTERNAL_SYSCALL_DECL
00569 #define INTERNAL_SYSCALL_DECL(err) do { } while (0)
00570 
00571 #undef INLINE_SYSCALL
00572 #undef INTERNAL_SYSCALL
00573 #define INLINE_SYSCALL(name, nr, args...) \
00574   ({                                                                          \
00575     unsigned long resultvar;                                                  \
00576     LOAD_ARGS_##nr (args)                                                     \
00577     asm volatile (                                                            \
00578     "movq %1, %%rax\n\t"                                                      \
00579     "int _0x81\n\t"                                                           \
00580     : "=a" (resultvar)                                                        \
00581     : "i" (__NR_##name) ASM_ARGS_##nr : "memory", "cc", "r11", "cx");         \
00582     (long) resultvar; })
00583 
00584 #define INLINE_SYSCALL1(name, nr, args...) \
00585   ({                                                                          \
00586     unsigned long resultvar;                                                  \
00587     LOAD_ARGS_##nr (args)                                                     \
00588     asm volatile (                                                            \
00589     "movq %1, %%rax\n\t"                                                      \
00590     "int _0x82\n\t"                                                           \
00591     : "=a" (resultvar)                                                        \
00592     : "i" (__NR_##name) ASM_ARGS_##nr : "memory", "cc", "r11", "cx");         \
00593     (long) resultvar; })
00594 
00595 #define INLINE_SYSCALL3(name, nr, args...) \
00596   ({                                                                          \
00597     unsigned long resultvar;                                                  \
00598     LOAD_ARGS_##nr (args)                                                     \
00599     asm volatile (                                                            \
00600     "movq %1, %%rax\n\t"                                                      \
00601     "int _0x84\n\t"                                                           \
00602     : "=a" (resultvar)                                                        \
00603     : "i" (__NR_##name) ASM_ARGS_##nr : "memory", "cc", "r11", "cx");         \
00604     (long) resultvar; })
00605 
00606 #undef INTERNAL_SYSCALL_ERROR_P
00607 #define INTERNAL_SYSCALL_ERROR_P(val, err) \
00608   ((unsigned long) (val) >= -4095L)
00609 
00610 #undef INTERNAL_SYSCALL_ERRNO
00611 #define INTERNAL_SYSCALL_ERRNO(val, err)        (-(val))
00612 
00613 #define LOAD_ARGS_0()
00614 #define ASM_ARGS_0
00615 
00616 #define LOAD_ARGS_1(a1)                                 \
00617   register long int _a1 asm ("rdi") = (long) (a1);      \
00618   LOAD_ARGS_0 ()
00619 #define ASM_ARGS_1      ASM_ARGS_0, "r" (_a1)
00620 
00621 #define LOAD_ARGS_2(a1, a2)                             \
00622   register long int _a2 asm ("rsi") = (long) (a2);      \
00623   LOAD_ARGS_1 (a1)
00624 #define ASM_ARGS_2      ASM_ARGS_1, "r" (_a2)
00625 
00626 #define LOAD_ARGS_3(a1, a2, a3)                         \
00627   register long int _a3 asm ("rdx") = (long) (a3);      \
00628   LOAD_ARGS_2 (a1, a2)
00629 #define ASM_ARGS_3      ASM_ARGS_2, "r" (_a3)
00630 
00631 #define LOAD_ARGS_4(a1, a2, a3, a4)                     \
00632   register long int _a4 asm ("r10") = (long) (a4);      \
00633   LOAD_ARGS_3 (a1, a2, a3)
00634 #define ASM_ARGS_4      ASM_ARGS_3, "r" (_a4)
00635 
00636 #define LOAD_ARGS_5(a1, a2, a3, a4, a5)                 \
00637   register long int _a5 asm ("r8") = (long) (a5);       \
00638   LOAD_ARGS_4 (a1, a2, a3, a4)
00639 #define ASM_ARGS_5      ASM_ARGS_4, "r" (_a5)
00640 
00641 #define LOAD_ARGS_6(a1, a2, a3, a4, a5, a6)             \
00642   register long int _a6 asm ("r9") = (long) (a6);       \
00643   LOAD_ARGS_5 (a1, a2, a3, a4, a5)
00644 #define ASM_ARGS_6      ASM_ARGS_5, "r" (_a6)
00645 
00646 #endif  /* __ASSEMBLER__ */
00647 #else 
00648 /* For Linux we can use the system call table in the header file
00649         /usr/include/asm/unistd.h
00650    of the kernel.  But these symbols do not follow the SYS_* syntax
00651    so we have to redefine the `SYS_ify' macro here.  */
00652 #undef SYS_ify
00653 #define SYS_ify(syscall_name)   __NR_##syscall_name
00654 
00655 /* ELF-like local names start with `.L'.  */
00656 #undef L
00657 #define L(name) .L##name
00658 
00659 #ifdef __ASSEMBLER__
00660 
00661 /* Linux uses a negative return value to indicate syscall errors,
00662    unlike most Unices, which use the condition codes' carry flag.
00663 
00664    Since version 2.1 the return value of a system call might be
00665    negative even if the call succeeded.  E.g., the `lseek' system call
00666    might return a large offset.  Therefore we must not anymore test
00667    for < 0, but test for a real error by making sure the value in %rax
00668    is a real error number.  Linus said he will make sure the no syscall
00669    returns a value in -1 .. -4095 as a valid result so we can savely
00670    test with -4095.  */
00671 
00672 /* We don't want the label for the error handle to be global when we define
00673    it here.  */
00674 #ifdef PIC
00675 # define SYSCALL_ERROR_LABEL 0f
00676 #else
00677 # define SYSCALL_ERROR_LABEL syscall_error
00678 #endif
00679 
00680 #undef  PSEUDO
00681 #define PSEUDO(name, syscall_name, args)                                      \
00682   .text;                                                                      \
00683   ENTRY (name)                                                                \
00684     DO_CALL (args, syscall_name);                                             \
00685     cmpq _-4095, %rax;                                                        \
00686     jae SYSCALL_ERROR_LABEL;                                                  \
00687   L(pseudo_end):
00688 
00689 #undef  PSEUDO_END
00690 #define PSEUDO_END(name)                                                      \
00691   SYSCALL_ERROR_HANDLER                                                       \
00692   END (name)
00693 
00694 #ifndef PIC
00695 #define SYSCALL_ERROR_HANDLER   /* Nothing here; code in sysdep.S is used.  */
00696 #else
00697 /* Store (- %rax) into errno through the GOT.  */
00698 #ifdef _LIBC_REENTRANT
00699 #define SYSCALL_ERROR_HANDLER                                                 \
00700 0:pushq %rbx;                                                                 \
00701   call 1f;                                                                    \
00702 1:popq %rbx;                                                                  \
00703   xorq %rdx, %rdx;                                                            \
00704   addq __GLOBAL_OFFSET_TABLE_+[.-1b], %rbx;                                   \
00705   subq %rax, %rdx;                                                            \
00706   pushq %rdx;                                                                 \
00707   PUSH_ERRNO_LOCATION_RETURN;                                                 \
00708   call BP_SYM (__errno_location)@PLT;                                         \
00709   POP_ERRNO_LOCATION_RETURN;                                                  \
00710   popq %rcx;                                                                  \
00711   popq %rbx;                                                                  \
00712   movq %rcx, (%rax);                                                          \
00713   orq _-1, %rax;                                                              \
00714   jmp L(pseudo_end);
00715 /* A quick note: it is assumed that the call to `__errno_location' does
00716    not modify the stack!  */
00717 #else
00718 #define SYSCALL_ERROR_HANDLER                                                 \
00719 0:call 1f;                                                                    \
00720 1:popq %rcx;                                                                  \
00721   xorq %rdx, %rdx;                                                            \
00722   addq __GLOBAL_OFFSET_TABLE_+[.-1b], %rcx;                                   \
00723   subq %rax, %rdx;                                                            \
00724   movq errno@GOT(%rcx), %rcx;                                                 \
00725   movq %rdx, (%rcx);                                                          \
00726   orq _-1, %rax;                                                              \
00727   jmp L(pseudo_end);
00728 #endif  /* _LIBC_REENTRANT */
00729 #endif  /* PIC */
00730 
00731 /* Linux takes system call arguments in registers:
00732 
00733         syscall number  %rax         call-clobbered
00734         arg 1           %rbx         call-saved
00735         arg 2           %rcx         call-clobbered
00736         arg 3           %rdx         call-clobbered
00737         arg 4           %rsi         call-saved
00738         arg 5           %rdi         call-saved
00739 
00740    The stack layout upon entering the function is:
00741 
00742         40(%rsp)        Arg# 5
00743         32(%rsp)        Arg# 4
00744         24(%rsp)        Arg# 3
00745         16(%rsp)        Arg# 2
00746          8(%rsp)        Arg# 1
00747           (%rsp)        Return address
00748 
00749    (Of course a function with say 3 arguments does not have entries for
00750    arguments 4 and 5.)
00751 
00752    The following code tries hard to be optimal.  A general assumption
00753    (which is true according to the data books I have) is that
00754 
00755         2 * xchg        is more expensive than  pushq + movq + popq
00756 
00757    Beside this a neat trick is used.  The calling conventions for Linux
00758    tell that among the registers used for parameters %rcx and %rdx need
00759    not be saved.  Beside this we may clobber this registers even when
00760    they are not used for parameter passing.
00761 
00762    As a result one can see below that we save the content of the %rbx
00763    register in the %rdx register when we have less than 3 arguments
00764    (2 * movq is less expensive than pushq + popl).
00765 
00766    Second unlike for the other registers we don't save the content of
00767    %rcx and %rdx when we have more than 1 and 2 registers resp.
00768 
00769    The code below might look a bit long but we have to take care for
00770    the pipelined processors (i586).  Here the `pushl' and `popl'
00771    instructions are marked as NP (not pairable) but the exception is
00772    two consecutive of these instruction.  This gives no penalty on
00773    other processors though.  */
00774 
00775 #undef  DO_CALL
00776 #define DO_CALL(args, syscall_name)                                           \
00777     PUSHARGS_##args                                                           \
00778     DOARGS_##args                                                             \
00779     movq _SYS_ify (syscall_name), %rax;                                       \
00780     int _0x81                                                                 \
00781     POPARGS_##args
00782 
00783 #define PUSHARGS_0      /* No arguments to push.  */
00784 #define DOARGS_0        /* No arguments to frob.  */
00785 #define POPARGS_0       /* No arguments to pop.  */
00786 #define _PUSHARGS_0     /* No arguments to push.  */
00787 #define _DOARGS_0(n)    /* No arguments to frob.  */
00788 #define _POPARGS_0      /* No arguments to pop.  */
00789 
00790 #define PUSHARGS_1      movq %rbx, %rdx; PUSHARGS_0
00791 #define DOARGS_1        _DOARGS_1 (4)
00792 #define POPARGS_1       POPARGS_0; movq %rdx, %rbx
00793 #define _PUSHARGS_1     pushq %rbx; _PUSHARGS_0
00794 #define _DOARGS_1(n)    movq n(%rsp), %rbx; _DOARGS_0(n-4)
00795 #define _POPARGS_1      _POPARGS_0; popq %rbx
00796 
00797 #define PUSHARGS_2      PUSHARGS_1
00798 #define DOARGS_2        _DOARGS_2 (8)
00799 #define POPARGS_2       POPARGS_1
00800 #define _PUSHARGS_2     _PUSHARGS_1
00801 #define _DOARGS_2(n)    movq n(%rsp), %rcx; _DOARGS_1 (n-4)
00802 #define _POPARGS_2      _POPARGS_1
00803 
00804 #define PUSHARGS_3      _PUSHARGS_2
00805 #define DOARGS_3        _DOARGS_3 (16)
00806 #define POPARGS_3       _POPARGS_3
00807 #define _PUSHARGS_3     _PUSHARGS_2
00808 #define _DOARGS_3(n)    movq n(%rsp), %rdx; _DOARGS_2 (n-4)
00809 #define _POPARGS_3      _POPARGS_2
00810 
00811 #define PUSHARGS_4      _PUSHARGS_4
00812 #define DOARGS_4        _DOARGS_4 (24)
00813 #define POPARGS_4       _POPARGS_4
00814 #define _PUSHARGS_4     pushq %rsi; _PUSHARGS_3
00815 #define _DOARGS_4(n)    movq n(%rsp), %rsi; _DOARGS_3 (n-4)
00816 #define _POPARGS_4      _POPARGS_3; popq %rsi
00817 
00818 #define PUSHARGS_5      _PUSHARGS_5
00819 #define DOARGS_5        _DOARGS_5 (32)
00820 #define POPARGS_5       _POPARGS_5
00821 #define _PUSHARGS_5     pushq %rdi; _PUSHARGS_4
00822 #define _DOARGS_5(n)    movq n(%rsp), %rdi; _DOARGS_4 (n-4)
00823 #define _POPARGS_5      _POPARGS_4; popq %rdi
00824 
00825 #else   /* !__ASSEMBLER__ */
00826 
00827 /* We need some help from the assembler to generate optimal code.  We
00828    define some macros here which later will be used.  */
00829 asm (".L__X'%rbx = 1\n\t"
00830      ".L__X'%rcx = 2\n\t"
00831      ".L__X'%rdx = 2\n\t"
00832      ".L__X'%rax = 3\n\t"
00833      ".L__X'%rsi = 3\n\t"
00834      ".L__X'%rdi = 3\n\t"
00835      ".L__X'%rbp = 3\n\t"
00836      ".L__X'%rsp = 3\n\t"
00837 #if 0
00838      ".L__X'%ebx = .L__X'%rbx\n\t"
00839      ".L__X'%ecx = .L__X'%rcx\n\t"
00840      ".L__X'%edx = .L__X'%rdx\n\t"
00841      ".L__X'%eax = .L__X'%rax\n\t"
00842      ".L__X'%esi = .L__X'%rsi\n\t"
00843      ".L__X'%edi = .L__X'%rdi\n\t"
00844      ".L__X'%ebp = .L__X'%rbp\n\t"
00845      ".L__X'%esp = .L__X'%rsp\n\t"
00846 #endif
00847      ".macro bpushq name reg\n\t"
00848      ".if 1 - \\name\n\t"
00849      ".if 2 - \\name\n\t"
00850      "pushq %rbx\n\t"
00851      ".else\n\t"
00852      "xchgq \\reg, %rbx\n\t"
00853      ".endif\n\t"
00854      ".endif\n\t"
00855      ".endm\n\t"
00856      ".macro bpopq name reg\n\t"
00857      ".if 1 - \\name\n\t"
00858      ".if 2 - \\name\n\t"
00859      "popq %rbx\n\t"
00860      ".else\n\t"
00861      "xchgq \\reg, %rbx\n\t"
00862      ".endif\n\t"
00863      ".endif\n\t"
00864      ".endm\n\t"
00865      ".macro bmovq name reg\n\t"
00866      ".if 1 - \\name\n\t"
00867      ".if 2 - \\name\n\t"
00868      "movq \\reg, %rbx\n\t"
00869      ".endif\n\t"
00870      ".endif\n\t"
00871      ".endm\n\t");
00872 
00873 extern int errno;
00874 
00875 /* Define a macro which expands inline into the wrapper code for a system
00876    call.  */
00877 #undef INLINE_SYSCALL
00878 #define INLINE_SYSCALL(name, nr, args...) \
00879   ({                                                                          \
00880     unsigned int resultvar;                                                   \
00881     asm volatile (                                                            \
00882     LOADARGS_##nr                                                             \
00883     "movq %1, %%rax\n\t"                                                      \
00884     "int _0x81\n\t"                                                           \
00885     RESTOREARGS_##nr                                                          \
00886     : "=a" (resultvar)                                                        \
00887     : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc");                  \
00888     if (resultvar >= 0xfffff001)                                              \
00889       {                                                                       \
00890         errno= (-resultvar);                                          \
00891         resultvar = 0xffffffff;                                               \
00892       }                                                                       \
00893     (int) resultvar; })
00894 
00895 #undef INLINE_SYSCALL1
00896 #define INLINE_SYSCALL1(name, nr, args...) \
00897   ({                                                                          \
00898     unsigned int resultvar;                                                   \
00899     asm volatile (                                                            \
00900     LOADARGS_##nr                                                             \
00901     "movq %1, %%rax\n\t"                                                      \
00902     "int _0x82\n\t"                                                           \
00903     RESTOREARGS_##nr                                                          \
00904     : "=a" (resultvar)                                                        \
00905     : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc");                  \
00906     if (resultvar >= 0xfffff001)                                              \
00907       {                                                                       \
00908         errno= (-resultvar);                                          \
00909         resultvar = 0xffffffff;                                               \
00910       }                                                                       \
00911     (int) resultvar; })
00912 
00913 #undef INLINE_SYSCALL3
00914 #define INLINE_SYSCALL3(name, nr, args...) \
00915   ({                                                                          \
00916     unsigned int resultvar;                                                   \
00917     asm volatile (                                                            \
00918     LOADARGS_##nr                                                             \
00919     "movq %1, %%rax\n\t"                                                      \
00920     "int _0x84\n\t"                                                           \
00921     RESTOREARGS_##nr                                                          \
00922     : "=a" (resultvar)                                                        \
00923     : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc");                  \
00924     if (resultvar >= 0xfffff001)                                              \
00925       {                                                                       \
00926         errno= (-resultvar);                                          \
00927         resultvar = 0xffffffff;                                               \
00928       }                                                                       \
00929     (int) resultvar; })
00930 
00931 #undef INLINE_SYSCALLTEST
00932 #define INLINE_SYSCALLTEST(name, nr, args...) \
00933   ({                                                                          \
00934     unsigned int resultvar;                                                   \
00935     asm volatile (                                                            \
00936     LOADARGS_##nr                                                             \
00937     "movq %1, %%rax\n\t"                                                      \
00938     "call 0xc0100010\n\t"                                                     \
00939     RESTOREARGS_##nr                                                          \
00940     : "=a" (resultvar)                                                        \
00941     : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc");                  \
00942     if (resultvar >= 0xfffff001)                                              \
00943       {                                                                       \
00944         errno= (-resultvar);                                          \
00945         resultvar = 0xffffffff;                                               \
00946       }                                                                       \
00947     (int) resultvar; })
00948 
00949 #define LOADARGS_0
00950 #define LOADARGS_1 \
00951     "bpushq .L__X'%k2, %k2\n\t"                                               \
00952     "bmovq .L__X'%k2, %k2\n\t"
00953 #define LOADARGS_2      LOADARGS_1
00954 #define LOADARGS_3      LOADARGS_1
00955 #define LOADARGS_4      LOADARGS_1
00956 #define LOADARGS_5      LOADARGS_1
00957 
00958 #define RESTOREARGS_0
00959 #define RESTOREARGS_1 \
00960     "bpopq .L__X'%k2, %k2\n\t"
00961 #define RESTOREARGS_2   RESTOREARGS_1
00962 #define RESTOREARGS_3   RESTOREARGS_1
00963 #define RESTOREARGS_4   RESTOREARGS_1
00964 #define RESTOREARGS_5   RESTOREARGS_1
00965 
00966 #define ASMFMT_0()
00967 #define ASMFMT_1(arg1) \
00968         , "acdSD" (arg1)
00969 #define ASMFMT_2(arg1, arg2) \
00970         , "adCD" (arg1), "c" (arg2)
00971 #define ASMFMT_3(arg1, arg2, arg3) \
00972         , "aCD" (arg1), "c" (arg2), "d" (arg3)
00973 #define ASMFMT_4(arg1, arg2, arg3, arg4) \
00974         , "aD" (arg1), "c" (arg2), "d" (arg3), "S" (arg4)
00975 #define ASMFMT_5(arg1, arg2, arg3, arg4, arg5) \
00976         , "a" (arg1), "c" (arg2), "d" (arg3), "S" (arg4), "D" (arg5)
00977 
00978 #endif  /* __ASSEMBLER__ */
00979 #endif
00980 #endif /* __x86_64__ */
00981 #endif /* linux/i386/sysdep.h */ /* linux/x86_64/sysdep.h */
00982 #endif /* compile_um */
00983