syscall: unify common syscall defines

Unify all the common syscall defines in syscalls-common.h and scrub all
the duplicated code from relevant ports.  This should also make converting
existing ports to INLINE_SYSCALL() much easier as they don't have to get
lost in all the unrelated noise, as well as creating new ports.

Signed-off-by: Mike Frysinger <vapier@gentoo.org>

14 files changed, 316 insertions, 1061 deletions

diff --git a/libc/sysdeps/linux/alpha/bits/syscalls.h b/libc/sysdeps/linux/alpha/bits/syscalls.h
index b5e0c1602..6be26971f 100644
--- a/libc/sysdeps/linux/alpha/bits/syscalls.h
+++ b/libc/sysdeps/linux/alpha/bits/syscalls.h
@@ -1,3 +1,23 @@
+/* Copyright (C) 1992, 1995, 1996, 2000, 2003, 2004, 2006
+   Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Brendan Kehoe (brendan@zen.org).
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
 #ifndef _BITS_SYSCALLS_H
 #define _BITS_SYSCALLS_H
 #ifndef _SYSCALL_H
@@ -6,186 +26,231 @@
 
 #ifndef __ASSEMBLER__
 
-#include <errno.h>
-
-#define SYS_ify(syscall_name)  (__NR_##syscall_name)
-
-#define _syscall_return(type)						\
-	return (_sc_err ? __set_errno(_sc_ret), _sc_ret = -1L : 0), (type) _sc_ret
-
-#define _syscall_clobbers						\
-	"$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8",			\
-	"$22", "$23", "$24", "$25", "$27", "$28" 			\
-
-#define _syscall0(type, name)						\
-type name(void)								\
-{									\
-	long _sc_ret, _sc_err;						\
-	{								\
-		register long _sc_0 __asm__("$0");			\
-		register long _sc_19 __asm__("$19");			\
-									\
-		_sc_0 = __NR_##name;					\
-		__asm__("callsys # %0 %1 %2"				\
-			: "=r"(_sc_0), "=r"(_sc_19)			\
-			: "0"(_sc_0)					\
-			: _syscall_clobbers);				\
-		_sc_ret = _sc_0, _sc_err = _sc_19;			\
-	}								\
-	_syscall_return(type);						\
+#define INLINE_SYSCALL(name, nr, args...)	\
+({						\
+	long _sc_ret, _sc_err;			\
+	inline_syscall##nr(__NR_##name, args);	\
+	if (__builtin_expect (_sc_err, 0))	\
+	  {					\
+	    __set_errno (_sc_ret);		\
+	    _sc_ret = -1L;			\
+	  }					\
+	_sc_ret;				\
+})
+
+#define INTERNAL_SYSCALL(name, err_out, nr, args...) \
+({							\
+	long _sc_ret, _sc_err;				\
+	inline_syscall##nr(__NR_##name, args);		\
+	err_out = _sc_err;				\
+	_sc_ret;					\
+})
+
+#define INTERNAL_SYSCALL_DECL(err)		long int err
+#define INTERNAL_SYSCALL_ERROR_P(val, err)	err
+#define INTERNAL_SYSCALL_ERRNO(val, err)	val
+
+#define inline_syscall_clobbers				\
+	"$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8",	\
+	"$22", "$23", "$24", "$25", "$27", "$28", "memory"
+
+/* If TLS is in use, we have a conflict between the PAL_rduniq primitive,
+   as modeled within GCC, and explicit use of the R0 register.  If we use
+   the register via the asm, the scheduler may place the PAL_rduniq insn
+   before we've copied the data from R0 into _sc_ret.  If this happens
+   we'll get a reload abort, since R0 is live at the same time it is
+   needed for the PAL_rduniq.
+
+   Solve this by using the "v" constraint instead of an asm for the syscall
+   output.  We don't do this unconditionally to allow compilation with
+   older compilers.  */
+
+#ifdef HAVE___THREAD
+#define inline_syscall_r0_asm
+#define inline_syscall_r0_out_constraint	"=v"
+#else
+#define inline_syscall_r0_asm			__asm__("$0")
+#define inline_syscall_r0_out_constraint	"=r"
+#endif
+
+/* It is moderately important optimization-wise to limit the lifetime
+   of the hard-register variables as much as possible.  Thus we copy
+   in/out as close to the asm as possible.  */
+
+#define inline_syscall0(name, args...)				\
+{								\
+	register long _sc_0 inline_syscall_r0_asm;		\
+	register long _sc_19 __asm__("$19");			\
+								\
+	_sc_0 = name;						\
+	__asm__ __volatile__					\
+	  ("callsys # %0 %1 <= %2"				\
+	   : inline_syscall_r0_out_constraint (_sc_0),		\
+	     "=r"(_sc_19)					\
+	   : "0"(_sc_0)						\
+	   : inline_syscall_clobbers,				\
+	     "$16", "$17", "$18", "$20", "$21");		\
+	_sc_ret = _sc_0, _sc_err = _sc_19;			\
 }
 
