[thirdparty/glibc.git] / sysdeps / unix / sysv / linux / i386 / sysdep.h

/* Copyright (C) 1992-2015 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper, <drepper@gnu.org>, August 1995.

   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, see
   <http://www.gnu.org/licenses/>.  */

#ifndef _LINUX_I386_SYSDEP_H
#define _LINUX_I386_SYSDEP_H 1

/* There is some commonality.  */
#include <sysdeps/unix/i386/sysdep.h>
/* Defines RTLD_PRIVATE_ERRNO and USE_DL_SYSINFO.  */
#include <dl-sysdep.h>
#include <tls.h>


/* 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
   so we have to redefine the `SYS_ify' macro here.  */
#undef SYS_ify
#define SYS_ify(syscall_name)	__NR_##syscall_name

#if defined USE_DL_SYSINFO \
    && (IS_IN (libc) || IS_IN (libpthread))
# define I386_USE_SYSENTER	1
#else
# undef I386_USE_SYSENTER
#endif

#ifdef __ASSEMBLER__

/* Linux uses a negative return value to indicate syscall errors,
   unlike most Unices, which use the condition codes' carry flag.

   Since version 2.1 the return value of a system call might be
   negative even if the call succeeded.  E.g., the `lseek' system call
   might return a large offset.  Therefore we must not anymore test
   for < 0, but test for a real error by making sure the value in %eax
   is a real error number.  Linus said he will make sure the no syscall
   returns a value in -1 .. -4095 as a valid result so we can savely
   test with -4095.  */

/* We don't want the label for the error handle to be global when we define
   it here.  */
#ifdef PIC
# define SYSCALL_ERROR_LABEL 0f
#else
# define SYSCALL_ERROR_LABEL syscall_error
#endif

#undef	PSEUDO
#define	PSEUDO(name, syscall_name, args)				      \
  .text;								      \
  ENTRY (name)								      \
    DO_CALL (syscall_name, args);					      \
    cmpl $-4095, %eax;							      \
    jae SYSCALL_ERROR_LABEL

#undef	PSEUDO_END
#define	PSEUDO_END(name)						      \
  SYSCALL_ERROR_HANDLER							      \
  END (name)

#undef	PSEUDO_NOERRNO
#define	PSEUDO_NOERRNO(name, syscall_name, args)			      \
  .text;								      \
  ENTRY (name)								      \
    DO_CALL (syscall_name, args)

#undef	PSEUDO_END_NOERRNO
#define	PSEUDO_END_NOERRNO(name)					      \
  END (name)

#define ret_NOERRNO ret

/* The function has to return the error code.  */
#undef	PSEUDO_ERRVAL
#define	PSEUDO_ERRVAL(name, syscall_name, args) \
  .text;								      \
  ENTRY (name)								      \
    DO_CALL (syscall_name, args);					      \
    negl %eax

#undef	PSEUDO_END_ERRVAL
#define	PSEUDO_END_ERRVAL(name) \
  END (name)

#define ret_ERRVAL ret

#ifndef PIC
# define SYSCALL_ERROR_HANDLER	/* Nothing here; code in sysdep.S is used.  */
#else

# if RTLD_PRIVATE_ERRNO
#  define SYSCALL_ERROR_HANDLER						      \
0:SETUP_PIC_REG(cx);							      \
  addl $_GLOBAL_OFFSET_TABLE_, %ecx;					      \
  negl %eax;								      \
  movl %eax, rtld_errno@GOTOFF(%ecx);					      \
  orl $-1, %eax;							      \
  ret;

# elif defined _LIBC_REENTRANT

#  if IS_IN (libc)
#   define SYSCALL_ERROR_ERRNO __libc_errno
#  else
#   define SYSCALL_ERROR_ERRNO errno
#  endif
#  define SYSCALL_ERROR_HANDLER					      \
0:SETUP_PIC_REG (cx);							      \
  addl $_GLOBAL_OFFSET_TABLE_, %ecx;					      \
  movl SYSCALL_ERROR_ERRNO@GOTNTPOFF(%ecx), %ecx;			      \
  negl %eax;								      \
  SYSCALL_ERROR_HANDLER_TLS_STORE (%eax, %ecx);				      \
  orl $-1, %eax;							      \
  ret;
#  ifndef NO_TLS_DIRECT_SEG_REFS
#   define SYSCALL_ERROR_HANDLER_TLS_STORE(src, destoff)		      \
  movl src, %gs:(destoff)
#  else
#   define SYSCALL_ERROR_HANDLER_TLS_STORE(src, destoff)		      \
  addl %gs:0, destoff;							      \
  movl src, (destoff)
#  endif
# else
/* Store (- %eax) into errno through the GOT.  */
#  define SYSCALL_ERROR_HANDLER						      \
0:SETUP_PIC_REG(cx);							      \
  addl $_GLOBAL_OFFSET_TABLE_, %ecx;					      \
  negl %eax;								      \
  movl errno@GOT(%ecx), %ecx;						      \
  movl %eax, (%ecx);							      \
  orl $-1, %eax;							      \
  ret;
# endif	/* _LIBC_REENTRANT */
#endif	/* PIC */


/* The original calling convention for system calls on Linux/i386 is
   to use int $0x80.  */
#ifdef I386_USE_SYSENTER
# ifdef SHARED
#  define ENTER_KERNEL call *%gs:SYSINFO_OFFSET
# else
#  define ENTER_KERNEL call *_dl_sysinfo
# endif
#else
# define ENTER_KERNEL int $0x80
#endif

/* Linux takes system call arguments in registers:

	syscall number	%eax	     call-clobbered
	arg 1		%ebx	     call-saved
	arg 2		%ecx	     call-clobbered
	arg 3		%edx	     call-clobbered
	arg 4		%esi	     call-saved
	arg 5		%edi	     call-saved
	arg 6		%ebp	     call-saved

   The stack layout upon entering the function is:

	24(%esp)	Arg# 6
	20(%esp)	Arg# 5
	16(%esp)	Arg# 4
	12(%esp)	Arg# 3
	 8(%esp)	Arg# 2
	 4(%esp)	Arg# 1
	  (%esp)	Return address

   (Of course a function with say 3 arguments does not have entries for
   arguments 4, 5, and 6.)

   The following code tries hard to be optimal.  A general assumption
   (which is true according to the data books I have) is that

	2 * xchg	is more expensive than	pushl + movl + popl

   Beside this a neat trick is used.  The calling conventions for Linux
   tell that among the registers used for parameters %ecx and %edx need
   not be saved.  Beside this we may clobber this registers even when
   they are not used for parameter passing.

   As a result one can see below that we save the content of the %ebx
   register in the %edx register when we have less than 3 arguments
   (2 * movl is less expensive than pushl + popl).

   Second unlike for the other registers we don't save the content of
   %ecx and %edx when we have more than 1 and 2 registers resp.

   The code below might look a bit long but we have to take care for
   the pipelined processors (i586).  Here the `pushl' and `popl'
   instructions are marked as NP (not pairable) but the exception is
   two consecutive of these instruction.  This gives no penalty on
   other processors though.  */

