2002-10-24 Jakub Jelinek <jakub@redhat.com>
authorroland <roland>
Thu, 24 Oct 2002 18:48:43 +0000 (18:48 +0000)
committerroland <roland>
Thu, 24 Oct 2002 18:48:43 +0000 (18:48 +0000)
* sysdeps/unix/sysv/linux/s390/s390-32/sysdep.h (INTERNAL_SYSCALL,
INTERNAL_SYSCALL_ERROR_P, INTERNAL_SYSCALL_ERRNO): New macros.
(INLINE_SYSCALL): Use that.
* sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h (INTERNAL_SYSCALL,
INTERNAL_SYSCALL_ERROR_P, INTERNAL_SYSCALL_ERRNO): New macros.
(INLINE_SYSCALL): Use that.
* sysdeps/unix/sysv/linux/x86_64/sysdep.h (INTERNAL_SYSCALL,
INTERNAL_SYSCALL_ERROR_P, INTERNAL_SYSCALL_ERRNO): New macros.
(INLINE_SYSCALL): Use that.
* sysdeps/unix/sysv/linux/sparc/sparc32/sysdep.h: Include
dl-sysdep.h.
(SYSCALL_ERROR_HANDLER): Define RTLD_PRIVATE_ERRNO variant.
(__INTERNAL_SYSCALL_STRING): Define.
* sysdeps/unix/sysv/linux/sparc/sparc64/sysdep.h: Include
dl-sysdep.h.
(SYSCALL_ERROR_HANDLER): Define RTLD_PRIVATE_ERRNO variant.
(__INTERNAL_SYSCALL_STRING): Define.
* sysdeps/unix/sysv/linux/sparc/sysdep.h (INLINE_SYSCALL): Pass
__SYSCALL_STRING to inline_syscall*.
(INTERNAL_SYSCALL, INTERNAL_SYSCALL_ERROR_P, INTERNAL_SYSCALL_ERRNO):
New macros.
(inline_syscall0, inline_syscall1, inline_syscall2, inline_syscall3,
inline_syscall4, inline_syscall5, inline_syscall6): Add string
argument.

sysdeps/unix/sysv/linux/s390/s390-32/sysdep.h
sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h
sysdeps/unix/sysv/linux/sparc/sparc32/sysdep.h
sysdeps/unix/sysv/linux/sparc/sparc64/sysdep.h
sysdeps/unix/sysv/linux/sparc/sysdep.h
sysdeps/unix/sysv/linux/x86_64/sysdep.h

index 0a95f91..c26d3f1 100644 (file)
 #endif /* __ASSEMBLER__ */
 
 #undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...)                                     \