-#define _syscall1(type,name,type1,arg1)					\
-type name(type1 arg1)							\
-{									\
-	long _sc_ret, _sc_err;						\
-	{								\
-		register long _sc_0 __asm__("$0");			\
-		register long _sc_16 __asm__("$16");			\
-		register long _sc_19 __asm__("$19");			\
-									\
-		_sc_0 = __NR_##name;					\
-		_sc_16 = (long) (arg1);					\
-		__asm__("callsys # %0 %1 %2 %3"				\
-			: "=r"(_sc_0), "=r"(_sc_19)			\
-			: "0"(_sc_0), "r"(_sc_16)			\
-			: _syscall_clobbers);				\
-		_sc_ret = _sc_0, _sc_err = _sc_19;			\
-	}								\
-	_syscall_return(type);						\
+#define inline_syscall1(name,arg1)				\
+{								\
+	register long _sc_0 inline_syscall_r0_asm;		\
+	register long _sc_16 __asm__("$16");			\
+	register long _sc_19 __asm__("$19");			\
+	register long _tmp_16 = (long) (arg1);			\
+								\
+	_sc_0 = name;						\
+	_sc_16 = _tmp_16;					\
+	__asm__ __volatile__					\
+	  ("callsys # %0 %1 <= %2 %3"				\
+	   : inline_syscall_r0_out_constraint (_sc_0),		\
+	     "=r"(_sc_19), "=r"(_sc_16)				\
+	   : "0"(_sc_0), "2"(_sc_16)				\
+	   : inline_syscall_clobbers,				\
+	     "$17", "$18", "$20", "$21");			\
+	_sc_ret = _sc_0, _sc_err = _sc_19;			\
 }
 
-#define _syscall2(type,name,type1,arg1,type2,arg2)			\
-type name(type1 arg1,type2 arg2)					\
-{									\
-	long _sc_ret, _sc_err;						\
-	{								\
-		register long _sc_0 __asm__("$0");			\
-		register long _sc_16 __asm__("$16");			\
-		register long _sc_17 __asm__("$17");			\
-		register long _sc_19 __asm__("$19");			\
-									\
-		_sc_0 = __NR_##name;					\
-		_sc_16 = (long) (arg1);					\
-		_sc_17 = (long) (arg2);					\
-		__asm__("callsys # %0 %1 %2 %3 %4"			\
-			: "=r"(_sc_0), "=r"(_sc_19)			\
-			: "0"(_sc_0), "r"(_sc_16), "r"(_sc_17)		\
-			: _syscall_clobbers);				\
-		_sc_ret = _sc_0, _sc_err = _sc_19;			\
-	}								\
-	_syscall_return(type);						\
+#define inline_syscall2(name,arg1,arg2)				\
+{								\
+	register long _sc_0 inline_syscall_r0_asm;		\
+	register long _sc_16 __asm__("$16");			\
+	register long _sc_17 __asm__("$17");			\
+	register long _sc_19 __asm__("$19");			\
+	register long _tmp_16 = (long) (arg1);			\
+	register long _tmp_17 = (long) (arg2);			\
+								\
+	_sc_0 = name;						\
+	_sc_16 = _tmp_16;					\
+	_sc_17 = _tmp_17;					\
+	__asm__ __volatile__					\
+	  ("callsys # %0 %1 <= %2 %3 %4"			\
+	   : inline_syscall_r0_out_constraint (_sc_0),		\
+	     "=r"(_sc_19), "=r"(_sc_16), "=r"(_sc_17)		\
+	   : "0"(_sc_0), "2"(_sc_16), "3"(_sc_17)		\
+	   : inline_syscall_clobbers,				\
+	     "$18", "$20", "$21");				\
+	_sc_ret = _sc_0, _sc_err = _sc_19;			\
 }
 
-#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)		\
-type name(type1 arg1,type2 arg2,type3 arg3)				\
-{									\
-	long _sc_ret, _sc_err;						\
-	{								\
-		register long _sc_0 __asm__("$0");			\
-		register long _sc_16 __asm__("$16");			\
-		register long _sc_17 __asm__("$17");			\
-		register long _sc_18 __asm__("$18");			\
-		register long _sc_19 __asm__("$19");			\
-									\
-		_sc_0 = __NR_##name;					\
-		_sc_16 = (long) (arg1);					\
-		_sc_17 = (long) (arg2);					\
-		_sc_18 = (long) (arg3);					\
-		__asm__("callsys # %0 %1 %2 %3 %4 %5"			\
-			: "=r"(_sc_0), "=r"(_sc_19)			\
-			: "0"(_sc_0), "r"(_sc_16), "r"(_sc_17),		\
-			  "r"(_sc_18)					\
-			: _syscall_clobbers);				\
-		_sc_ret = _sc_0, _sc_err = _sc_19;			\
-	}								\
-	_syscall_return(type);						\
+#define inline_syscall3(name,arg1,arg2,arg3)			\
+{								\
+	register long _sc_0 inline_syscall_r0_asm;		\
+	register long _sc_16 __asm__("$16");			\
+	register long _sc_17 __asm__("$17");			\
+	register long _sc_18 __asm__("$18");			\
+	register long _sc_19 __asm__("$19");			\
+	register long _tmp_16 = (long) (arg1);			\
+	register long _tmp_17 = (long) (arg2);			\
+	register long _tmp_18 = (long) (arg3);			\
+								\
+	_sc_0 = name;						\
+	_sc_16 = _tmp_16;					\
+	_sc_17 = _tmp_17;					\
+	_sc_18 = _tmp_18;					\
+	__asm__ __volatile__					\
+	  ("callsys # %0 %1 <= %2 %3 %4 %5"			\
+	   : inline_syscall_r0_out_constraint (_sc_0),		\
+	     "=r"(_sc_19), "=r"(_sc_16), "=r"(_sc_17),		\
+	     "=r"(_sc_18)					\
+	   : "0"(_sc_0), "2"(_sc_16), "3"(_sc_17),		\
+	     "4"(_sc_18)					\
+	   : inline_syscall_clobbers, "$20", "$21");		\
+	_sc_ret = _sc_0, _sc_err = _sc_19;			\
 }
 
-#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
-type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4)		 \
-{									 \
-	long _sc_ret, _sc_err;						\
-	{								\
-		register long _sc_0 __asm__("$0");			\
-		register long _sc_16 __asm__("$16");			\
-		register long _sc_17 __asm__("$17");			\
-		register long _sc_18 __asm__("$18");			\
-		register long _sc_19 __asm__("$19");			\
-									\
-		_sc_0 = __NR_##name;					\
-		_sc_16 = (long) (arg1);					\
-		_sc_17 = (long) (arg2);					\
-		_sc_18 = (long) (arg3);					\
-		_sc_19 = (long) (arg4);					\
-		__asm__("callsys # %0 %1 %2 %3 %4 %5 %6"		\
-			: "=r"(_sc_0), "=r"(_sc_19)			\
-			: "0"(_sc_0), "r"(_sc_16), "r"(_sc_17),		\
-			  "r"(_sc_18), "1"(_sc_19)			\
-			: _syscall_clobbers);				\
-		_sc_ret = _sc_0, _sc_err = _sc_19;			\
-	}								\
-	_syscall_return(type);						\
+#define inline_syscall4(name,arg1,arg2,arg3,arg4)		\
+{								\
+	register long _sc_0 inline_syscall_r0_asm;		\
+	register long _sc_16 __asm__("$16");			\
+	register long _sc_17 __asm__("$17");			\
+	register long _sc_18 __asm__("$18");			\
+	register long _sc_19 __asm__("$19");			\
+	register long _tmp_16 = (long) (arg1);			\
+	register long _tmp_17 = (long) (arg2);			\
+	register long _tmp_18 = (long) (arg3);			\
+	register long _tmp_19 = (long) (arg4);			\
+								\
+	_sc_0 = name;						\
+	_sc_16 = _tmp_16;					\
+	_sc_17 = _tmp_17;					\
+	_sc_18 = _tmp_18;					\
+	_sc_19 = _tmp_19;					\
+	__asm__ __volatile__					\
+	  ("callsys # %0 %1 <= %2 %3 %4 %5 %6"			\
+	   : inline_syscall_r0_out_constraint (_sc_0),		\
+	     "=r"(_sc_19), "=r"(_sc_16), "=r"(_sc_17),		\
+	     "=r"(_sc_18)					\
+	   : "0"(_sc_0), "2"(_sc_16), "3"(_sc_17),		\
+	     "4"(_sc_18), "1"(_sc_19)				\
+	   : inline_syscall_clobbers, "$20", "$21");		\
+	_sc_ret = _sc_0, _sc_err = _sc_19;			\
 }
 
-#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
-	  type5,arg5)							 \
-type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5)	\
-{									\
-	long _sc_ret, _sc_err;						\
-	{								\
-		register long _sc_0 __asm__("$0");			\
-		register long _sc_16 __asm__("$16");			\
-		register long _sc_17 __asm__("$17");			\
-		register long _sc_18 __asm__("$18");			\
-		register long _sc_19 __asm__("$19");			\
-		register long _sc_20 __asm__("$20");			\
-									\
-		_sc_0 = __NR_##name;					\
-		_sc_16 = (long) (arg1);					\
-		_sc_17 = (long) (arg2);					\
-		_sc_18 = (long) (arg3);					\
-		_sc_19 = (long) (arg4);					\
-		_sc_20 = (long) (arg5);					\
-		__asm__("callsys # %0 %1 %2 %3 %4 %5 %6 %7"		\
-			: "=r"(_sc_0), "=r"(_sc_19)			\
-			: "0"(_sc_0), "r"(_sc_16), "r"(_sc_17),		\
-			  "r"(_sc_18), "1"(_sc_19), "r"(_sc_20)		\
-			: _syscall_clobbers);				\
-		_sc_ret = _sc_0, _sc_err = _sc_19;			\
-	}								\
-	_syscall_return(type);						\
+#define inline_syscall5(name,arg1,arg2,arg3,arg4,arg5)		\
+{								\
+	register long _sc_0 inline_syscall_r0_asm;		\
+	register long _sc_16 __asm__("$16");			\
+	register long _sc_17 __asm__("$17");			\
+	register long _sc_18 __asm__("$18");			\
+	register long _sc_19 __asm__("$19");			\
+	register long _sc_20 __asm__("$20");			\
+	register long _tmp_16 = (long) (arg1);			\
+	register long _tmp_17 = (long) (arg2);			\
+	register long _tmp_18 = (long) (arg3);			\
+	register long _tmp_19 = (long) (arg4);			\
+	register long _tmp_20 = (long) (arg5);			\
+								\
+	_sc_0 = name;						\
+	_sc_16 = _tmp_16;					\
+	_sc_17 = _tmp_17;					\
+	_sc_18 = _tmp_18;					\
+	_sc_19 = _tmp_19;					\
+	_sc_20 = _tmp_20;					\
+	__asm__ __volatile__					\
+	  ("callsys # %0 %1 <= %2 %3 %4 %5 %6 %7"		\
+	   : inline_syscall_r0_out_constraint (_sc_0),		\
+	     "=r"(_sc_19), "=r"(_sc_16), "=r"(_sc_17),		\
+	     "=r"(_sc_18), "=r"(_sc_20)				\
+	   : "0"(_sc_0), "2"(_sc_16), "3"(_sc_17),		\
+	     "4"(_sc_18), "1"(_sc_19), "5"(_sc_20)		\
+	   : inline_syscall_clobbers, "$21");			\
+	_sc_ret = _sc_0, _sc_err = _sc_19;			\
 }
 
-#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
-	  type5,arg5,type6,arg6)					 \
-type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, type6 arg6)\
-{									\
-	long _sc_ret, _sc_err;						\
-	{								\
-		register long _sc_0 __asm__("$0");			\
-		register long _sc_16 __asm__("$16");			\
-		register long _sc_17 __asm__("$17");			\
-		register long _sc_18 __asm__("$18");			\
-		register long _sc_19 __asm__("$19");			\
-		register long _sc_20 __asm__("$20");			\
-		register long _sc_21 __asm__("$21");			\
-									\
-		_sc_0 = __NR_##name;					\
-		_sc_16 = (long) (arg1);					\
-		_sc_17 = (long) (arg2);					\
-		_sc_18 = (long) (arg3);					\
-		_sc_19 = (long) (arg4);					\
-		_sc_20 = (long) (arg5);					\
-		_sc_21 = (long) (arg6);					\
-		__asm__("callsys # %0 %1 %2 %3 %4 %5 %6 %7 %8"		\
-			: "=r"(_sc_0), "=r"(_sc_19)			\
-			: "0"(_sc_0), "r"(_sc_16), "r"(_sc_17),		\
-			  "r"(_sc_18), "1"(_sc_19), "r"(_sc_20), "r"(_sc_21) \
-			: _syscall_clobbers);				\
-		_sc_ret = _sc_0, _sc_err = _sc_19;			\
-	}								\
-	_syscall_return(type);						\
+#define inline_syscall6(name,arg1,arg2,arg3,arg4,arg5,arg6)	\
+{								\
+	register long _sc_0 inline_syscall_r0_asm;		\
+	register long _sc_16 __asm__("$16");			\
+	register long _sc_17 __asm__("$17");			\
+	register long _sc_18 __asm__("$18");			\
+	register long _sc_19 __asm__("$19");			\
+	register long _sc_20 __asm__("$20");			\
+	register long _sc_21 __asm__("$21");			\
+	register long _tmp_16 = (long) (arg1);			\
+	register long _tmp_17 = (long) (arg2);			\
+	register long _tmp_18 = (long) (arg3);			\
+	register long _tmp_19 = (long) (arg4);			\
+	register long _tmp_20 = (long) (arg5);			\
+	register long _tmp_21 = (long) (arg6);			\
+								\
+	_sc_0 = name;						\
+	_sc_16 = _tmp_16;					\
+	_sc_17 = _tmp_17;					\
+	_sc_18 = _tmp_18;					\
+	_sc_19 = _tmp_19;					\
+	_sc_20 = _tmp_20;					\
+	_sc_21 = _tmp_21;					\
+	__asm__ __volatile__					\
+	  ("callsys # %0 %1 <= %2 %3 %4 %5 %6 %7 %8"		\
+	   : inline_syscall_r0_out_constraint (_sc_0),		\
+	     "=r"(_sc_19), "=r"(_sc_16), "=r"(_sc_17),		\
+	     "=r"(_sc_18), "=r"(_sc_20), "=r"(_sc_21)		\
+	   : "0"(_sc_0), "2"(_sc_16), "3"(_sc_17), "4"(_sc_18),	\
+	     "1"(_sc_19), "5"(_sc_20), "6"(_sc_21)		\
+	   : inline_syscall_clobbers);				\
+	_sc_ret = _sc_0, _sc_err = _sc_19;			\
 }
 
 #endif /* __ASSEMBLER__ */
diff --git a/libc/sysdeps/linux/arm/bits/syscalls.h b/libc/sysdeps/linux/arm/bits/syscalls.h
index 2d2e0f0a4..2ad725544 100644
--- a/libc/sysdeps/linux/arm/bits/syscalls.h
+++ b/libc/sysdeps/linux/arm/bits/syscalls.h
@@ -9,8 +9,6 @@
    glibc-2.3.2/sysdeps/unix/sysv/linux/arm/sysdep.h
 */
 
-#define SYS_ify(syscall_name)  (__NR_##syscall_name)
-
 #ifdef __ASSEMBLER__
 
 /* Call a given syscall, with arguments loaded.  For EABI, we must
@@ -32,67 +30,6 @@
 
 #include <errno.h>
 
-#undef _syscall0
-#define _syscall0(type,name) \
-type name(void) \
-{ \
-return (type) (INLINE_SYSCALL(name, 0)); \
-}
-
-#undef _syscall1
-#define _syscall1(type,name,type1,arg1) \
-type name(type1 arg1) \
-{ \
-return (type) (INLINE_SYSCALL(name, 1, arg1)); \
-}
-
-#undef _syscall2
-#define _syscall2(type,name,type1,arg1,type2,arg2) \
-type name(type1 arg1,type2 arg2) \
-{ \
-return (type) (INLINE_SYSCALL(name, 2, arg1, arg2)); \
-}
-
-#undef _syscall3
-#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
-type name(type1 arg1,type2 arg2,type3 arg3) \
-{ \
-return (type) (INLINE_SYSCALL(name, 3, arg1, arg2, arg3)); \
-}
-
-#undef _syscall4
-#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
-type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
-{ \
-return (type) (INLINE_SYSCALL(name, 4, arg1, arg2, arg3, arg4)); \
-}
-
-#undef _syscall5
-#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
-	  type5,arg5) \
-type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
-{ \
-return (type) (INLINE_SYSCALL(name, 5, arg1, arg2, arg3, arg4, arg5)); \
-}
-
-#undef _syscall6
-#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
-	  type5,arg5,type6,arg6) \
-type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, type6 arg6) \
-{ \
-return (type) (INLINE_SYSCALL(name, 6, arg1, arg2, arg3, arg4, arg5, arg6)); \
-}
-
-#undef _syscall7
-#define _syscall7(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
-	  type5,arg5,type6,arg6,type7,arg7) \
-type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, type6 arg6,type7 arg7) \
-{ \
-return (type) (INLINE_SYSCALL(name, 7, arg1, arg2, arg3, arg4, arg5, arg6, arg7)); \
-}
-
-
-#undef INLINE_SYSCALL
 #define INLINE_SYSCALL(name, nr, args...)				\
   ({ unsigned int _inline_sys_result = INTERNAL_SYSCALL (name, , nr, args);	\
      if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_inline_sys_result, ), 0))	\
@@ -102,10 +39,6 @@ return (type) (INLINE_SYSCALL(name, 7, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
        }								\
      (int) _inline_sys_result; })
 
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL
 #if !defined(__thumb__)
 #if defined(__ARM_EABI__)
 #define INTERNAL_SYSCALL(name, err, nr, args...)			\
@@ -160,13 +93,9 @@ return (type) (INLINE_SYSCALL(name, 7, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
     (int) __sys_result; })
 #endif /*!defined(__thumb__)*/
 
-#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 LOAD_ARGS_0()
 #define ASM_ARGS_0
 #define LOAD_ARGS_1(a1)				\
diff --git a/libc/sysdeps/linux/avr32/bits/syscalls.h b/libc/sysdeps/linux/avr32/bits/syscalls.h
index ff5d1a7be..e473b10ba 100644
--- a/libc/sysdeps/linux/avr32/bits/syscalls.h
+++ b/libc/sysdeps/linux/avr32/bits/syscalls.h
@@ -4,95 +4,10 @@
 # error "Never use <bits/syscalls.h> directly; include <sys/syscall.h> instead."
 #endif
 
-/*
- * This includes the `__NR_<name>' syscall numbers taken from the
- * Linux kernel header files. It also defines the traditional
- * `SYS_<name>' macros for older programs.
- */
-#include <bits/sysnum.h>
-
 #ifndef __ASSEMBLER__
 
 #include <errno.h>
 
-#define SYS_ify(syscall_name) (__NR_##syscall_name)
-
-#undef _syscall0
-#define _syscall0(type,name)				\
-	type name(void)					\
-	{						\
-		return (type)(INLINE_SYSCALL(name, 0));	\
-	}
-
-#undef _syscall1
-#define _syscall1(type,name,type1,arg1)				\
-	type name(type1 arg1)					\
-	{							\
-		return (type)(INLINE_SYSCALL(name, 1, arg1));	\
-	}
-
-#undef _syscall2
-#define _syscall2(type,name,type1,arg1,type2,arg2)			\
-	type name(type1 arg1, type2 arg2)				\
-	{								\
-		return (type)(INLINE_SYSCALL(name, 2, arg1, arg2));	\
-	}
-
-#undef _syscall3
-#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)		\
-	type name(type1 arg1, type2 arg2, type3 arg3)			\
-	{								\
-		return (type)(INLINE_SYSCALL(name, 3, arg1,		\
-					     arg2, arg3));		\
-	}
-
-#undef _syscall4
-#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,		\
-		  type4,arg4)						\
-	type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4)	\
-	{								\
-		return (type)(INLINE_SYSCALL(name, 4, arg1, arg2,	\
-					     arg3, arg4));		\
-	}
-
-#undef _syscall5
-#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,		\
-		  type4,arg4,type5,arg5)				\
-	type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4,	\
-		  type5 arg5)						\
-	{								\
-		return (type)(INLINE_SYSCALL(name, 5, arg1, arg2,	\
-					     arg3, arg4, arg5));	\
-	}
-
-#undef _syscall6
-#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,		\
-		  type4,arg4,type5,arg5,type6,arg6)			\
-	type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4,	\
-		  type5 arg5, type6 arg6)				\
-	{								\
-		return (type)(INLINE_SYSCALL(name, 6, arg1, arg2, arg3,	\
-					     arg4, arg5, arg6));	\
-	}
-
-#undef unlikely
-#define unlikely(x) __builtin_expect((x), 0)
-
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...)				\
-	({								\
-		unsigned _sys_result = INTERNAL_SYSCALL(name, , nr, args); \
-		if (unlikely(INTERNAL_SYSCALL_ERROR_P(_sys_result, ))) { \
-			__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
 #define INTERNAL_SYSCALL(name, err, nr, args...)			\
 	({								\
 		register int _a1 __asm__("r12");			\
@@ -105,13 +20,9 @@
 		_a1;							\
 	})
 
-#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, errr) (-(val))
-
 #define LOAD_ARGS_0() do { } while(0)
 #define ASM_ARGS_0
 #define LOAD_ARGS_1(a1)					\
diff --git a/libc/sysdeps/linux/bfin/bits/syscalls.h b/libc/sysdeps/linux/bfin/bits/syscalls.h
index 37e564d2c..478ea2dfd 100644
--- a/libc/sysdeps/linux/bfin/bits/syscalls.h
+++ b/libc/sysdeps/linux/bfin/bits/syscalls.h
@@ -6,151 +6,6 @@
 
 #ifndef __ASSEMBLER__
 
-#include <errno.h>
-
-#define SYS_ify(syscall_name)  (__NR_##syscall_name)
-
-/* user-visible error numbers are in the range -1 - -4095: see <asm-frv/errno.h> */
-#if defined _LIBC && !defined __set_errno
-# define __syscall_return(type, res) \
-do { \
-        unsigned long __sr2 = (res);		    			    \
-	if (__builtin_expect ((unsigned long)(__sr2)			    \
-			      >= (unsigned long)(-4095), 0)) {		    \
-		extern int __syscall_error (int);			    \
-		return (type) __syscall_error (__sr2);		    	    \
-	}								    \
-	return (type) (__sr2); 						    \
-} while (0)
-#else
-# define __syscall_return(type, res) \
-do { \
-        unsigned long __sr2 = (res);		    			    \
-	if (__builtin_expect ((unsigned long)(__sr2)			    \
-			      >= (unsigned long)(-4095), 0)) {		    \
-		__set_errno (-__sr2);				    	    \
-		__sr2 = -1; 						    \
-	}								    \
-	return (type) (__sr2); 						    \
-} while (0)
-#endif
-
-#define _syscall0(type,name)						\
-type name(void) {							\
-	long __res;							\
-	__asm__ __volatile__ (						\
-		"excpt 0;\n\t"						\
-		: "=q0" (__res)						\
-		: "qA" (__NR_##name)					\
-		: "memory","CC");					\
-	__syscall_return(type,__res);					\
-}
-
-#define _syscall1(type,name,type1,arg1)					\
-type name(type1 arg1) {							\
-	long __res;							\
-	__asm__ __volatile__ (						\
-		"excpt 0;\n\t"						\
-		: "=q0" (__res)						\
-		: "qA" (__NR_##name),					\
-		  "q0" ((long)(arg1))					\
-		: "memory","CC");					\
-	__syscall_return(type,__res);					\
-}
-
-#define _syscall2(type,name,type1,arg1,type2,arg2)			\
-type name(type1 arg1,type2 arg2) {					\
-	long __res;							\
-	__asm__ __volatile__ (						\
-		"excpt 0;\n\t"						\
-		"%0=r0;\n\t"						\
-		: "=q0" (__res)						\
-		: "qA" (__NR_##name),					\
-		  "q0" ((long)(arg1)),					\
-		  "q1" ((long)(arg2))					\
-		: "memory","CC");					\
-	__syscall_return(type,__res);					\
-}
-
-#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)		\
-type name(type1 arg1,type2 arg2,type3 arg3) {				\
-	long __res;							\
-	__asm__ __volatile__ (						\
-		"excpt 0;\n\t"						\
-		: "=q0" (__res)						\
-		: "qA"   (__NR_##name),					\
-		  "q0"   ((long)(arg1)),				\
-		  "q1"   ((long)(arg2)),				\
-		  "q2"   ((long)(arg3))					\
-		: "memory","CC");					\
-	__syscall_return(type,__res);					\
-}
-
-#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)\
-type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {		\
-	long __res;							\
-	__asm__ __volatile__ (						\
-		"excpt 0;\n\t"						\
-		: "=q0" (__res)						\
-		: "qA"  (__NR_##name),					\
-		  "q0"  ((long)(arg1)),					\
-		  "q1"  ((long)(arg2)),					\
-		  "q2"  ((long)(arg3)),					\
-		  "q3"  ((long)(arg4))					\
-		: "memory","CC");					\
-	__syscall_return(type,__res);					\
-}
-
-#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5)	\
-type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) {	\
-	long __res;							\
-	__asm__ __volatile__ (						\
-		"excpt 0;\n\t"						\
-		: "=q0" (__res)						\
-		: "qA"  (__NR_##name),					\
-		  "q0"  ((long)(arg1)),					\
-		  "q1"  ((long)(arg2)),					\
-		  "q2"  ((long)(arg3)),					\
-		  "q3"  ((long)(arg4)),					\
-		  "q4"  ((long)(arg5))					\
-		: "memory","CC");					\
-	__syscall_return(type,__res);					\
-}
-
-#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5,type6,arg6) \
-type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg6) { \
-	long __res;							\
-	__asm__ __volatile__ (						\
-		"excpt 0;\n\t"						\
-		: "=q0" (__res)						\
-		: "qA"  (__NR_##name),					\
-		  "q0"  ((long)(arg1)),					\
-		  "q1"  ((long)(arg2)),					\
-		  "q2"  ((long)(arg3)),					\
-		  "q3"  ((long)(arg4)),					\
-		  "q4"  ((long)(arg5)),					\
-		  "q5"  ((long)(arg6))					\
-		: "memory","CC");					\
-	__syscall_return(type,__res);					\
-}
-
-
-/* Define a macro which expands into the inline wrapper code for a system call */
-#define INLINE_SYSCALL(name, nr, args...)				\
-({									\
-	INTERNAL_SYSCALL_DECL(err);					\
-	long 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;					\
-	}								\
-	result_var;							\
-})
-
-#define INTERNAL_SYSCALL_DECL(err)         do { } while (0)
-#define INTERNAL_SYSCALL_ERROR_P(val, err) ((unsigned long)val >= (unsigned long)(-4095))
-#define INTERNAL_SYSCALL_ERRNO(val, err)   (-(val))
-
 #define INTERNAL_SYSCALL(name, err, nr, args...)	\
 ({							\
 	long __res;					\
diff --git a/libc/sysdeps/linux/common/bits/syscalls-common.h b/libc/sysdeps/linux/common/bits/syscalls-common.h
new file mode 100644
index 000000000..81c82c801
--- /dev/null
+++ b/libc/sysdeps/linux/common/bits/syscalls-common.h
@@ -0,0 +1,81 @@
+/*
+ * Common syscall type defines
+ *
+ * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
+ */
+
+#ifndef _SYSCALLS_COMMON_H
+#define _SYSCALLS_COMMON_H	1
+
+#ifndef _SYSCALL_H
+# error "Never use <bits/syscalls-common.h> directly; include <sys/syscall.h> instead."
+#endif
+
+#ifndef SYS_ify
+# define SYS_ify(syscall_name) (__NR_##syscall_name)
+#endif
+
+#ifndef __ASSEMBLER__
+
+#include <errno.h>
+
+#ifndef INTERNAL_SYSCALL_DECL
+# define INTERNAL_SYSCALL_DECL(err)         do { } while (0)
+#endif
+#ifndef INTERNAL_SYSCALL_ERROR_P
+# define INTERNAL_SYSCALL_ERROR_P(val, err) ((unsigned long)val >= (unsigned long)(-4095))
+#endif
+#ifndef INTERNAL_SYSCALL_ERRNO
+# define INTERNAL_SYSCALL_ERRNO(val, err)   (-(val))
+#endif
+
+/* Define a macro which expands into the inline wrapper code for a system call */
+#ifndef INLINE_SYSCALL
+# define INLINE_SYSCALL(name, nr, args...)				\
+({									\
+	INTERNAL_SYSCALL_DECL(err);					\
+	long res = INTERNAL_SYSCALL(name, err, nr, args);		\
+	if (unlikely(INTERNAL_SYSCALL_ERROR_P(res, err))) {		\
+		__set_errno(INTERNAL_SYSCALL_ERRNO(res, err));		\
+		res = -1L;						\
+	}								\
+	res;								\
+})
+#endif
+
+#ifndef _syscall0
+
+#define C_DECL_ARGS_0()			void
+#define C_DECL_ARGS_1(t, v)		t v
+#define C_DECL_ARGS_2(t, v, args...)	t v, C_DECL_ARGS_1(args)
+#define C_DECL_ARGS_3(t, v, args...)	t v, C_DECL_ARGS_2(args)
+#define C_DECL_ARGS_4(t, v, args...)	t v, C_DECL_ARGS_3(args)
+#define C_DECL_ARGS_5(t, v, args...)	t v, C_DECL_ARGS_4(args)
+#define C_DECL_ARGS_6(t, v, args...)	t v, C_DECL_ARGS_5(args)
+
+#define C_ARGS_0()
+#define C_ARGS_1(t, v)			v
+#define C_ARGS_2(t, v, args...)		v, C_ARGS_1(args)
+#define C_ARGS_3(t, v, args...)		v, C_ARGS_2(args)
+#define C_ARGS_4(t, v, args...)		v, C_ARGS_3(args)
+#define C_ARGS_5(t, v, args...)		v, C_ARGS_4(args)
+#define C_ARGS_6(t, v, args...)		v, C_ARGS_5(args)
+
+#define SYSCALL_FUNC(nargs, type, name, args...)			\
+type name(C_DECL_ARGS_##nargs(args)) {					\
+	return (type)INLINE_SYSCALL(name, nargs, C_ARGS_##nargs(args));	\
+}
+
+#define _syscall0(args...)		SYSCALL_FUNC(0, args)
+#define _syscall1(args...)		SYSCALL_FUNC(1, args)
+#define _syscall2(args...)		SYSCALL_FUNC(2, args)
+#define _syscall3(args...)		SYSCALL_FUNC(3, args)
+#define _syscall4(args...)		SYSCALL_FUNC(4, args)
+#define _syscall5(args...)		SYSCALL_FUNC(5, args)
+#define _syscall6(args...)		SYSCALL_FUNC(6, args)
+
+#endif /* _syscall0 */
+
+#endif /* __ASSEMBLER__ */
+
+#endif
diff --git a/libc/sysdeps/linux/common/bits/syscalls.h b/libc/sysdeps/linux/common/bits/syscalls.h
index ceba568e5..e7c6b035d 100644
--- a/libc/sysdeps/linux/common/bits/syscalls.h
+++ b/libc/sysdeps/linux/common/bits/syscalls.h
@@ -5,4 +5,5 @@
  * forbidden.  Don't do it.  It is bad for you.
  */
 
-#error You have not provided architecture specific _syscall[0-6] macros
+#error You have not provided architecture specific bits/syscalls.h
+#error You should need to define only INTERNAL_SYSCALL
diff --git a/libc/sysdeps/linux/i386/bits/syscalls.h b/libc/sysdeps/linux/i386/bits/syscalls.h
index 014539c2a..343b096f1 100644
--- a/libc/sysdeps/linux/i386/bits/syscalls.h
+++ b/libc/sysdeps/linux/i386/bits/syscalls.h
@@ -13,15 +13,9 @@
 
 #include <errno.h>
 
-#define SYS_ify(syscall_name)  (__NR_##syscall_name)
-
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
 #define INTERNAL_SYSCALL_ERROR_P(val, err) \
   ((unsigned int) (val) >= 0xfffff001u)
 
-#define INTERNAL_SYSCALL_ERRNO(val, err)        (-(val))
-
 /* We need some help from the assembler to generate optimal code.  We
    define some macros here which later will be used.  */
 
@@ -102,66 +96,6 @@ __asm__ (".L__X'%ebx = 1\n\t"
      ".endm\n\t");
 #endif
 
-#undef _syscall0
-#define _syscall0(type,name) \
-type name(void) \
-{ \
-return (type)