#undef	DO_CALL
#define DO_CALL(syscall_name, args)			      		      \
    PUSHARGS_##args							      \
    DOARGS_##args							      \
    movl $SYS_ify (syscall_name), %eax;					      \
    ENTER_KERNEL							      \
    POPARGS_##args

#define PUSHARGS_0	/* No arguments to push.  */
#define	DOARGS_0	/* No arguments to frob.  */
#define	POPARGS_0	/* No arguments to pop.  */
#define	_PUSHARGS_0	/* No arguments to push.  */
#define _DOARGS_0(n)	/* No arguments to frob.  */
#define	_POPARGS_0	/* No arguments to pop.  */

#define PUSHARGS_1	movl %ebx, %edx; L(SAVEBX1): PUSHARGS_0
#define	DOARGS_1	_DOARGS_1 (4)
#define	POPARGS_1	POPARGS_0; movl %edx, %ebx; L(RESTBX1):
#define	_PUSHARGS_1	pushl %ebx; cfi_adjust_cfa_offset (4); \
			cfi_rel_offset (ebx, 0); L(PUSHBX1): _PUSHARGS_0
#define _DOARGS_1(n)	movl n(%esp), %ebx; _DOARGS_0(n-4)
#define	_POPARGS_1	_POPARGS_0; popl %ebx; cfi_adjust_cfa_offset (-4); \
			cfi_restore (ebx); L(POPBX1):

#define PUSHARGS_2	PUSHARGS_1
#define	DOARGS_2	_DOARGS_2 (8)
#define	POPARGS_2	POPARGS_1
#define _PUSHARGS_2	_PUSHARGS_1
#define	_DOARGS_2(n)	movl n(%esp), %ecx; _DOARGS_1 (n-4)
#define	_POPARGS_2	_POPARGS_1

#define PUSHARGS_3	_PUSHARGS_2
#define DOARGS_3	_DOARGS_3 (16)
#define POPARGS_3	_POPARGS_3
#define _PUSHARGS_3	_PUSHARGS_2
#define _DOARGS_3(n)	movl n(%esp), %edx; _DOARGS_2 (n-4)
#define _POPARGS_3	_POPARGS_2

#define PUSHARGS_4	_PUSHARGS_4
#define DOARGS_4	_DOARGS_4 (24)
#define POPARGS_4	_POPARGS_4
#define _PUSHARGS_4	pushl %esi; cfi_adjust_cfa_offset (4); \
			cfi_rel_offset (esi, 0); L(PUSHSI1): _PUSHARGS_3
#define _DOARGS_4(n)	movl n(%esp), %esi; _DOARGS_3 (n-4)
#define _POPARGS_4	_POPARGS_3; popl %esi; cfi_adjust_cfa_offset (-4); \
			cfi_restore (esi); L(POPSI1):

#define PUSHARGS_5	_PUSHARGS_5
#define DOARGS_5	_DOARGS_5 (32)
#define POPARGS_5	_POPARGS_5
#define _PUSHARGS_5	pushl %edi; cfi_adjust_cfa_offset (4); \
			cfi_rel_offset (edi, 0); L(PUSHDI1): _PUSHARGS_4
#define _DOARGS_5(n)	movl n(%esp), %edi; _DOARGS_4 (n-4)
#define _POPARGS_5	_POPARGS_4; popl %edi; cfi_adjust_cfa_offset (-4); \
			cfi_restore (edi); L(POPDI1):

#define PUSHARGS_6	_PUSHARGS_6
#define DOARGS_6	_DOARGS_6 (40)
#define POPARGS_6	_POPARGS_6
#define _PUSHARGS_6	pushl %ebp; cfi_adjust_cfa_offset (4); \
			cfi_rel_offset (ebp, 0); L(PUSHBP1): _PUSHARGS_5
#define _DOARGS_6(n)	movl n(%esp), %ebp; _DOARGS_5 (n-4)
#define _POPARGS_6	_POPARGS_5; popl %ebp; cfi_adjust_cfa_offset (-4); \
			cfi_restore (ebp); L(POPBP1):

#else	/* !__ASSEMBLER__ */

/* We need some help from the assembler to generate optimal code.  We
   define some macros here which later will be used.  */
asm (".L__X'%ebx = 1\n\t"
     ".L__X'%ecx = 2\n\t"
     ".L__X'%edx = 2\n\t"
     ".L__X'%eax = 3\n\t"
     ".L__X'%esi = 3\n\t"
     ".L__X'%edi = 3\n\t"
     ".L__X'%ebp = 3\n\t"
     ".L__X'%esp = 3\n\t"
     ".macro bpushl name reg\n\t"
     ".if 1 - \\name\n\t"
     ".if 2 - \\name\n\t"
     "error\n\t"
     ".else\n\t"
     "xchgl \\reg, %ebx\n\t"
     ".endif\n\t"
     ".endif\n\t"
     ".endm\n\t"
     ".macro bpopl name reg\n\t"
     ".if 1 - \\name\n\t"
     ".if 2 - \\name\n\t"
     "error\n\t"
     ".else\n\t"
     "xchgl \\reg, %ebx\n\t"
     ".endif\n\t"
     ".endif\n\t"
     ".endm\n\t");

/* Six-argument syscalls use an out-of-line helper, because an inline
   asm using all registers apart from %esp cannot work reliably and
   the assembler does not support describing an asm that saves and
   restores %ebp itself as a separate stack frame.  This structure
   stores the arguments not passed in registers; %edi is passed with a
   pointer to this structure.  */
struct libc_do_syscall_args
{
  int ebx, edi, ebp;
};

/* Define a macro which expands inline into the wrapper code for a system
   call.  */
#undef INLINE_SYSCALL
#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; })

/* 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.

   The _NCS variant allows non-constant syscall numbers but it is not
   possible to use more than four parameters.  */
#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL_MAIN_0(name, err, args...) \
    INTERNAL_SYSCALL_MAIN_INLINE(name, err, 0, args)
#define INTERNAL_SYSCALL_MAIN_1(name, err, args...) \
    INTERNAL_SYSCALL_MAIN_INLINE(name, err, 1, args)
#define INTERNAL_SYSCALL_MAIN_2(name, err, args...) \
    INTERNAL_SYSCALL_MAIN_INLINE(name, err, 2, args)