-  ({                                                                          \
-    DECLARGS_##nr(args)                                                       \
-    int err;                                                                  \
-    asm volatile (                                                            \
-    LOADARGS_##nr                                                             \
-    "svc    %b1\n\t"                                                          \
-    "lr     %0,%%r2\n\t"                                                      \
-    : "=d" (err)                                                              \
-    : "I" (__NR_##name) ASMFMT_##nr                                           \
-    : "memory", "cc", "2", "3", "4", "5", "6");                               \
-    if (err >= 0xfffff001)                                                    \
-     {                                                                        \
-       __set_errno(-err);                                                     \
-       err = 0xffffffff;                                                      \
-     }                                                                        \
+#define INLINE_SYSCALL(name, nr, args...)                                    \
+  ({                                                                         \
+    unsigned int err = INTERNAL_SYSCALL (name, nr, args);                    \
+    if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (err), 0))                \
+     {                                                                       \
+       __set_errno (INTERNAL_SYSCALL_ERRNO (err));                           \
+       err = 0xffffffff;                                                     \
+     }                                                                       \
+    (int) err; })
+
+#undef INTERNAL_SYSCALL
+#define INTERNAL_SYSCALL(name, nr, args...)                                  \
+  ({                                                                         \
+    DECLARGS_##nr(args)                                                              \
+    int err;                                                                 \
+    asm volatile (                                                           \
+    LOADARGS_##nr                                                            \
+    "svc    %b1\n\t"                                                         \
+    "lr     %0,%%r2\n\t"                                                     \
+    : "=d" (err)                                                             \
+    : "I" (__NR_##name) ASMFMT_##nr                                          \
+    : "memory", "cc", "2", "3", "4", "5", "6");                                      \
     (int) err; })
 
+#undef INTERNAL_SYSCALL_ERROR_P
+#define INTERNAL_SYSCALL_ERROR_P(val)  ((unsigned int) (val) >= 0xfffff001u)
+
+#undef INTERNAL_SYSCALL_ERRNO
+#define INTERNAL_SYSCALL_ERRNO(val)    (-(val))
+
 #define DECLARGS_0()
 #define DECLARGS_1(arg1) \
        unsigned int gpr2 = (unsigned int) (arg1);
index 2ad9c62..0728537 100644 (file)
 #undef INLINE_SYSCALL
 #define INLINE_SYSCALL(name, nr, args...)                                    \
   ({                                                                         \
+    unsigned int err = INTERNAL_SYSCALL (name, nr, args);                    \
+    if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (err), 0))                \
+     {                                                                       \
+       __set_errno (INTERNAL_SYSCALL_ERRNO (err));                           \
+       err = -1;                                                             \
+     }                                                                       \
+    (int) err; })
+
+#undef INTERNAL_SYSCALL
+#define INTERNAL_SYSCALL(name, nr, args...)                                  \
+  ({                                                                         \
     DECLARGS_##nr(args)                                                              \
     int err;                                                                 \
     asm volatile (                                                           \
     : "=d" (err)                                                             \
     : "I" (__NR_##name) ASMFMT_##nr                                          \
     : "memory", "cc", "2", "3", "4", "5", "6");                                      \
-    if (err >= 0xfffff001)                                                   \
-     {                                                                       \
-       __set_errno(-err);                                                    \
-       err = -1;                                                             \
-     }                                                                       \
     (int) err; })
 
+#undef INTERNAL_SYSCALL_ERROR_P
+#define INTERNAL_SYSCALL_ERROR_P(val)  ((unsigned int) (val) >= 0xfffff001u)
+
+#undef INTERNAL_SYSCALL_ERRNO
+#define INTERNAL_SYSCALL_ERRNO(val)    (-(val))
+
 #define DECLARGS_0()
 #define DECLARGS_1(arg1) \
        unsigned long gpr2 = (unsigned long) (arg1);
index c2e7e0a..e3573fd 100644 (file)
 
 #include <sysdeps/unix/sparc/sysdep.h>
 
+#ifdef IS_IN_rtld
+# include <dl-sysdep.h>                /* Defines RTLD_PRIVATE_ERRNO.  */
+#endif
+
 #undef SYS_ify
 #define SYS_ify(syscall_name) __NR_##syscall_name
 
 
 #define LOC(name)  .L##name
 
-#ifdef PIC
-#define SYSCALL_ERROR_HANDLER                                  \
-       .global C_SYMBOL_NAME(__errno_location);                \
-        .type   C_SYMBOL_NAME(__errno_location),@function;     \
-       save   %sp,-96,%sp;                                     \
+#if RTLD_PRIVATE_ERRNO
+# define SYSCALL_ERROR_HANDLER                                         \
+       .section .gnu.linkonce.t.__sparc.get_pic.l7,"ax",@progbits;     \
+       .globl __sparc.get_pic.l7;                                      \
+       .hidden __sparc.get_pic.l7;                                     \
+       .type __sparc.get_pic.l7,@function;                             \
+__sparc.get_pic.l7:                                                    \
+       retl;                                                           \
+        add    %o7, %l7, %l7;                                          \
+       .previous;                                                      \
+       save    %sp,-96,%sp;                                            \
+       sethi   %hi(_GLOBAL_OFFSET_TABLE_-4), %l7;                      \
+       call    __sparc.get_pic.l7;                                     \
+        add    %l7, %lo(_GLOBAL_OFFSET_TABLE_+4), %l7;                 \
+       ld      [%l7 + errno], %l0;                                     \
+       st      %i0, [%l0];                                             \
+       jmpl    %i7+8, %g0;                                             \
+        restore %g0, -1, %o0;
+#else
+# define SYSCALL_ERROR_HANDLER                                 \
+       .global __errno_location;                               \
+        .type   __errno_location,@function;                    \
+       save   %sp, -96, %sp;                                   \
        call   __errno_location;                                \
         nop;                                                   \
-       st      %i0,[%o0];                                      \
-       jmpl    %i7+8,%g0;                                      \
-        restore %g0,-1,%o0;
-#else
-#define SYSCALL_ERROR_HANDLER                                  \
-       save    %sp,-96,%sp;                                    \
-       call    __errno_location;                               \
-       nop;                                                    \
-       st      %i0,[%o0];                                      \
-       jmpl    %i7+8,%g0;                                      \
-        restore %g0,-1,%o0;
-#endif   /* PIC */
+       st      %i0, [%o0];                                     \
+       jmpl    %i7+8, %g0;                                     \
+        restore %g0, -1, %o0;
+#endif
 
 #define PSEUDO(name, syscall_name, args)                       \
        .text;                                                  \
        " restore %%g0, -1, %%o0;"                                      \
        ".previous;"
 
+#define __INTERNAL_SYSCALL_STRING                                      \
+       "ta     0x10;"                                                  \
+       "bcs,a  1f;"                                                    \
+       " sub   %%g0, %%o0, %%o0;"                                      \
+       "1:"
+
 #define __SYSCALL_CLOBBERS "g2", "g3", "g4", "g5", "g7",               \
        "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",                 \
        "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",           \
index 1821862..3c8999a 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997, 2000 Free Software Foundation, Inc.
+/* Copyright (C) 1997, 2000, 2002 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson <richard@gnu.ai.mit.edu>, 1997.
 
 
 #include <sysdeps/unix/sysdep.h>
 
+#ifdef IS_IN_rtld
+# include <dl-sysdep.h>                /* Defines RTLD_PRIVATE_ERRNO.  */
+#endif
+
 #undef SYS_ify
 #define SYS_ify(syscall_name) __NR_##syscall_name
 
        C_LABEL(name);                                                  \
        .type name,@function;
 
-#define SYSCALL_ERROR_HANDLER                                          \
+#if RTLD_PRIVATE_ERRNO
+# define SYSCALL_ERROR_HANDLER                                         \
+       .section .gnu.linkonce.t.__sparc64.get_pic.l7,"ax",@progbits;   \
+       .globl __sparc64.get_pic.l7;                                    \
+       .hidden __sparc64.get_pic.l7;                                   \
+       .type __sparc64.get_pic.l7,@function;                           \
+__sparc64.get_pic.l7:                                                  \
+       retl;                                                           \
+        add    %o7, %l7, %l7;                                          \
+       .previous;                                                      \
        save    %sp, -192, %sp;                                         \
-       call    __errno_location;                                       \
-        nop;                                                           \
-       st      %i0, [%o0];                                             \
+       sethi   %hi(_GLOBAL_OFFSET_TABLE_-4), %l7;                      \
+       call    __sparc.get_pic.l7;                                     \
+        add    %l7, %lo(_GLOBAL_OFFSET_TABLE_+4), %l7;                 \
+       ldx     [%l7 + errno], %l0;                                     \
+       st      %i0, [%l0];                                             \
        jmpl    %i7+8, %g0;                                             \
-        restore %g0, -1, %o0
+        restore %g0, -1, %o0;
+#else
+# define SYSCALL_ERROR_HANDLER                                 \
+       .global __errno_location;                               \
+       .type   __errno_location,@function;                     \
+       save    %sp, -192, %sp;                                 \
+       call    __errno_location;                               \
+        nop;                                                   \
+       st      %i0, [%o0];                                     \
+       jmpl    %i7+8, %g0;                                     \
+        restore %g0, -1, %o0;
+#endif
 
 #define PSEUDO(name, syscall_name, args)                               \
        .text;                                                          \
        "restore %%g0, -1, %%o0;"                                       \
        "1:"
 
+#define __INTERNAL_SYSCALL_STRING                                      \
+       "ta     0x6d;"                                                  \
+       "bcs,a,pt %%xcc, 1f;"                                           \
+       " sub   %%g0, %%o0, %%o0;"                                      \
+       "1:"
+
 #define __SYSCALL_CLOBBERS "g2", "g3", "g4", "g5", "g7",               \
        "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",                 \
        "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",           \
index cf59f12..cc719b4 100644 (file)
 #define _LINUX_SPARC_SYSDEP_H 1
 
 #undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) inline_syscall##nr(name, args)
+#define INLINE_SYSCALL(name, nr, args...) \
+  inline_syscall##nr(__SYSCALL_STRING, name, args)
 
-#define inline_syscall0(name,dummy...)                                 \
+#undef INTERNAL_SYSCALL
+#define INTERNAL_SYSCALL(name, nr, args...) \
+  inline_syscall##nr(__INTERNAL_SYSCALL_STRING, name, args)
+
+#undef INTERNAL_SYSCALL_ERROR_P
+#define INTERNAL_SYSCALL_ERROR_P(val)  ((unsigned long) (val) >= -515L)
+
+#undef INTERNAL_SYSCALL_ERRNO
+#define INTERNAL_SYSCALL_ERRNO(val)    (-(val))
+
+#define inline_syscall0(string,name,dummy...)                          \
 ({                                                                     \
        register long __o0 __asm__ ("o0");                              \
        register long __g1 __asm__ ("g1") = __NR_##name;                \
-       __asm __volatile (__SYSCALL_STRING : "=r" (__g1), "=r" (__o0) : \
+       __asm __volatile (string : "=r" (__g1), "=r" (__o0) :           \
                          "0" (__g1) :                                  \
                          __SYSCALL_CLOBBERS);                          \
        __o0;                                                           \
 })
 
-#define inline_syscall1(name,arg1)                                     \
+#define inline_syscall1(string,name,arg1)                              \
 ({                                                                     \
        register long __o0 __asm__ ("o0") = (long)(arg1);               \
        register long __g1 __asm__ ("g1") = __NR_##name;                \
-       __asm __volatile (__SYSCALL_STRING : "=r" (__g1), "=r" (__o0) : \
+       __asm __volatile (string : "=r" (__g1), "=r" (__o0) :           \
                          "0" (__g1), "1" (__o0) :                      \
                          __SYSCALL_CLOBBERS);                          \
        __o0;                                                           \
 })
 
-#define inline_syscall2(name,arg1,arg2)                                        \
+#define inline_syscall2(string,name,arg1,arg2)                         \
 ({                                                                     \
        register long __o0 __asm__ ("o0") = (long)(arg1);               \
        register long __o1 __asm__ ("o1") = (long)(arg2);               \
        register long __g1 __asm__ ("g1") = __NR_##name;                \
-       __asm __volatile (__SYSCALL_STRING : "=r" (__g1), "=r" (__o0) : \
+       __asm __volatile (string : "=r" (__g1), "=r" (__o0) :           \
                          "0" (__g1), "1" (__o0), "r" (__o1) :          \
                          __SYSCALL_CLOBBERS);                          \
        __o0;                                                           \
 })
 
-#define inline_syscall3(name,arg1,arg2,arg3)                           \
+#define inline_syscall3(string,name,arg1,arg2,arg3)                    \
 ({                                                                     \
        register long __o0 __asm__ ("o0") = (long)(arg1);               \
        register long __o1 __asm__ ("o1") = (long)(arg2);               \
        register long __o2 __asm__ ("o2") = (long)(arg3);               \
        register long __g1 __asm__ ("g1") = __NR_##name;                \
-       __asm __volatile (__SYSCALL_STRING : "=r" (__g1), "=r" (__o0) : \
+       __asm __volatile (string : "=r" (__g1), "=r" (__o0) :           \
                          "0" (__g1), "1" (__o0), "r" (__o1),           \
                          "r" (__o2) :                                  \
                          __SYSCALL_CLOBBERS);                          \
        __o0;                                                           \
 })
 
-#define inline_syscall4(name,arg1,arg2,arg3,arg4)                      \
+#define inline_syscall4(string,name,arg1,arg2,arg3,arg4)               \
 ({                                                                     \
        register long __o0 __asm__ ("o0") = (long)(arg1);               \
        register long __o1 __asm__ ("o1") = (long)(arg2);               \
        register long __o2 __asm__ ("o2") = (long)(arg3);               \
        register long __o3 __asm__ ("o3") = (long)(arg4);               \
        register long __g1 __asm__ ("g1") = __NR_##name;                \
-       __asm __volatile (__SYSCALL_STRING : "=r" (__g1), "=r" (__o0) : \
+       __asm __volatile (string : "=r" (__g1), "=r" (__o0) :           \
                          "0" (__g1), "1" (__o0), "r" (__o1),           \
                          "r" (__o2), "r" (__o3) :                      \
                          __SYSCALL_CLOBBERS);                          \
        __o0;                                                           \
 })
 
-#define inline_syscall5(name,arg1,arg2,arg3,arg4,arg5)                 \
+#define inline_syscall5(string,name,arg1,arg2,arg3,arg4,arg5)          \
 ({                                                                     \
        register long __o0 __asm__ ("o0") = (long)(arg1);               \
        register long __o1 __asm__ ("o1") = (long)(arg2);               \
        register long __o3 __asm__ ("o3") = (long)(arg4);               \
        register long __o4 __asm__ ("o4") = (long)(arg5);               \
        register long __g1 __asm__ ("g1") = __NR_##name;                \
-       __asm __volatile (__SYSCALL_STRING : "=r" (__g1), "=r" (__o0) : \
+       __asm __volatile (string : "=r" (__g1), "=r" (__o0) :           \
                          "0" (__g1), "1" (__o0), "r" (__o1),           \
                          "r" (__o2), "r" (__o3), "r" (__o4) :          \
                          __SYSCALL_CLOBBERS);                          \
        __o0;                                                           \
 })
 
-#define inline_syscall6(name,arg1,arg2,arg3,arg4,arg5,arg6)            \
+#define inline_syscall6(string,name,arg1,arg2,arg3,arg4,arg5,arg6)     \
 ({                                                                     \
        register long __o0 __asm__ ("o0") = (long)(arg1);               \
        register long __o1 __asm__ ("o1") = (long)(arg2);               \
        register long __o4 __asm__ ("o4") = (long)(arg5);               \
        register long __o5 __asm__ ("o5") = (long)(arg6);               \
        register long __g1 __asm__ ("g1") = __NR_##name;                \
-       __asm __volatile (__SYSCALL_STRING : "=r" (__g1), "=r" (__o0) : \
+       __asm __volatile (string : "=r" (__g1), "=r" (__o0) :           \
                          "0" (__g1), "1" (__o0), "r" (__o1),           \
                          "r" (__o2), "r" (__o3), "r" (__o4),           \
                          "r" (__o5) :                                  \
index 2da4d41..5c4c708 100644 (file)
 #undef INLINE_SYSCALL
 #define INLINE_SYSCALL(name, nr, args...) \
   ({                                                                         \
+    unsigned long resultvar = INTERNAL_SYSCALL (name, nr, args);             \
+    if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (resultvar), 0))          \
+      {                                                                              \
+       __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar));                     \
+       resultvar = (unsigned long) -1;                                       \
+      }                                                                              \
+    (long) resultvar; })
+
+#undef INTERNAL_SYSCALL
+#define INTERNAL_SYSCALL(name, nr, args...) \
+  ({                                                                         \
     unsigned long resultvar;                                                 \
     LOAD_ARGS_##nr (args)                                                    \
     asm volatile (                                                           \
     "syscall\n\t"                                                            \
     : "=a" (resultvar)                                                       \
     : "i" (__NR_##name) ASM_ARGS_##nr : "memory", "cc", "r11", "cx");        \
-    if (resultvar >= (unsigned long) -4095)                                  \
-      {                                                                              \
-       __set_errno (-resultvar);                                             \
-       resultvar = (unsigned long) -1;                                       \
-      }                                                                              \
     (long) resultvar; })
 
+#undef INTERNAL_SYSCALL_ERROR_P
+#define INTERNAL_SYSCALL_ERROR_P(val)  ((unsigned long) (val) >= -4095L)
+
+#undef INTERNAL_SYSCALL_ERRNO
+#define INTERNAL_SYSCALL_ERRNO(val)    (-(val))
+
 #define LOAD_ARGS_0()
 #define ASM_ARGS_0