[glibc] linux: Consolidate INLINE_SYSCALL
Adhemerval Zanella
azanella@sourceware.org
Sat Feb 15 00:18:00 GMT 2020
https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=fcb78a55058fd4e3477d9e4c6a5083d650aefa31
commit fcb78a55058fd4e3477d9e4c6a5083d650aefa31
Author: Adhemerval Zanella <adhemerval.zanella@linaro.org>
Date: Wed Jan 29 17:36:58 2020 +0000
linux: Consolidate INLINE_SYSCALL
With all Linux ABIs using the expected Linux kABI to indicate
syscalls errors, there is no need to replicate the INLINE_SYSCALL.
The generic Linux sysdep.h includes errno.h even for !__ASSEMBLER__,
which is ok now and it allows cleanup some archaic code that assume
otherwise.
Checked with a build against all affected ABIs.
Diff:
---
sysdeps/i386/pthread_spin_trylock.S | 2 +-
sysdeps/mips/nptl/tls.h | 2 +-
sysdeps/sh/nptl/pthread_spin_trylock.S | 2 +-
sysdeps/sparc/sparc32/pthread_spin_trylock.S | 2 +-
sysdeps/sparc/sparc64/pthread_spin_trylock.S | 2 +-
sysdeps/unix/arm/sysdep.S | 3 +-
sysdeps/unix/mips/sysdep.S | 3 +-
sysdeps/unix/sh/sysdep.S | 3 +-
sysdeps/unix/sysv/linux/aarch64/sysdep.h | 22 ---------------
sysdeps/unix/sysv/linux/alpha/brk.S | 3 +-
sysdeps/unix/sysv/linux/alpha/sysdep.h | 25 +----------------
sysdeps/unix/sysv/linux/arm/sysdep.h | 27 ------------------
sysdeps/unix/sysv/linux/csky/sysdep.h | 22 ---------------
sysdeps/unix/sysv/linux/hppa/sysdep.h | 30 --------------------
sysdeps/unix/sysv/linux/i386/sysdep.h | 40 +--------------------------
sysdeps/unix/sysv/linux/ia64/sysdep.h | 21 +-------------
sysdeps/unix/sysv/linux/m68k/sysdep.h | 23 +--------------
sysdeps/unix/sysv/linux/microblaze/sysdep.h | 25 +----------------
sysdeps/unix/sysv/linux/mips/mips32/sysdep.h | 29 +------------------
sysdeps/unix/sysv/linux/mips/mips64/sysdep.h | 29 +------------------
sysdeps/unix/sysv/linux/nios2/sysdep.h | 24 +---------------
sysdeps/unix/sysv/linux/powerpc/sysdep.h | 30 --------------------
sysdeps/unix/sysv/linux/riscv/sysdep.h | 20 --------------
sysdeps/unix/sysv/linux/s390/s390-32/sysdep.h | 6 +---
sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h | 6 +---
sysdeps/unix/sysv/linux/s390/sysdep.h | 21 --------------
sysdeps/unix/sysv/linux/sh/sysdep.h | 21 --------------
sysdeps/unix/sysv/linux/sparc/sparc64/brk.S | 3 +-
sysdeps/unix/sysv/linux/sparc/sysdep.h | 22 ---------------
sysdeps/unix/sysv/linux/sysdep.h | 37 +++++++++++++++++++++++++
sysdeps/unix/sysv/linux/x86_64/sysdep.h | 36 +-----------------------
sysdeps/unix/x86_64/sysdep.S | 3 +-
sysdeps/x86_64/nptl/pthread_spin_trylock.S | 2 +-
33 files changed, 60 insertions(+), 486 deletions(-)
diff --git a/sysdeps/i386/pthread_spin_trylock.S b/sysdeps/i386/pthread_spin_trylock.S
index 949879c..8edb676 100644
--- a/sysdeps/i386/pthread_spin_trylock.S
+++ b/sysdeps/i386/pthread_spin_trylock.S
@@ -17,7 +17,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#include <pthread-errnos.h>
+#include <errno.h>
#ifdef UP
diff --git a/sysdeps/mips/nptl/tls.h b/sysdeps/mips/nptl/tls.h
index ba0efe8..ae85984 100644
--- a/sysdeps/mips/nptl/tls.h
+++ b/sysdeps/mips/nptl/tls.h
@@ -35,7 +35,7 @@
# define READ_THREAD_POINTER() (__builtin_thread_pointer ())
#else
/* Note: rd must be $v1 to be ABI-conformant. */
-# if __mips_isa_rev >= 2
+# if defined (__mips_isa_rev) && __mips_isa_rev >= 2
# define READ_THREAD_POINTER() \
({ void *__result; \
asm volatile ("rdhwr\t%0, $29" : "=v" (__result)); \
diff --git a/sysdeps/sh/nptl/pthread_spin_trylock.S b/sysdeps/sh/nptl/pthread_spin_trylock.S
index c8c453c..142908c 100644
--- a/sysdeps/sh/nptl/pthread_spin_trylock.S
+++ b/sysdeps/sh/nptl/pthread_spin_trylock.S
@@ -15,7 +15,7 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
-#include <pthread-errnos.h>
+#include <errno.h>
.globl pthread_spin_trylock
.type pthread_spin_trylock,@function
diff --git a/sysdeps/sparc/sparc32/pthread_spin_trylock.S b/sysdeps/sparc/sparc32/pthread_spin_trylock.S
index bd31fad..4b992e7 100644
--- a/sysdeps/sparc/sparc32/pthread_spin_trylock.S
+++ b/sysdeps/sparc/sparc32/pthread_spin_trylock.S
@@ -16,7 +16,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#include <pthread-errnos.h>
+#include <errno.h>
.text
ENTRY(pthread_spin_trylock)
diff --git a/sysdeps/sparc/sparc64/pthread_spin_trylock.S b/sysdeps/sparc/sparc64/pthread_spin_trylock.S
index fd33946..b6cfa52 100644
--- a/sysdeps/sparc/sparc64/pthread_spin_trylock.S
+++ b/sysdeps/sparc/sparc64/pthread_spin_trylock.S
@@ -16,7 +16,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#include <pthread-errnos.h>
+#include <errno.h>
.text
ENTRY(pthread_spin_trylock)
diff --git a/sysdeps/unix/arm/sysdep.S b/sysdeps/unix/arm/sysdep.S
index 514937b..5c9022a 100644
--- a/sysdeps/unix/arm/sysdep.S
+++ b/sysdeps/unix/arm/sysdep.S
@@ -16,8 +16,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
#if IS_IN (rtld)
# include <dl-sysdep.h> /* Defines RTLD_PRIVATE_ERRNO. */
diff --git a/sysdeps/unix/mips/sysdep.S b/sysdeps/unix/mips/sysdep.S
index fca1091..744d162 100644
--- a/sysdeps/unix/mips/sysdep.S
+++ b/sysdeps/unix/mips/sysdep.S
@@ -17,8 +17,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
#include <sys/asm.h>
.set nomips16
diff --git a/sysdeps/unix/sh/sysdep.S b/sysdeps/unix/sh/sysdep.S
index 7facc02..dc9a230 100644
--- a/sysdeps/unix/sh/sysdep.S
+++ b/sysdeps/unix/sh/sysdep.S
@@ -16,8 +16,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
ENTRY(__syscall_error)
#if defined (EWOULDBLOCK_sys) && EWOULDBLOCK_sys != EAGAIN
diff --git a/sysdeps/unix/sysv/linux/aarch64/sysdep.h b/sysdeps/unix/sysv/linux/aarch64/sysdep.h
index 00b8e24..79fa0bd 100644
--- a/sysdeps/unix/sysv/linux/aarch64/sysdep.h
+++ b/sysdeps/unix/sysv/linux/aarch64/sysdep.h
@@ -170,21 +170,6 @@
# define SINGLE_THREAD_BY_GLOBAL 1
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ unsigned long _sys_result = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_sys_result, ), 0))\
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sys_result, )); \
- _sys_result = (unsigned long) -1; \
- } \
- (long) _sys_result; })
-
-# undef INTERNAL_SYSCALL_DECL
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
# undef INTERNAL_SYSCALL_RAW
# define INTERNAL_SYSCALL_RAW(name, err, nr, args...) \
({ long _sys_result; \
@@ -205,13 +190,6 @@
# define INTERNAL_SYSCALL_AARCH64(name, err, nr, args...) \
INTERNAL_SYSCALL_RAW(__ARM_NR_##name, err, nr, args)
-# undef INTERNAL_SYSCALL_ERROR_P
-# define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) >= (unsigned long) -4095)
-
-# undef INTERNAL_SYSCALL_ERRNO
-# define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
# define LOAD_ARGS_0() \
register long _x0 asm ("x0");
# define LOAD_ARGS_1(x0) \
diff --git a/sysdeps/unix/sysv/linux/alpha/brk.S b/sysdeps/unix/sysv/linux/alpha/brk.S
index 45ecbbe..5596b34 100644
--- a/sysdeps/unix/sysv/linux/alpha/brk.S
+++ b/sysdeps/unix/sysv/linux/alpha/brk.S
@@ -21,8 +21,7 @@
break value (instead of the new, requested one). */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
#ifdef PIC
.section .bss
diff --git a/sysdeps/unix/sysv/linux/alpha/sysdep.h b/sysdeps/unix/sysv/linux/alpha/sysdep.h
index 218e207..f5bcd85 100644
--- a/sysdeps/unix/sysv/linux/alpha/sysdep.h
+++ b/sysdeps/unix/sysv/linux/alpha/sysdep.h
@@ -92,6 +92,7 @@
# define USEPV_PROF no
#endif
+#undef SYSCALL_ERROR_LABEL
#if RTLD_PRIVATE_ERRNO
# define SYSCALL_ERROR_LABEL $syscall_error
# define SYSCALL_ERROR_HANDLER \
@@ -169,42 +170,18 @@ __LABEL(name) \
#else /* !ASSEMBLER */
-/* In order to get __set_errno() definition in INLINE_SYSCALL. */
-#include <errno.h>
-
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
-({ \
- INTERNAL_SYSCALL_DECL (_sc_err); \
- long int _sc_ret = INTERNAL_SYSCALL (name, sc_err, nr, args); \
- if (INTERNAL_SYSCALL_ERROR_P (_sc_ret, _sc_err)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sc_ret, _sc_err)); \
- _sc_ret = -1L; \
- } \
- _sc_ret; \
-})
-
#define INTERNAL_SYSCALL(name, err_out, nr, args...) \
internal_syscall##nr(__NR_##name, args)
#define INTERNAL_SYSCALL_NCS(name, err_out, nr, args...) \
internal_syscall##nr(name, args)
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
/* The normal Alpha calling convention sign-extends 32-bit quantties
no matter what the "real" sign of the 32-bit type. We want to
preserve that when filling in values for the kernel. */
#define syscall_promote(arg) \
(sizeof (arg) == 4 ? (long int)(int)(long int)(arg) : (long int)(arg))
-/* Make sure and "use" the variable that we're not returning,
- in order to suppress unused variable warnings. */
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) > -4096UL)
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define internal_syscall_clobbers \
"$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", \
"$22", "$23", "$24", "$25", "$27", "$28", "memory"
diff --git a/sysdeps/unix/sysv/linux/arm/sysdep.h b/sysdeps/unix/sysv/linux/arm/sysdep.h
index 0c5f498..f6e6b63 100644
--- a/sysdeps/unix/sysv/linux/arm/sysdep.h
+++ b/sysdeps/unix/sysv/linux/arm/sysdep.h
@@ -29,11 +29,6 @@
#include <tls.h>
-/* In order to get __set_errno() definition in INLINE_SYSCALL. */
-#ifndef __ASSEMBLER__
-#include <errno.h>
-#endif
-
/* For Linux we can use the system call table in the header file
/usr/include/asm/unistd.h
of the kernel. But these symbols do not follow the SYS_* syntax
@@ -317,21 +312,6 @@ __local_syscall_error: \
#else /* not __ASSEMBLER__ */
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ unsigned int _sys_result = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_sys_result, ), 0)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sys_result, )); \
- _sys_result = (unsigned int) -1; \
- } \
- (int) _sys_result; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
#if defined(__thumb__)
/* We can not expose the use of r7 to the compiler. GCC (as
of 4.5) uses r7 as the hard frame pointer for Thumb - although
@@ -377,13 +357,6 @@ __local_syscall_error: \
#define INTERNAL_SYSCALL(name, err, nr, args...) \
INTERNAL_SYSCALL_RAW(SYS_ify(name), err, nr, args)
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= 0xfffff001u)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define VDSO_NAME "LINUX_2.6"
#define VDSO_HASH 61765110
diff --git a/sysdeps/unix/sysv/linux/csky/sysdep.h b/sysdeps/unix/sysv/linux/csky/sysdep.h
index fa1dbd6..7ebb19d 100644
--- a/sysdeps/unix/sysv/linux/csky/sysdep.h
+++ b/sysdeps/unix/sysv/linux/csky/sysdep.h
@@ -293,28 +293,6 @@ __local_syscall_error: \
#else /* not __ASSEMBLER__ */
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ unsigned int _sys_result = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_sys_result,), 0)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sys_result, )); \
- _sys_result = (unsigned int) -1; \
- } \
- (int) _sys_result; })
-
-# undef INTERNAL_SYSCALL_DECL
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-# undef INTERNAL_SYSCALL_ERROR_P
-# define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= 0xffffff01u)
-
-# undef INTERNAL_SYSCALL_ERRNO
-# define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
# undef INTERNAL_SYSCALL_RAW
# define INTERNAL_SYSCALL_RAW0(name, err, dummy...) \
({unsigned int __sys_result; \
diff --git a/sysdeps/unix/sysv/linux/hppa/sysdep.h b/sysdeps/unix/sysv/linux/hppa/sysdep.h
index 6c34189..88e368d 100644
--- a/sysdeps/unix/sysv/linux/hppa/sysdep.h
+++ b/sysdeps/unix/sysv/linux/hppa/sysdep.h
@@ -360,36 +360,6 @@ L(pre_end): ASM_LINE_SEP \
#define CALL_CLOB_REGS "%r1", "%r2", CLOB_TREG \
"%r20", "%r29", "%r31"
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
-({ \
- long __sys_res = INTERNAL_SYSCALL (name, , nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (__sys_res, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (__sys_res, )); \
- __sys_res = -1; \
- } \
- __sys_res; \
-})
-
-/* INTERNAL_SYSCALL_DECL - Allows us to setup some function static
- value to use within the context of the syscall
- INTERNAL_SYSCALL_ERROR_P - Returns 0 if it wasn't an error, 1 otherwise
- You are allowed to use the syscall result (val) and the DECL error
- variable to determine what went wrong.
- INTERLAL_SYSCALL_ERRNO - Munges the val/err pair into the error number.
- In our case we just flip the sign. */
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((val < 0) && (val > -4095))
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
/* Similar to INLINE_SYSCALL but we don't set errno */
#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL(name, err, nr, args...) \
diff --git a/sysdeps/unix/sysv/linux/i386/sysdep.h b/sysdeps/unix/sysv/linux/i386/sysdep.h
index 420b6a7..2387a4a 100644
--- a/sysdeps/unix/sysv/linux/i386/sysdep.h
+++ b/sysdeps/unix/sysv/linux/i386/sysdep.h
@@ -67,6 +67,7 @@
/* We don't want the label for the error handle to be global when we define
it here. */
+#undef SYSCALL_ERROR_LABEL
#define SYSCALL_ERROR_LABEL __syscall_error
#undef PSEUDO
@@ -280,35 +281,6 @@ struct libc_do_syscall_args
};
#endif
-/* Define a macro which expands inline into the wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#if IS_IN (libc)
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- unsigned int resultvar = INTERNAL_SYSCALL (name, , nr, args); \
- __glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, )) \
- ? __syscall_error (-INTERNAL_SYSCALL_ERRNO (resultvar, )) \
- : (int) resultvar; })
-#else
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- unsigned int resultvar = INTERNAL_SYSCALL (name, , nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, )); \
- resultvar = 0xffffffff; \
- } \
- (int) resultvar; })
-#endif
-
-/* Set error number and return -1. Return the internal function,
- __syscall_error, which sets errno from the negative error number
- and returns -1, to avoid PIC. */
-#undef INLINE_SYSCALL_ERROR_RETURN_VALUE
-#define INLINE_SYSCALL_ERROR_RETURN_VALUE(resultvar) \
- __syscall_error (-(resultvar))
-
# define VDSO_NAME "LINUX_2.6"
# define VDSO_HASH 61765110
@@ -490,16 +462,6 @@ struct libc_do_syscall_args
# endif /* GCC 5 */
#endif
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= 0xfffff001u)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define LOADARGS_0
#ifdef __PIC__
# if I386_USE_SYSENTER && defined PIC
diff --git a/sysdeps/unix/sysv/linux/ia64/sysdep.h b/sysdeps/unix/sysv/linux/ia64/sysdep.h
index dc122a8..8b2ff9c 100644
--- a/sysdeps/unix/sysv/linux/ia64/sysdep.h
+++ b/sysdeps/unix/sysv/linux/ia64/sysdep.h
@@ -95,6 +95,7 @@
/* We don't want the label for the error handler to be visible in the symbol
table when we define it here. */
+#undef SYSCALL_ERROR_LABEL
#define SYSCALL_ERROR_LABEL __syscall_error
#undef PSEUDO
@@ -231,29 +232,9 @@
#endif /* !IA64_USE_NEW_STUB */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ unsigned long _sys_result = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_sys_result, ), 0))\
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sys_result, )); \
- _sys_result = (unsigned long) -1; \
- } \
- (long) _sys_result; })
-
-# undef INTERNAL_SYSCALL_DECL
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
#define INTERNAL_SYSCALL(name, err, nr, args...) \
INTERNAL_SYSCALL_NCS (__NR_##name, err, nr, ##args)
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (val) > -4096UL)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define LOAD_ARGS_0()
#define LOAD_REGS_0
#define LOAD_ARGS_1(a1) \
diff --git a/sysdeps/unix/sysv/linux/m68k/sysdep.h b/sysdeps/unix/sysv/linux/m68k/sysdep.h
index 5cd35ff..e3d87be 100644
--- a/sysdeps/unix/sysv/linux/m68k/sysdep.h
+++ b/sysdeps/unix/sysv/linux/m68k/sysdep.h
@@ -44,6 +44,7 @@
/* We don't want the label for the error handler to be visible in the symbol
table when we define it here. */
+#undef SYSCALL_ERROR_LABEL
#ifdef PIC
#define SYSCALL_ERROR_LABEL .Lsyscall_error
#else
@@ -221,21 +222,6 @@ SYSCALL_ERROR_LABEL: \
#else /* not __ASSEMBLER__ */
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ unsigned int _sys_result = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_sys_result, ), 0))\
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sys_result, )); \
- _sys_result = (unsigned int) -1; \
- } \
- (int) _sys_result; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
/* Define a macro which expands inline into the wrapper code for a system
call. This use is for internal calls that do not need to handle errors
normally. It will never touch errno. This returns just what the kernel
@@ -260,13 +246,6 @@ SYSCALL_ERROR_LABEL: \
#define INTERNAL_SYSCALL(name, err, nr, args...) \
INTERNAL_SYSCALL_NCS (__NR_##name, err, nr, ##args)
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= -4095U)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define LOAD_ARGS_0()
#define LOAD_REGS_0
#define ASM_ARGS_0
diff --git a/sysdeps/unix/sysv/linux/microblaze/sysdep.h b/sysdeps/unix/sysv/linux/microblaze/sysdep.h
index 796663a..8f9355f 100644
--- a/sysdeps/unix/sysv/linux/microblaze/sysdep.h
+++ b/sysdeps/unix/sysv/linux/microblaze/sysdep.h
@@ -60,6 +60,7 @@
/* We don't want the label for the error handler to be visible in the symbol
table when we define it here. */
+# undef SYSCALL_ERROR_LABEL
# ifdef PIC
# define SYSCALL_ERROR_LABEL 0f
# else
@@ -163,23 +164,6 @@ SYSCALL_ERROR_LABEL_DCL: \
#else /* not __ASSEMBLER__ */
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
-({ INTERNAL_SYSCALL_DECL(err); \
- unsigned long resultvar = INTERNAL_SYSCALL(name, err, nr, args); \
- if (INTERNAL_SYSCALL_ERROR_P (resultvar, err)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, err)); \
- resultvar = (unsigned long) -1; \
- } \
- (long) resultvar; \
-})
-
-# undef INTERNAL_SYSCALL_DECL
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
/* Define a macro which expands inline into the wrapper code for a system
call. This use is for internal calls that do not need to handle errors
normally. It will never touch errno. This returns just what the kernel
@@ -192,13 +176,6 @@ SYSCALL_ERROR_LABEL_DCL: \
# define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
inline_syscall##nr(name, args)
-# undef INTERNAL_SYSCALL_ERROR_P
-# define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= -4095U)
-
-# undef INTERNAL_SYSCALL_ERRNO
-# define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
# define SYSCALL_CLOBBERS_6 "r11", "r4", "memory"
# define SYSCALL_CLOBBERS_5 "r10", SYSCALL_CLOBBERS_6
# define SYSCALL_CLOBBERS_4 "r9", SYSCALL_CLOBBERS_5
diff --git a/sysdeps/unix/sysv/linux/mips/mips32/sysdep.h b/sysdeps/unix/sysv/linux/mips/mips32/sysdep.h
index 78534a5..7c04819 100644
--- a/sysdeps/unix/sysv/linux/mips/mips32/sysdep.h
+++ b/sysdeps/unix/sysv/linux/mips/mips32/sysdep.h
@@ -25,11 +25,6 @@
#include <tls.h>
-/* In order to get __set_errno() definition in INLINE_SYSCALL. */
-#ifndef __ASSEMBLER__
-#include <errno.h>
-#endif
-
/* For Linux we can use the system call table in the header file
/usr/include/asm/unistd.h
of the kernel. But these symbols do not follow the SYS_* syntax
@@ -42,34 +37,12 @@
/* We don't want the label for the error handler to be visible in the symbol
table when we define it here. */
#ifdef __PIC__
+# undef SYSCALL_ERROR_LABEL
# define SYSCALL_ERROR_LABEL 99b
#endif
#else /* ! __ASSEMBLER__ */
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ INTERNAL_SYSCALL_DECL (_sc_err); \
- long int result_var = INTERNAL_SYSCALL (name, _sc_err, nr, args); \
- if ( INTERNAL_SYSCALL_ERROR_P (result_var, _sc_err) ) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (result_var, _sc_err)); \
- result_var = -1L; \
- } \
- result_var; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (val) > -4096UL)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
/* Note that the original Linux syscall restart convention required the
instruction immediately preceding SYSCALL to initialize $v0 with the
syscall number. Then if a restart triggered, $v0 would have been
diff --git a/sysdeps/unix/sysv/linux/mips/mips64/sysdep.h b/sysdeps/unix/sysv/linux/mips/mips64/sysdep.h
index 2c8ddcf..112d940 100644
--- a/sysdeps/unix/sysv/linux/mips/mips64/sysdep.h
+++ b/sysdeps/unix/sysv/linux/mips/mips64/sysdep.h
@@ -25,11 +25,6 @@
#include <tls.h>
-/* In order to get __set_errno() definition in INLINE_SYSCALL. */
-#ifndef __ASSEMBLER__
-#include <errno.h>
-#endif
-
/* For Linux we can use the system call table in the header file
/usr/include/asm/unistd.h
of the kernel. But these symbols do not follow the SYS_* syntax
@@ -41,6 +36,7 @@
/* We don't want the label for the error handler to be visible in the symbol
table when we define it here. */
+# undef SYSCALL_ERROR_LABEL
# define SYSCALL_ERROR_LABEL 99b
#else /* ! __ASSEMBLER__ */
@@ -55,29 +51,6 @@ typedef long long int __syscall_arg_t;
typedef long int __syscall_arg_t;
#endif
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ INTERNAL_SYSCALL_DECL (_sc_err); \
- long int result_var = INTERNAL_SYSCALL (name, _sc_err, nr, args); \
- if ( INTERNAL_SYSCALL_ERROR_P (result_var, _sc_err) ) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (result_var, _sc_err)); \
- result_var = -1L; \
- } \
- result_var; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (val) > -4096UL)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
/* Note that the original Linux syscall restart convention required the
instruction immediately preceding SYSCALL to initialize $v0 with the
syscall number. Then if a restart triggered, $v0 would have been
diff --git a/sysdeps/unix/sysv/linux/nios2/sysdep.h b/sysdeps/unix/sysv/linux/nios2/sysdep.h
index ae2f2a5..45ef817 100644
--- a/sysdeps/unix/sysv/linux/nios2/sysdep.h
+++ b/sysdeps/unix/sysv/linux/nios2/sysdep.h
@@ -37,6 +37,7 @@
#ifdef __ASSEMBLER__
+#undef SYSCALL_ERROR_LABEL
#define SYSCALL_ERROR_LABEL __local_syscall_error
#undef PSEUDO
@@ -143,29 +144,6 @@
which lead in a non existent __send symbol in libc.so. */
# undef HAVE_INTERNAL_SEND_SYMBOL
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ INTERNAL_SYSCALL_DECL(err); \
- unsigned int result_var = INTERNAL_SYSCALL (name, err, nr, args); \
- if ( INTERNAL_SYSCALL_ERROR_P (result_var, err) ) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (result_var, err)); \
- result_var = -1L; \
- } \
- (int) result_var; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (val) > -4096UL)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#undef INTERNAL_SYSCALL_RAW
#define INTERNAL_SYSCALL_RAW(name, err, nr, args...) \
({ unsigned int _sys_result; \
diff --git a/sysdeps/unix/sysv/linux/powerpc/sysdep.h b/sysdeps/unix/sysv/linux/powerpc/sysdep.h
index aab4901..9442839 100644
--- a/sysdeps/unix/sysv/linux/powerpc/sysdep.h
+++ b/sysdeps/unix/sysv/linux/powerpc/sysdep.h
@@ -64,26 +64,6 @@
#define INTERNAL_VSYSCALL_CALL(funcptr, err, nr, args...) \
INTERNAL_VSYSCALL_CALL_TYPE(funcptr, err, long int, nr, args)
-/* This version is for kernels that implement system calls that
- behave like function calls as far as register saving. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- INTERNAL_SYSCALL_DECL (sc_err); \
- long int sc_ret = INTERNAL_SYSCALL (name, sc_err, nr, args); \
- if (INTERNAL_SYSCALL_ERROR_P (sc_ret, sc_err)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (sc_ret, sc_err)); \
- sc_ret = -1L; \
- } \
- sc_ret; \
- })
-
-/* Define a macro which expands inline into the wrapper code for a system
- call. This use is for internal calls that do not need to handle errors
- normally. It will never touch errno. This returns just what the kernel
- gave back in the non-error (CR0.SO cleared) case, otherwise (CR0.SO set)
- the negation of the return value in the kernel gets reverted. */
#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
@@ -111,16 +91,6 @@
#define INTERNAL_SYSCALL(name, err, nr, args...) \
INTERNAL_SYSCALL_NCS (__NR_##name, err, nr, args)
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (val) > -4096UL)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#if defined(__PPC64__) || defined(__powerpc64__)
# define SYSCALL_ARG_SIZE 8
#else
diff --git a/sysdeps/unix/sysv/linux/riscv/sysdep.h b/sysdeps/unix/sysv/linux/riscv/sysdep.h
index 2bd9b16..e46160f 100644
--- a/sysdeps/unix/sysv/linux/riscv/sysdep.h
+++ b/sysdeps/unix/sysv/linux/riscv/sysdep.h
@@ -130,26 +130,6 @@
# define HAVE_GETTIMEOFDAY_VSYSCALL "__vdso_gettimeofday"
# define HAVE_GETCPU_VSYSCALL "__vdso_getcpu"
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ INTERNAL_SYSCALL_DECL (err); \
- long int __sys_result = INTERNAL_SYSCALL (name, err, nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (__sys_result, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (__sys_result, )); \
- __sys_result = (unsigned long) -1; \
- } \
- __sys_result; })
-
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-# define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (val) > -4096UL)
-
-# define INTERNAL_SYSCALL_ERRNO(val, err) (-val)
-
# define INTERNAL_SYSCALL(name, err, nr, args...) \
internal_syscall##nr (SYS_ify (name), err, args)
diff --git a/sysdeps/unix/sysv/linux/s390/s390-32/sysdep.h b/sysdeps/unix/sysv/linux/s390/s390-32/sysdep.h
index 520c935..98e5ba0 100644
--- a/sysdeps/unix/sysv/linux/s390/s390-32/sysdep.h
+++ b/sysdeps/unix/sysv/linux/s390/s390-32/sysdep.h
@@ -26,11 +26,6 @@
#include <dl-sysdep.h> /* For RTLD_PRIVATE_ERRNO. */
#include <tls.h>
-/* Define __set_errno() for INLINE_SYSCALL macro below. */
-#ifndef __ASSEMBLER__
-#include <errno.h>
-#endif
-
/* For Linux we can use the system call table in the header file
/usr/include/asm/unistd.h
of the kernel. But these symbols do not follow the SYS_* syntax
@@ -85,6 +80,7 @@
#define PSEUDO_END_ERRVAL(name) \
END (name)
+#undef SYSCALL_ERROR_LABEL
#ifndef PIC
# define SYSCALL_ERROR_LABEL 0f
# define SYSCALL_ERROR_HANDLER \
diff --git a/sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h b/sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h
index 6230591..2a4874c 100644
--- a/sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h
+++ b/sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h
@@ -27,11 +27,6 @@
#include <dl-sysdep.h> /* For RTLD_PRIVATE_ERRNO. */
#include <tls.h>
-/* Define __set_errno() for INLINE_SYSCALL macro below. */
-#ifndef __ASSEMBLER__
-#include <errno.h>
-#endif
-
/* For Linux we can use the system call table in the header file
/usr/include/asm/unistd.h
of the kernel. But these symbols do not follow the SYS_* syntax
@@ -99,6 +94,7 @@
SYSCALL_ERROR_HANDLER; \
END (name)
+#undef SYSCALL_ERROR_LABEL
#ifndef PIC
# define SYSCALL_ERROR_LABEL syscall_error
# define SYSCALL_ERROR_HANDLER
diff --git a/sysdeps/unix/sysv/linux/s390/sysdep.h b/sysdeps/unix/sysv/linux/s390/sysdep.h
index 7731d2e..e0e25c9 100644
--- a/sysdeps/unix/sysv/linux/s390/sysdep.h
+++ b/sysdeps/unix/sysv/linux/s390/sysdep.h
@@ -21,20 +21,6 @@
#undef SYS_ify
#define SYS_ify(syscall_name) __NR_##syscall_name
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- long int _ret = INTERNAL_SYSCALL (name, , nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (_ret, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_ret, )); \
- _ret = -1; \
- } \
- _ret; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
#undef INTERNAL_SYSCALL_DIRECT
#define INTERNAL_SYSCALL_DIRECT(name, err, nr, args...) \
({ \
@@ -80,13 +66,6 @@
? INTERNAL_SYSCALL_DIRECT(name, nr, args) \
: INTERNAL_SYSCALL_SVC0(name, nr, args))
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (val) > -4096UL)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define DECLARGS_0()
#define DECLARGS_1(arg1) \
register unsigned long int gpr2 __asm__ ("2") = (unsigned long int)(arg1);
diff --git a/sysdeps/unix/sysv/linux/sh/sysdep.h b/sysdeps/unix/sysv/linux/sh/sysdep.h
index 703b042..c0e52af 100644
--- a/sysdeps/unix/sysv/linux/sh/sysdep.h
+++ b/sysdeps/unix/sysv/linux/sh/sysdep.h
@@ -287,17 +287,6 @@
register long int r1 asm ("%r1") = (long int) (_arg6); \
register long int r2 asm ("%r2") = (long int) (_arg7)
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- unsigned int resultvar = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (resultvar, ), 0)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, )); \
- resultvar = 0xffffffff; \
- } \
- (int) resultvar; })
-
#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL(name, err, nr, args...) \
({ \
@@ -326,16 +315,6 @@
\
(int) resultvar; })
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= 0xfffff001u)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#endif /* __ASSEMBLER__ */
/* Pointer mangling support. */
diff --git a/sysdeps/unix/sysv/linux/sparc/sparc64/brk.S b/sysdeps/unix/sysv/linux/sparc/sparc64/brk.S
index 0bcd882..471da3d 100644
--- a/sysdeps/unix/sysv/linux/sparc/sparc64/brk.S
+++ b/sysdeps/unix/sysv/linux/sparc/sparc64/brk.S
@@ -21,8 +21,7 @@
break value (instead of the new, requested one). */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
#ifdef PIC
.section .bss
diff --git a/sysdeps/unix/sysv/linux/sparc/sysdep.h b/sysdeps/unix/sysv/linux/sparc/sysdep.h
index e43f2bd..b14e132 100644
--- a/sysdeps/unix/sysv/linux/sparc/sysdep.h
+++ b/sysdeps/unix/sysv/linux/sparc/sysdep.h
@@ -45,21 +45,6 @@
# endif
# define HAVE_GETTIMEOFDAY_VSYSCALL "__vdso_gettimeofday"
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
-({ INTERNAL_SYSCALL_DECL(err); \
- unsigned long resultvar = INTERNAL_SYSCALL(name, err, nr, args);\
- if (INTERNAL_SYSCALL_ERROR_P (resultvar, err)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, err)); \
- resultvar = (unsigned long) -1; \
- } \
- (long) resultvar; \
-})
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL(name, err, nr, args...) \
internal_syscall##nr(__SYSCALL_STRING, err, __NR_##name, args)
@@ -68,13 +53,6 @@
#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
internal_syscall##nr(__SYSCALL_STRING, err, name, args)
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (val) > -4096UL)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define internal_syscall0(string,err,name,dummy...) \
({ \
register long int __g1 __asm__ ("g1") = (name); \
diff --git a/sysdeps/unix/sysv/linux/sysdep.h b/sysdeps/unix/sysv/linux/sysdep.h
index c7f3e54..ca3d84f 100644
--- a/sysdeps/unix/sysv/linux/sysdep.h
+++ b/sysdeps/unix/sysv/linux/sysdep.h
@@ -15,8 +15,43 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
+#ifndef _SYSDEP_LINUX_H
+#define _SYSDEP_LINUX_H
+
#include <bits/wordsize.h>
#include <kernel-features.h>
+#include <errno.h>
+
+#undef INTERNAL_SYSCALL_DECL
+#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
+
+#undef INTERNAL_SYSCALL_ERROR_P
+#define INTERNAL_SYSCALL_ERROR_P(val, err) \
+ ((unsigned long int) (val) > -4096UL)
+
+#ifndef SYSCALL_ERROR_LABEL
+# define SYSCALL_ERROR_LABEL(sc_err) \
+ ({ \
+ __set_errno (sc_err); \
+ -1L; \
+ })
+#endif
+
+/* Define a macro which expands into the inline wrapper code for a system
+ call. It sets the errno and returns -1 on a failure, or the syscall
+ return value otherwise. */
+#undef INLINE_SYSCALL
+#define INLINE_SYSCALL(name, nr, args...) \
+ ({ \
+ INTERNAL_SYSCALL_DECL (sc_err); \
+ long int sc_ret = INTERNAL_SYSCALL (name, sc_err, nr, args); \
+ __glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (sc_ret, sc_err)) \
+ ? SYSCALL_ERROR_LABEL (INTERNAL_SYSCALL_ERRNO (sc_ret, sc_err)) \
+ : sc_ret; \
+ })
+
+#undef INTERNAL_SYSCALL_ERRNO
+#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
/* Set error number and return -1. A target may choose to return the
internal function, __syscall_error, which sets errno and returns -1.
@@ -66,3 +101,5 @@
/* Exports the __send symbol on send.c linux implementation (some ABI have
it missing due the usage of a old generic version without it). */
#define HAVE_INTERNAL_SEND_SYMBOL 1
+
+#endif /* _SYSDEP_LINUX_H */
diff --git a/sysdeps/unix/sysv/linux/x86_64/sysdep.h b/sysdeps/unix/sysv/linux/x86_64/sysdep.h
index c2eb37e..f641192 100644
--- a/sysdeps/unix/sysv/linux/x86_64/sysdep.h
+++ b/sysdeps/unix/sysv/linux/x86_64/sysdep.h
@@ -55,6 +55,7 @@
/* We don't want the label for the error handle to be global when we define
it here. */
+# undef SYSCALL_ERROR_LABEL
# ifdef PIC
# define SYSCALL_ERROR_LABEL 0f
# else
@@ -177,35 +178,6 @@
# define DOARGS_6 DOARGS_5
#else /* !__ASSEMBLER__ */
-/* Define a macro which expands inline into the wrapper code for a system
- call. */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- unsigned long int resultvar = INTERNAL_SYSCALL (name, , nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, )); \
- resultvar = (unsigned long int) -1; \
- } \
- (long int) resultvar; })
-
-/* Define a macro with explicit types for arguments, which expands inline
- into the wrapper code for a system call. It should be used when size
- of any argument > size of long int. */
-# undef INLINE_SYSCALL_TYPES
-# define INLINE_SYSCALL_TYPES(name, nr, args...) \
- ({ \
- unsigned long int resultvar = INTERNAL_SYSCALL_TYPES (name, , nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, )); \
- resultvar = (unsigned long int) -1; \
- } \
- (long int) resultvar; })
-
-# undef INTERNAL_SYSCALL_DECL
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
/* Registers clobbered by syscall. */
# define REGISTERS_CLOBBERED_BY_SYSCALL "cc", "r11", "cx"
@@ -353,12 +325,6 @@
(long int) resultvar; \
})
-# undef INTERNAL_SYSCALL_ERROR_P
-# define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (long int) (val) >= -4095L)
-
-# undef INTERNAL_SYSCALL_ERRNO
-# define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
# define VDSO_NAME "LINUX_2.6"
# define VDSO_HASH 61765110
diff --git a/sysdeps/unix/x86_64/sysdep.S b/sysdeps/unix/x86_64/sysdep.S
index f617627..2278fce 100644
--- a/sysdeps/unix/x86_64/sysdep.S
+++ b/sysdeps/unix/x86_64/sysdep.S
@@ -16,8 +16,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
#include <tls.h>
#if IS_IN (rtld)
diff --git a/sysdeps/x86_64/nptl/pthread_spin_trylock.S b/sysdeps/x86_64/nptl/pthread_spin_trylock.S
index 24981fe..c084577 100644
--- a/sysdeps/x86_64/nptl/pthread_spin_trylock.S
+++ b/sysdeps/x86_64/nptl/pthread_spin_trylock.S
@@ -16,8 +16,8 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
-#include <pthread-errnos.h>
#include <sysdep.h>
+#include <errno.h>
#ifdef UP
More information about the Glibc-cvs
mailing list