#define INTERNAL_SYSCALL_MAIN_3(name, err, args...) \
    INTERNAL_SYSCALL_MAIN_INLINE(name, err, 3, args)
#define INTERNAL_SYSCALL_MAIN_4(name, err, args...) \
    INTERNAL_SYSCALL_MAIN_INLINE(name, err, 4, args)
#define INTERNAL_SYSCALL_MAIN_5(name, err, args...) \
    INTERNAL_SYSCALL_MAIN_INLINE(name, err, 5, args)
/* Each object using 6-argument inline syscalls must include a
   definition of __libc_do_syscall.  */
#define INTERNAL_SYSCALL_MAIN_6(name, err, arg1, arg2, arg3,		\
				arg4, arg5, arg6)			\
  struct libc_do_syscall_args _xv =					\
    {									\
      (int) (arg1),							\
      (int) (arg5),							\
      (int) (arg6)							\
    };									\
    asm volatile (							\
    "movl %1, %%eax\n\t"						\
    "call __libc_do_syscall"						\
    : "=a" (resultvar)							\
    : "i" (__NR_##name), "c" (arg2), "d" (arg3), "S" (arg4), "D" (&_xv) \
    : "memory", "cc")
#define INTERNAL_SYSCALL(name, err, nr, args...) \
  ({									      \
    register unsigned int resultvar;					      \
    INTERNAL_SYSCALL_MAIN_##nr (name, err, args);			      \
    (int) resultvar; })
#ifdef I386_USE_SYSENTER
# ifdef SHARED
#  define INTERNAL_SYSCALL_MAIN_INLINE(name, err, nr, args...) \
    EXTRAVAR_##nr							      \
    asm volatile (							      \
    LOADARGS_##nr							      \
    "movl %1, %%eax\n\t"						      \
    "call *%%gs:%P2\n\t"						      \
    RESTOREARGS_##nr							      \
    : "=a" (resultvar)							      \
    : "i" (__NR_##name), "i" (offsetof (tcbhead_t, sysinfo))		      \
      ASMFMT_##nr(args) : "memory", "cc")
#  define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
  ({									      \
    register unsigned int resultvar;					      \
    EXTRAVAR_##nr							      \
    asm volatile (							      \
    LOADARGS_##nr							      \
    "call *%%gs:%P2\n\t"						      \
    RESTOREARGS_##nr							      \
    : "=a" (resultvar)							      \
    : "0" (name), "i" (offsetof (tcbhead_t, sysinfo))			      \
      ASMFMT_##nr(args) : "memory", "cc");				      \
    (int) resultvar; })
# else
#  define INTERNAL_SYSCALL_MAIN_INLINE(name, err, nr, args...) \
    EXTRAVAR_##nr							      \
    asm volatile (							      \
    LOADARGS_##nr							      \
    "movl %1, %%eax\n\t"						      \
    "call *_dl_sysinfo\n\t"						      \
    RESTOREARGS_##nr							      \
    : "=a" (resultvar)							      \
    : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc")
#  define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
  ({									      \
    register unsigned int resultvar;					      \
    EXTRAVAR_##nr							      \
    asm volatile (							      \
    LOADARGS_##nr							      \
    "call *_dl_sysinfo\n\t"						      \
    RESTOREARGS_##nr							      \
    : "=a" (resultvar)							      \
    : "0" (name) ASMFMT_##nr(args) : "memory", "cc");			      \
    (int) resultvar; })
# endif
#else
# define INTERNAL_SYSCALL_MAIN_INLINE(name, err, nr, args...) \
    EXTRAVAR_##nr							      \
    asm volatile (							      \
    LOADARGS_##nr							      \
    "movl %1, %%eax\n\t"						      \
    "int $0x80\n\t"							      \
    RESTOREARGS_##nr							      \
    : "=a" (resultvar)							      \
    : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc")
# define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
  ({									      \
    register unsigned int resultvar;					      \
    EXTRAVAR_##nr							      \
    asm volatile (							      \
    LOADARGS_##nr							      \
    "int $0x80\n\t"							      \
    RESTOREARGS_##nr							      \
    : "=a" (resultvar)							      \
    : "0" (name) ASMFMT_##nr(args) : "memory", "cc");			      \
    (int) resultvar; })
#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 defined I386_USE_SYSENTER && defined SHARED
#  define LOADARGS_1 \
    "bpushl .L__X'%k3, %k3\n\t"
#  define LOADARGS_5 \
    "movl %%ebx, %4\n\t"						      \
    "movl %3, %%ebx\n\t"
# else
#  define LOADARGS_1 \
    "bpushl .L__X'%k2, %k2\n\t"
#  define LOADARGS_5 \
    "movl %%ebx, %3\n\t"						      \
    "movl %2, %%ebx\n\t"
# endif
# define LOADARGS_2	LOADARGS_1
# define LOADARGS_3 \
    "xchgl %%ebx, %%edi\n\t"
# define LOADARGS_4	LOADARGS_3
#else
# define LOADARGS_1
# define LOADARGS_2
# define LOADARGS_3
# define LOADARGS_4
# define LOADARGS_5
#endif

#define RESTOREARGS_0
#ifdef __PIC__
# if defined I386_USE_SYSENTER && defined SHARED
#  define RESTOREARGS_1 \
    "bpopl .L__X'%k3, %k3\n\t"
#  define RESTOREARGS_5 \
    "movl %4, %%ebx"
# else
#  define RESTOREARGS_1 \
    "bpopl .L__X'%k2, %k2\n\t"
#  define RESTOREARGS_5 \
    "movl %3, %%ebx"
# endif
# define RESTOREARGS_2	RESTOREARGS_1
# define RESTOREARGS_3 \
    "xchgl %%edi, %%ebx\n\t"
# define RESTOREARGS_4	RESTOREARGS_3
#else
# define RESTOREARGS_1
# define RESTOREARGS_2
# define RESTOREARGS_3
# define RESTOREARGS_4
# define RESTOREARGS_5
#endif

#define ASMFMT_0()
#ifdef __PIC__
# define ASMFMT_1(arg1) \
	, "cd" (arg1)
# define ASMFMT_2(arg1, arg2) \
	, "d" (arg1), "c" (arg2)
# define ASMFMT_3(arg1, arg2, arg3) \
	, "D" (arg1), "c" (arg2), "d" (arg3)
# define ASMFMT_4(arg1, arg2, arg3, arg4) \
	, "D" (arg1), "c" (arg2), "d" (arg3), "S" (arg4)
# define ASMFMT_5(arg1, arg2, arg3, arg4, arg5) \
	, "0" (arg1), "m" (_xv), "c" (arg2), "d" (arg3), "S" (arg4), "D" (arg5)
#else
# define ASMFMT_1(arg1) \
	, "b" (arg1)
# define ASMFMT_2(arg1, arg2) \
	, "b" (arg1), "c" (arg2)
# define ASMFMT_3(arg1, arg2, arg3) \
	, "b" (arg1), "c" (arg2), "d" (arg3)
# define ASMFMT_4(arg1, arg2, arg3, arg4) \
	, "b" (arg1), "c" (arg2), "d" (arg3), "S" (arg4)
# define ASMFMT_5(arg1, arg2, arg3, arg4, arg5) \
	, "b" (arg1), "c" (arg2), "d" (arg3), "S" (arg4), "D" (arg5)
#endif

#define EXTRAVAR_0
#define EXTRAVAR_1
#define EXTRAVAR_2
#define EXTRAVAR_3
#define EXTRAVAR_4
#ifdef __PIC__
# define EXTRAVAR_5 int _xv;
#else
# define EXTRAVAR_5
#endif

/* Consistency check for position-independent code.  */
#if defined __PIC__ && !__GNUC_PREREQ (5,0)
# define check_consistency()						      \
  ({ int __res;								      \
     __asm__ __volatile__						      \
       (LOAD_PIC_REG_STR (cx) ";"					      \
	"subl %%ebx, %%ecx;"						      \
	"je 1f;"							      \
	"ud2;"								      \
	"1:\n"								      \
	: "=c" (__res));						      \
     __res; })
#endif

#endif	/* __ASSEMBLER__ */


/* Pointer mangling support.  */
#if IS_IN (rtld)
/* We cannot use the thread descriptor because in ld.so we use setjmp
   earlier than the descriptor is initialized.  Using a global variable
   is too complicated here since we have no PC-relative addressing mode.  */
#else
# ifdef __ASSEMBLER__
#  define PTR_MANGLE(reg)	xorl %gs:POINTER_GUARD, reg;		      \
				roll $9, reg
#  define PTR_DEMANGLE(reg)	rorl $9, reg;				      \
				xorl %gs:POINTER_GUARD, reg
# else
#  define PTR_MANGLE(var)	asm ("xorl %%gs:%c2, %0\n"		      \
				     "roll $9, %0"			      \
				     : "=r" (var)			      \
				     : "0" (var),			      \
				       "i" (offsetof (tcbhead_t,	      \
						      pointer_guard)))
#  define PTR_DEMANGLE(var)	asm ("rorl $9, %0\n"			      \
				     "xorl %%gs:%c2, %0"		      \
				     : "=r" (var)			      \
				     : "0" (var),			      \
				       "i" (offsetof (tcbhead_t,	      \
						      pointer_guard)))
# endif
#endif

#endif /* linux/i386/sysdep.h */
Commit	Line	Data
b168057a	1	/* Copyright (C) 1992-2015 Free Software Foundation, Inc.
bfbc5754	2	This file is part of the GNU C Library.
44129238	3	Contributed by Ulrich Drepper, <drepper@gnu.org>, August 1995.
bfbc5754 UD	4
bfbc5754 UD	5	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
bfbc5754 UD	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	13	Lesser General Public License for more details.
bfbc5754	14
41bdb6e2	15	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	16	License along with the GNU C Library; if not, see
59ba27a6 PE	17	<http://www.gnu.org/licenses/>. */
d2f5be2a	18
ec4b0518 UD	19	#ifndef _LINUX_I386_SYSDEP_H
	20	#define _LINUX_I386_SYSDEP_H 1
	21
d2f5be2a UD	22	/* There is some commonality. */
d2f5be2a UD	23	#include <sysdeps/unix/i386/sysdep.h>
131fd126	24	/* Defines RTLD_PRIVATE_ERRNO and USE_DL_SYSINFO. */
5f5843e3	25	#include <dl-sysdep.h>
739d440d	26	#include <tls.h>
d2f5be2a	27
ce460d04	28
d2f5be2a UD	29	/* For Linux we can use the system call table in the header file
	30	/usr/include/asm/unistd.h
	31	of the kernel. But these symbols do not follow the SYS_* syntax
	32	so we have to redefine the `SYS_ify' macro here. */
	33	#undef SYS_ify
6ed0492f	34	#define SYS_ify(syscall_name) __NR_##syscall_name
d2f5be2a	35
131fd126	36	#if defined USE_DL_SYSINFO \
4f41c682	37	&& (IS_IN (libc) \|\| IS_IN (libpthread))
5f5843e3 UD	38	# define I386_USE_SYSENTER 1
	39	#else
	40	# undef I386_USE_SYSENTER
	41	#endif
	42
c2afe833 RM	43	#ifdef __ASSEMBLER__
c2afe833 RM	44
cccda09f UD	45	/* Linux uses a negative return value to indicate syscall errors,
	46	unlike most Unices, which use the condition codes' carry flag.
	47
	48	Since version 2.1 the return value of a system call might be
	49	negative even if the call succeeded. E.g., the `lseek' system call
	50	might return a large offset. Therefore we must not anymore test
	51	for < 0, but test for a real error by making sure the value in %eax
b5791037 UD	52	is a real error number. Linus said he will make sure the no syscall
	53	returns a value in -1 .. -4095 as a valid result so we can savely
	54	test with -4095. */
c0fb8a56 UD	55
	56	/* We don't want the label for the error handle to be global when we define
	57	it here. */
	58	#ifdef PIC
	59	# define SYSCALL_ERROR_LABEL 0f
	60	#else
	61	# define SYSCALL_ERROR_LABEL syscall_error
	62	#endif
	63
d2f5be2a UD	64	#undef PSEUDO
	65	#define PSEUDO(name, syscall_name, args) \
	66	.text; \
d2f5be2a	67	ENTRY (name) \
ffa8d2a0	68	DO_CALL (syscall_name, args); \
b5791037	69	cmpl $-4095, %eax; \
842a39cd	70	jae SYSCALL_ERROR_LABEL
d2f5be2a	71
6ed0492f UD	72	#undef PSEUDO_END
	73	#define PSEUDO_END(name) \
	74	SYSCALL_ERROR_HANDLER \
	75	END (name)
	76
9eb88290 UD	77	#undef PSEUDO_NOERRNO
	78	#define PSEUDO_NOERRNO(name, syscall_name, args) \
	79	.text; \
	80	ENTRY (name) \
	81	DO_CALL (syscall_name, args)
	82
	83	#undef PSEUDO_END_NOERRNO
	84	#define PSEUDO_END_NOERRNO(name) \
	85	END (name)
	86
	87	#define ret_NOERRNO ret
	88
bfef9264 UD	89	/* The function has to return the error code. */
	90	#undef PSEUDO_ERRVAL
	91	#define PSEUDO_ERRVAL(name, syscall_name, args) \
	92	.text; \
	93	ENTRY (name) \
	94	DO_CALL (syscall_name, args); \
	95	negl %eax
	96
	97	#undef PSEUDO_END_ERRVAL
	98	#define PSEUDO_END_ERRVAL(name) \
	99	END (name)
	100
	101	#define ret_ERRVAL ret
	102
edf5b2d7	103	#ifndef PIC
739d440d	104	# define SYSCALL_ERROR_HANDLER /* Nothing here; code in sysdep.S is used. */
03a75825	105	#else
9bd64602	106
ce460d04 RM	107	# if RTLD_PRIVATE_ERRNO
	108	# define SYSCALL_ERROR_HANDLER \
	109	0:SETUP_PIC_REG(cx); \
	110	addl $_GLOBAL_OFFSET_TABLE_, %ecx; \
f63d5db6 L	111	negl %eax; \
f63d5db6 L	112	movl %eax, rtld_errno@GOTOFF(%ecx); \
ce460d04	113	orl $-1, %eax; \
5e292e4f	114	ret;
739d440d	115
ce460d04 RM	116	# elif defined _LIBC_REENTRANT
ce460d04 RM	117
4f41c682	118	# if IS_IN (libc)
d063d164 UD	119	# define SYSCALL_ERROR_ERRNO __libc_errno
	120	# else
	121	# define SYSCALL_ERROR_ERRNO errno
	122	# endif
	123	# define SYSCALL_ERROR_HANDLER \
739d440d UD	124	0:SETUP_PIC_REG (cx); \
739d440d UD	125	addl $_GLOBAL_OFFSET_TABLE_, %ecx; \
ac2dc598	126	movl SYSCALL_ERROR_ERRNO@GOTNTPOFF(%ecx), %ecx; \
f63d5db6 L	127	negl %eax; \
f63d5db6 L	128	SYSCALL_ERROR_HANDLER_TLS_STORE (%eax, %ecx); \
739d440d	129	orl $-1, %eax; \
5e292e4f	130	ret;
d063d164 UD	131	# ifndef NO_TLS_DIRECT_SEG_REFS
d063d164 UD	132	# define SYSCALL_ERROR_HANDLER_TLS_STORE(src, destoff) \
24992143	133	movl src, %gs:(destoff)
d063d164 UD	134	# else
d063d164 UD	135	# define SYSCALL_ERROR_HANDLER_TLS_STORE(src, destoff) \
70a8119b RM	136	addl %gs:0, destoff; \
70a8119b RM	137	movl src, (destoff)
739d440d	138	# endif
9bd64602	139	# else
ce460d04	140	/* Store (- %eax) into errno through the GOT. */
739d440d	141	# define SYSCALL_ERROR_HANDLER \
09d65ff3	142	0:SETUP_PIC_REG(cx); \
b44e3016	143	addl $_GLOBAL_OFFSET_TABLE_, %ecx; \
f63d5db6	144	negl %eax; \
03a75825	145	movl errno@GOT(%ecx), %ecx; \
f63d5db6	146	movl %eax, (%ecx); \
b259e746	147	orl $-1, %eax; \
5e292e4f	148	ret;
739d440d	149	# endif /* _LIBC_REENTRANT */
edf5b2d7	150	#endif /* PIC */
03a75825	151
f051627f UD	152
	153	/* The original calling convention for system calls on Linux/i386 is
	154	to use int $0x80. */
5f5843e3 UD	155	#ifdef I386_USE_SYSENTER
	156	# ifdef SHARED
	157	# define ENTER_KERNEL call *%gs:SYSINFO_OFFSET
	158	# else
	159	# define ENTER_KERNEL call *_dl_sysinfo
	160	# endif
	161	#else
	162	# define ENTER_KERNEL int $0x80
	163	#endif
f051627f	164
d2f5be2a UD	165	/* Linux takes system call arguments in registers:
	166
	167	syscall number %eax call-clobbered
	168	arg 1 %ebx call-saved
	169	arg 2 %ecx call-clobbered
	170	arg 3 %edx call-clobbered
	171	arg 4 %esi call-saved
	172	arg 5 %edi call-saved
b2bcd249	173	arg 6 %ebp call-saved
d2f5be2a UD	174
	175	The stack layout upon entering the function is:
	176
b2bcd249	177	24(%esp) Arg# 6
d2f5be2a UD	178	20(%esp) Arg# 5
	179	16(%esp) Arg# 4
	180	12(%esp) Arg# 3
	181	8(%esp) Arg# 2
	182	4(%esp) Arg# 1
	183	(%esp) Return address
	184
	185	(Of course a function with say 3 arguments does not have entries for
b2bcd249	186	arguments 4, 5, and 6.)
d2f5be2a	187
6ed0492f	188	The following code tries hard to be optimal. A general assumption
03a75825	189	(which is true according to the data books I have) is that
d2f5be2a UD	190
	191	2 * xchg is more expensive than pushl + movl + popl
	192
	193	Beside this a neat trick is used. The calling conventions for Linux
	194	tell that among the registers used for parameters %ecx and %edx need
	195	not be saved. Beside this we may clobber this registers even when
	196	they are not used for parameter passing.
	197
	198	As a result one can see below that we save the content of the %ebx
	199	register in the %edx register when we have less than 3 arguments
	200	(2 * movl is less expensive than pushl + popl).
	201
	202	Second unlike for the other registers we don't save the content of
6ed0492f	203	%ecx and %edx when we have more than 1 and 2 registers resp.
8f5ca04b RM	204
8f5ca04b RM	205	The code below might look a bit long but we have to take care for
63bda0c1	206	the pipelined processors (i586). Here the `pushl' and `popl'
8f5ca04b RM	207	instructions are marked as NP (not pairable) but the exception is
8f5ca04b RM	208	two consecutive of these instruction. This gives no penalty on
63bda0c1	209	other processors though. */
d2f5be2a UD	210
d2f5be2a UD	211	#undef DO_CALL
ffa8d2a0	212	#define DO_CALL(syscall_name, args) \
8f5ca04b	213	PUSHARGS_##args \
d2f5be2a	214	DOARGS_##args \
c14e4c32	215	movl $SYS_ify (syscall_name), %eax; \
f051627f	216	ENTER_KERNEL \
8f5ca04b	217	POPARGS_##args
d2f5be2a	218
8f5ca04b	219	#define PUSHARGS_0 /* No arguments to push. */
d2f5be2a	220	#define DOARGS_0 /* No arguments to frob. */
8f5ca04b RM	221	#define POPARGS_0 /* No arguments to pop. */
	222	#define _PUSHARGS_0 /* No arguments to push. */
	223	#define _DOARGS_0(n) /* No arguments to frob. */
	224	#define _POPARGS_0 /* No arguments to pop. */
	225
bd4f43b4	226	#define PUSHARGS_1 movl %ebx, %edx; L(SAVEBX1): PUSHARGS_0
8f5ca04b	227	#define DOARGS_1 _DOARGS_1 (4)
bd4f43b4	228	#define POPARGS_1 POPARGS_0; movl %edx, %ebx; L(RESTBX1):
62d01985 UD	229	#define _PUSHARGS_1 pushl %ebx; cfi_adjust_cfa_offset (4); \
62d01985 UD	230	cfi_rel_offset (ebx, 0); L(PUSHBX1): _PUSHARGS_0
8f5ca04b	231	#define _DOARGS_1(n) movl n(%esp), %ebx; _DOARGS_0(n-4)
62d01985 UD	232	#define _POPARGS_1 _POPARGS_0; popl %ebx; cfi_adjust_cfa_offset (-4); \
62d01985 UD	233	cfi_restore (ebx); L(POPBX1):
8f5ca04b RM	234
	235	#define PUSHARGS_2 PUSHARGS_1
	236	#define DOARGS_2 _DOARGS_2 (8)
	237	#define POPARGS_2 POPARGS_1
	238	#define _PUSHARGS_2 _PUSHARGS_1
d2f5be2a	239	#define _DOARGS_2(n) movl n(%esp), %ecx; _DOARGS_1 (n-4)
8f5ca04b	240	#define _POPARGS_2 _POPARGS_1
d2f5be2a	241
8f5ca04b RM	242	#define PUSHARGS_3 _PUSHARGS_2
	243	#define DOARGS_3 _DOARGS_3 (16)
	244	#define POPARGS_3 _POPARGS_3
	245	#define _PUSHARGS_3 _PUSHARGS_2
d2f5be2a	246	#define _DOARGS_3(n) movl n(%esp), %edx; _DOARGS_2 (n-4)
8f5ca04b RM	247	#define _POPARGS_3 _POPARGS_2
	248
	249	#define PUSHARGS_4 _PUSHARGS_4
	250	#define DOARGS_4 _DOARGS_4 (24)
	251	#define POPARGS_4 _POPARGS_4
62d01985 UD	252	#define _PUSHARGS_4 pushl %esi; cfi_adjust_cfa_offset (4); \
62d01985 UD	253	cfi_rel_offset (esi, 0); L(PUSHSI1): _PUSHARGS_3
8f5ca04b	254	#define _DOARGS_4(n) movl n(%esp), %esi; _DOARGS_3 (n-4)
62d01985 UD	255	#define _POPARGS_4 _POPARGS_3; popl %esi; cfi_adjust_cfa_offset (-4); \
62d01985 UD	256	cfi_restore (esi); L(POPSI1):
8f5ca04b RM	257
	258	#define PUSHARGS_5 _PUSHARGS_5
	259	#define DOARGS_5 _DOARGS_5 (32)
	260	#define POPARGS_5 _POPARGS_5
62d01985 UD	261	#define _PUSHARGS_5 pushl %edi; cfi_adjust_cfa_offset (4); \
62d01985 UD	262	cfi_rel_offset (edi, 0); L(PUSHDI1): _PUSHARGS_4
8f5ca04b	263	#define _DOARGS_5(n) movl n(%esp), %edi; _DOARGS_4 (n-4)
62d01985 UD	264	#define _POPARGS_5 _POPARGS_4; popl %edi; cfi_adjust_cfa_offset (-4); \
62d01985 UD	265	cfi_restore (edi); L(POPDI1):
d2f5be2a	266
0da7bcc5	267	#define PUSHARGS_6 _PUSHARGS_6
46c38bd7	268	#define DOARGS_6 _DOARGS_6 (40)
0da7bcc5	269	#define POPARGS_6 _POPARGS_6
62d01985 UD	270	#define _PUSHARGS_6 pushl %ebp; cfi_adjust_cfa_offset (4); \
62d01985 UD	271	cfi_rel_offset (ebp, 0); L(PUSHBP1): _PUSHARGS_5
0da7bcc5	272	#define _DOARGS_6(n) movl n(%esp), %ebp; _DOARGS_5 (n-4)
62d01985 UD	273	#define _POPARGS_6 _POPARGS_5; popl %ebp; cfi_adjust_cfa_offset (-4); \
62d01985 UD	274	cfi_restore (ebp); L(POPBP1):
0da7bcc5	275
adcb550c UD	276	#else /* !__ASSEMBLER__ */
adcb550c UD	277
78e5779b UD	278	/* We need some help from the assembler to generate optimal code. We
78e5779b UD	279	define some macros here which later will be used. */
e3e35cfc UD	280	asm (".L__X'%ebx = 1\n\t"
	281	".L__X'%ecx = 2\n\t"
	282	".L__X'%edx = 2\n\t"
	283	".L__X'%eax = 3\n\t"
	284	".L__X'%esi = 3\n\t"
	285	".L__X'%edi = 3\n\t"
	286	".L__X'%ebp = 3\n\t"
	287	".L__X'%esp = 3\n\t"
78e5779b UD	288	".macro bpushl name reg\n\t"
	289	".if 1 - \\name\n\t"
	290	".if 2 - \\name\n\t"
7a114794	291	"error\n\t"
78e5779b UD	292	".else\n\t"
	293	"xchgl \\reg, %ebx\n\t"
	294	".endif\n\t"
	295	".endif\n\t"
	296	".endm\n\t"
	297	".macro bpopl name reg\n\t"
	298	".if 1 - \\name\n\t"
	299	".if 2 - \\name\n\t"
7a114794	300	"error\n\t"
78e5779b UD	301	".else\n\t"
	302	"xchgl \\reg, %ebx\n\t"
	303	".endif\n\t"
	304	".endif\n\t"
78e5779b UD	305	".endm\n\t");
78e5779b UD	306
a9fe4c5a JM	307	/* Six-argument syscalls use an out-of-line helper, because an inline
	308	asm using all registers apart from %esp cannot work reliably and
	309	the assembler does not support describing an asm that saves and
	310	restores %ebp itself as a separate stack frame. This structure
	311	stores the arguments not passed in registers; %edi is passed with a
	312	pointer to this structure. */
	313	struct libc_do_syscall_args
	314	{
	315	int ebx, edi, ebp;
	316	};
	317
adcb550c UD	318	/* Define a macro which expands inline into the wrapper code for a system
	319	call. */
	320	#undef INLINE_SYSCALL
	321	#define INLINE_SYSCALL(name, nr, args...) \
ce460d04	322	({ \
6aca81bb	323	unsigned int resultvar = INTERNAL_SYSCALL (name, , nr, args); \
a1ffb40e	324	if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, ))) \
ce460d04	325	{ \
6aca81bb	326	__set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, )); \
ce460d04 RM	327	resultvar = 0xffffffff; \
	328	} \
	329	(int) resultvar; })
	330
	331	/* Define a macro which expands inline into the wrapper code for a system
	332	call. This use is for internal calls that do not need to handle errors
	333	normally. It will never touch errno. This returns just what the kernel
2edb61e3 UD	334	gave back.
	335
	336	The _NCS variant allows non-constant syscall numbers but it is not
	337	possible to use more than four parameters. */
ce460d04	338	#undef INTERNAL_SYSCALL
a9fe4c5a JM	339	#define INTERNAL_SYSCALL_MAIN_0(name, err, args...) \
	340	INTERNAL_SYSCALL_MAIN_INLINE(name, err, 0, args)
	341	#define INTERNAL_SYSCALL_MAIN_1(name, err, args...) \
	342	INTERNAL_SYSCALL_MAIN_INLINE(name, err, 1, args)
	343	#define INTERNAL_SYSCALL_MAIN_2(name, err, args...) \
	344	INTERNAL_SYSCALL_MAIN_INLINE(name, err, 2, args)
	345	#define INTERNAL_SYSCALL_MAIN_3(name, err, args...) \
	346	INTERNAL_SYSCALL_MAIN_INLINE(name, err, 3, args)
	347	#define INTERNAL_SYSCALL_MAIN_4(name, err, args...) \
	348	INTERNAL_SYSCALL_MAIN_INLINE(name, err, 4, args)
	349	#define INTERNAL_SYSCALL_MAIN_5(name, err, args...) \
	350	INTERNAL_SYSCALL_MAIN_INLINE(name, err, 5, args)
	351	/* Each object using 6-argument inline syscalls must include a
	352	definition of __libc_do_syscall. */
	353	#define INTERNAL_SYSCALL_MAIN_6(name, err, arg1, arg2, arg3, \
	354	arg4, arg5, arg6) \
	355	struct libc_do_syscall_args _xv = \
	356	{ \
	357	(int) (arg1), \
	358	(int) (arg5), \
	359	(int) (arg6) \
	360	}; \
	361	asm volatile ( \
	362	"movl %1, %%eax\n\t" \
	363	"call __libc_do_syscall" \
	364	: "=a" (resultvar) \
	365	: "i" (__NR_##name), "c" (arg2), "d" (arg3), "S" (arg4), "D" (&_xv) \
	366	: "memory", "cc")
	367	#define INTERNAL_SYSCALL(name, err, nr, args...) \
5f5843e3	368	({ \
7a114794	369	register unsigned int resultvar; \
a9fe4c5a JM	370	INTERNAL_SYSCALL_MAIN_##nr (name, err, args); \
	371	(int) resultvar; })
	372	#ifdef I386_USE_SYSENTER
	373	# ifdef SHARED
	374	# define INTERNAL_SYSCALL_MAIN_INLINE(name, err, nr, args...) \
7a114794	375	EXTRAVAR_##nr \
5f5843e3 UD	376	asm volatile ( \
	377	LOADARGS_##nr \
	378	"movl %1, %%eax\n\t" \
	379	"call *%%gs:%P2\n\t" \
	380	RESTOREARGS_##nr \
	381	: "=a" (resultvar) \
	382	: "i" (__NR_##name), "i" (offsetof (tcbhead_t, sysinfo)) \
a9fe4c5a	383	ASMFMT_##nr(args) : "memory", "cc")
2edb61e3 UD	384	# define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
	385	({ \
	386	register unsigned int resultvar; \
	387	EXTRAVAR_##nr \
	388	asm volatile ( \
	389	LOADARGS_##nr \
	390	"call *%%gs:%P2\n\t" \
	391	RESTOREARGS_##nr \
	392	: "=a" (resultvar) \
	393	: "0" (name), "i" (offsetof (tcbhead_t, sysinfo)) \
	394	ASMFMT_##nr(args) : "memory", "cc"); \
	395	(int) resultvar; })
5f5843e3	396	# else
a9fe4c5a	397	# define INTERNAL_SYSCALL_MAIN_INLINE(name, err, nr, args...) \
7a114794	398	EXTRAVAR_##nr \
adcb550c	399	asm volatile ( \
44129238	400	LOADARGS_##nr \
78e5779b	401	"movl %1, %%eax\n\t" \
5f5843e3	402	"call *_dl_sysinfo\n\t" \
44129238	403	RESTOREARGS_##nr \
adcb550c	404	: "=a" (resultvar) \
a9fe4c5a	405	: "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc")
2edb61e3 UD	406	# define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
	407	({ \
	408	register unsigned int resultvar; \
	409	EXTRAVAR_##nr \
	410	asm volatile ( \
	411	LOADARGS_##nr \
	412	"call *_dl_sysinfo\n\t" \
	413	RESTOREARGS_##nr \
	414	: "=a" (resultvar) \
	415	: "0" (name) ASMFMT_##nr(args) : "memory", "cc"); \
	416	(int) resultvar; })
5f5843e3 UD	417	# endif
5f5843e3 UD	418	#else
a9fe4c5a	419	# define INTERNAL_SYSCALL_MAIN_INLINE(name, err, nr, args...) \
7a114794	420	EXTRAVAR_##nr \
5f5843e3 UD	421	asm volatile ( \
	422	LOADARGS_##nr \
	423	"movl %1, %%eax\n\t" \
7a114794	424	"int $0x80\n\t" \
5f5843e3 UD	425	RESTOREARGS_##nr \
5f5843e3 UD	426	: "=a" (resultvar) \
a9fe4c5a	427	: "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc")
2edb61e3 UD	428	# define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
	429	({ \
	430	register unsigned int resultvar; \
	431	EXTRAVAR_##nr \
	432	asm volatile ( \
	433	LOADARGS_##nr \
	434	"int $0x80\n\t" \
	435	RESTOREARGS_##nr \
	436	: "=a" (resultvar) \
	437	: "0" (name) ASMFMT_##nr(args) : "memory", "cc"); \
	438	(int) resultvar; })
5f5843e3	439	#endif
adcb550c	440
6aca81bb UD	441	#undef INTERNAL_SYSCALL_DECL
	442	#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
	443
f4447671	444	#undef INTERNAL_SYSCALL_ERROR_P
6aca81bb UD	445	#define INTERNAL_SYSCALL_ERROR_P(val, err) \
6aca81bb UD	446	((unsigned int) (val) >= 0xfffff001u)
f4447671 UD	447
f4447671 UD	448	#undef INTERNAL_SYSCALL_ERRNO
6aca81bb	449	#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
f4447671	450
44129238	451	#define LOADARGS_0
7a114794	452	#ifdef __PIC__
a44cffaa	453	# if defined I386_USE_SYSENTER && defined SHARED
7a114794 UD	454	# define LOADARGS_1 \
	455	"bpushl .L__X'%k3, %k3\n\t"
	456	# define LOADARGS_5 \
	457	"movl %%ebx, %4\n\t" \
	458	"movl %3, %%ebx\n\t"
	459	# else
	460	# define LOADARGS_1 \
	461	"bpushl .L__X'%k2, %k2\n\t"
	462	# define LOADARGS_5 \
	463	"movl %%ebx, %3\n\t" \
	464	"movl %2, %%ebx\n\t"
	465	# endif
	466	# define LOADARGS_2 LOADARGS_1
	467	# define LOADARGS_3 \
	468	"xchgl %%ebx, %%edi\n\t"
	469	# define LOADARGS_4 LOADARGS_3
5f5843e3	470	#else
7a114794 UD	471	# define LOADARGS_1
	472	# define LOADARGS_2
	473	# define LOADARGS_3
	474	# define LOADARGS_4
	475	# define LOADARGS_5
5f5843e3	476	#endif
44129238 UD	477
44129238 UD	478	#define RESTOREARGS_0
7a114794 UD	479	#ifdef __PIC__
	480	# if defined I386_USE_SYSENTER && defined SHARED
	481	# define RESTOREARGS_1 \
5f5843e3	482	"bpopl .L__X'%k3, %k3\n\t"
7a114794 UD	483	# define RESTOREARGS_5 \
	484	"movl %4, %%ebx"
	485	# else
	486	# define RESTOREARGS_1 \
44129238	487	"bpopl .L__X'%k2, %k2\n\t"
7a114794 UD	488	# define RESTOREARGS_5 \
	489	"movl %3, %%ebx"
	490	# endif
	491	# define RESTOREARGS_2 RESTOREARGS_1
	492	# define RESTOREARGS_3 \
	493	"xchgl %%edi, %%ebx\n\t"
	494	# define RESTOREARGS_4 RESTOREARGS_3
	495	#else
	496	# define RESTOREARGS_1
	497	# define RESTOREARGS_2
	498	# define RESTOREARGS_3
	499	# define RESTOREARGS_4
	500	# define RESTOREARGS_5
5f5843e3	501	#endif
44129238	502
7bb38c70	503	#define ASMFMT_0()
7a114794 UD	504	#ifdef __PIC__
	505	# define ASMFMT_1(arg1) \
	506	, "cd" (arg1)
	507	# define ASMFMT_2(arg1, arg2) \
3a370de8	508	, "d" (arg1), "c" (arg2)
7a114794 UD	509	# define ASMFMT_3(arg1, arg2, arg3) \
	510	, "D" (arg1), "c" (arg2), "d" (arg3)
	511	# define ASMFMT_4(arg1, arg2, arg3, arg4) \
	512	, "D" (arg1), "c" (arg2), "d" (arg3), "S" (arg4)
	513	# define ASMFMT_5(arg1, arg2, arg3, arg4, arg5) \
	514	, "0" (arg1), "m" (_xv), "c" (arg2), "d" (arg3), "S" (arg4), "D" (arg5)
	515	#else
	516	# define ASMFMT_1(arg1) \
	517	, "b" (arg1)
	518	# define ASMFMT_2(arg1, arg2) \
	519	, "b" (arg1), "c" (arg2)
	520	# define ASMFMT_3(arg1, arg2, arg3) \
	521	, "b" (arg1), "c" (arg2), "d" (arg3)
	522	# define ASMFMT_4(arg1, arg2, arg3, arg4) \
	523	, "b" (arg1), "c" (arg2), "d" (arg3), "S" (arg4)
	524	# define ASMFMT_5(arg1, arg2, arg3, arg4, arg5) \
	525	, "b" (arg1), "c" (arg2), "d" (arg3), "S" (arg4), "D" (arg5)
	526	#endif
	527
	528	#define EXTRAVAR_0
	529	#define EXTRAVAR_1
	530	#define EXTRAVAR_2
	531	#define EXTRAVAR_3
	532	#define EXTRAVAR_4
	533	#ifdef __PIC__
	534	# define EXTRAVAR_5 int _xv;
	535	#else
	536	# define EXTRAVAR_5
	537	#endif
adcb550c	538
dbfc1e02	539	/* Consistency check for position-independent code. */
07256e18	540	#if defined __PIC__ && !__GNUC_PREREQ (5,0)
dbfc1e02 UD	541	# define check_consistency() \
	542	({ int __res; \
	543	__asm__ __volatile__ \
d8e0ca50	544	(LOAD_PIC_REG_STR (cx) ";" \
dbfc1e02 UD	545	"subl %%ebx, %%ecx;" \
	546	"je 1f;" \
	547	"ud2;" \
	548	"1:\n" \
dbfc1e02 UD	549	: "=c" (__res)); \
	550	__res; })
	551	#endif
	552
66715f83	553	#endif /* __ASSEMBLER__ */
ec4b0518	554
827b7087 UD	555
827b7087 UD	556	/* Pointer mangling support. */
a3848485	557	#if IS_IN (rtld)
827b7087 UD	558	/* We cannot use the thread descriptor because in ld.so we use setjmp
	559	earlier than the descriptor is initialized. Using a global variable
	560	is too complicated here since we have no PC-relative addressing mode. */
	561	#else
3467f5c3	562	# ifdef __ASSEMBLER__
4a44ce79 UD	563	# define PTR_MANGLE(reg) xorl %gs:POINTER_GUARD, reg; \
	564	roll $9, reg
	565	# define PTR_DEMANGLE(reg) rorl $9, reg; \
	566	xorl %gs:POINTER_GUARD, reg
3467f5c3	567	# else
4a44ce79 UD	568	# define PTR_MANGLE(var) asm ("xorl %%gs:%c2, %0\n" \
	569	"roll $9, %0" \
	570	: "=r" (var) \
	571	: "0" (var), \
	572	"i" (offsetof (tcbhead_t, \
	573	pointer_guard)))
	574	# define PTR_DEMANGLE(var) asm ("rorl $9, %0\n" \
	575	"xorl %%gs:%c2, %0" \
3467f5c3 UD	576	: "=r" (var) \
	577	: "0" (var), \
	578	"i" (offsetof (tcbhead_t, \
	579	pointer_guard)))
3467f5c3	580	# endif
827b7087 UD	581	#endif
827b7087 UD	582
ec4b0518	583	#endif /* linux/i386/sysdep.h */