text: /* Copyright (C) 1996-2019 Free Software Foundation, Inc.
     This file is part of the GNU C Library.
     Written by Andreas Schwab, <schwab@issan.informatik.uni-dortmund.de>,
     December 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/>.  */
  
  #include <sysdeps/unix/sysv/linux/sysdep.h>
  #include <tls.h>
  
  /* Defines RTLD_PRIVATE_ERRNO.  */
  #include <dl-sysdep.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
  
  #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 %d0 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 handler to be visible in the symbol
     table when we define it here.  */
  #ifdef PIC
  #define SYSCALL_ERROR_LABEL .Lsyscall_error
  #else
  #define SYSCALL_ERROR_LABEL __syscall_error
  #endif
  
  #undef PSEUDO
  #define	PSEUDO(name, syscall_name, args)				      \
    .text;								      \
    ENTRY (name)								      \
      DO_CALL (syscall_name, args);					      \
      cmp.l &-4095, %d0;							      \
      jcc 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 rts
  
  /* 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 %d0
  
  #undef	PSEUDO_END_ERRVAL
  #define	PSEUDO_END_ERRVAL(name) \
    END (name)
  
  #define ret_ERRVAL rts
  
  #ifdef PIC
  # if RTLD_PRIVATE_ERRNO
  #  define SYSCALL_ERROR_HANDLER						      \
  SYSCALL_ERROR_LABEL:							      \
      PCREL_OP (lea, rtld_errno, %a0, %a0);				      \
      neg.l %d0;								      \
      move.l %d0, (%a0);							      \
      move.l &-1, %d0;							      \
      /* Copy return value to %a0 for syscalls that are declared to return      \
         a pointer (e.g., mmap).  */					      \
      move.l %d0, %a0;							      \
      rts;
  # 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						      \
  SYSCALL_ERROR_LABEL:							      \
      neg.l %d0;								      \
      move.l %d0, -(%sp);							      \
      cfi_adjust_cfa_offset (4);						      \
      jbsr __m68k_read_tp@PLTPC;						      \
      SYSCALL_ERROR_LOAD_GOT (%a1);					      \
      add.l (SYSCALL_ERROR_ERRNO@TLSIE, %a1), %a0;			      \
      move.l (%sp)+, (%a0);						      \
      cfi_adjust_cfa_offset (-4);						      \
      move.l &-1, %d0;							      \
      /* Copy return value to %a0 for syscalls that are declared to return      \
         a pointer (e.g., mmap).  */					      \
      move.l %d0, %a0;							      \
      rts;
  # else /* !_LIBC_REENTRANT */
  /* Store (- %d0) into errno through the GOT.  */
  #  define SYSCALL_ERROR_HANDLER						      \
  SYSCALL_ERROR_LABEL:							      \
      move.l (errno@GOTPC, %pc), %a0;					      \
      neg.l %d0;								      \
      move.l %d0, (%a0);							      \
      move.l &-1, %d0;							      \
      /* Copy return value to %a0 for syscalls that are declared to return      \
         a pointer (e.g., mmap).  */					      \
      move.l %d0, %a0;							      \
      rts;
  # endif /* _LIBC_REENTRANT */
  #else
  # define SYSCALL_ERROR_HANDLER	/* Nothing here; code in sysdep.S is used.  */
  #endif /* PIC */
  
  /* Linux takes system call arguments in registers:
  
  	syscall number	%d0	     call-clobbered
  	arg 1		%d1	     call-clobbered
  	arg 2		%d2	     call-saved
  	arg 3		%d3	     call-saved
  	arg 4		%d4	     call-saved
  	arg 5		%d5	     call-saved
  	arg 6		%a0	     call-clobbered
  
     The stack layout upon entering the function is:
  
  	24(%sp)		Arg# 6
  	20(%sp)		Arg# 5
  	16(%sp)		Arg# 4
  	12(%sp)		Arg# 3
  	 8(%sp)		Arg# 2
  	 4(%sp)		Arg# 1
  	  (%sp)		Return address
  
     (Of course a function with say 3 arguments does not have entries for
     arguments 4 and 5.)
  
     Separate move's are faster than movem, but need more space.  Since
     speed is more important, we don't use movem.  Since %a0 and %a1 are
     scratch registers, we can use them for saving as well.  */
  
  #define DO_CALL(syscall_name, args)			      		      \
      move.l &SYS_ify(syscall_name), %d0;					      \
      DOARGS_##args							      \
      trap &0;								      \
      UNDOARGS_##args
  
  #define	DOARGS_0	/* No arguments to frob.  */
  #define	UNDOARGS_0	/* No arguments to unfrob.  */
  #define	_DOARGS_0(n)	/* No arguments to frob.  */
  
  #define	DOARGS_1	_DOARGS_1 (4)
  #define	_DOARGS_1(n)	move.l n(%sp), %d1; _DOARGS_0 (n)
  #define	UNDOARGS_1	UNDOARGS_0
  
  #define	DOARGS_2	_DOARGS_2 (8)
  #define	_DOARGS_2(n)	move.l %d2, %a0; cfi_register (%d2, %a0);	      \
  			move.l n(%sp), %d2; _DOARGS_1 (n-4)
  #define	UNDOARGS_2	UNDOARGS_1; move.l %a0, %d2; cfi_restore (%d2)
  
  #define DOARGS_3	_DOARGS_3 (12)
  #define _DOARGS_3(n)	move.l %d3, %a1; cfi_register (%d3, %a1);	      \
  			move.l n(%sp), %d3; _DOARGS_2 (n-4)
  #define UNDOARGS_3	UNDOARGS_2; move.l %a1, %d3; cfi_restore (%d3)
  
  #define DOARGS_4	_DOARGS_4 (16)
  #define _DOARGS_4(n)	move.l %d4, -(%sp);				      \
  			cfi_adjust_cfa_offset (4); cfi_rel_offset (%d4, 0);   \
  			move.l n+4(%sp), %d4; _DOARGS_3 (n)
  #define UNDOARGS_4	UNDOARGS_3; move.l (%sp)+, %d4;			      \
  			cfi_adjust_cfa_offset (-4); cfi_restore (%d4)
  
  #define DOARGS_5	_DOARGS_5 (20)
  #define _DOARGS_5(n)	move.l %d5, -(%sp); 				      \
  			cfi_adjust_cfa_offset (4); cfi_rel_offset (%d5, 0);   \
  			move.l n+4(%sp), %d5; _DOARGS_4 (n)
  #define UNDOARGS_5	UNDOARGS_4; move.l (%sp)+, %d5;			      \
  			cfi_adjust_cfa_offset (-4); cfi_restore (%d5)
  
  #define DOARGS_6	_DOARGS_6 (24)
  #define _DOARGS_6(n)	_DOARGS_5 (n-4); move.l %a0, -(%sp);		      \
  			cfi_adjust_cfa_offset (4);			      \
  			move.l n+12(%sp), %a0;
  #define UNDOARGS_6	move.l (%sp)+, %a0; cfi_adjust_cfa_offset (-4);	      \
  			UNDOARGS_5
  
  
  #define	ret	rts
  #if 0 /* Not used by Linux */
  #define	r0	%d0
  #define	r1	%d1
  #define	MOVE(x,y)	movel x , y
  #endif
  
  #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
     gave back.  */
  #undef INTERNAL_SYSCALL
  #define INTERNAL_SYSCALL_NCS(name, err, nr, args...)	\
    ({ unsigned int _sys_result;				\
       {							\
         /* Load argument values in temporary variables
  	  to perform side effects like function calls
  	  before the call used registers are set.  */	\
         LOAD_ARGS_##nr (args)				\
         LOAD_REGS_##nr					\
         register int _d0 asm ("%d0") = name;		\
         asm volatile ("trap #0"				\
  		     : "=d" (_d0)			\
  		     : "0" (_d0) ASM_ARGS_##nr		\
  		     : "memory");			\
         _sys_result = _d0;				\
       }							\
       (int) _sys_result; })
  #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
  #define LOAD_ARGS_1(a1)				\
    LOAD_ARGS_0 ()				\
    int __arg1 = (int) (a1);
  #define LOAD_REGS_1				\
    register int _d1 asm ("d1") = __arg1;		\
    LOAD_REGS_0
  #define ASM_ARGS_1	ASM_ARGS_0, "d" (_d1)
  #define LOAD_ARGS_2(a1, a2)			\
    LOAD_ARGS_1 (a1)				\
    int __arg2 = (int) (a2);
  #define LOAD_REGS_2				\
    register int _d2 asm ("d2") = __arg2;		\
    LOAD_REGS_1
  #define ASM_ARGS_2	ASM_ARGS_1, "d" (_d2)
  #define LOAD_ARGS_3(a1, a2, a3)			\
    LOAD_ARGS_2 (a1, a2)				\
    int __arg3 = (int) (a3);
  #define LOAD_REGS_3				\
    register int _d3 asm ("d3") = __arg3;		\
    LOAD_REGS_2
  #define ASM_ARGS_3	ASM_ARGS_2, "d" (_d3)
  #define LOAD_ARGS_4(a1, a2, a3, a4)		\
    LOAD_ARGS_3 (a1, a2, a3)			\
    int __arg4 = (int) (a4);
  #define LOAD_REGS_4				\
    register int _d4 asm ("d4") = __arg4;		\
    LOAD_REGS_3
  #define ASM_ARGS_4	ASM_ARGS_3, "d" (_d4)
  #define LOAD_ARGS_5(a1, a2, a3, a4, a5)		\
    LOAD_ARGS_4 (a1, a2, a3, a4)			\
    int __arg5 = (int) (a5);
  #define LOAD_REGS_5				\
    register int _d5 asm ("d5") = __arg5;		\
    LOAD_REGS_4
  #define ASM_ARGS_5	ASM_ARGS_4, "d" (_d5)
  #define LOAD_ARGS_6(a1, a2, a3, a4, a5, a6)	\
    LOAD_ARGS_5 (a1, a2, a3, a4, a5)		\
    int __arg6 = (int) (a6);
  #define LOAD_REGS_6				\
    register int _a0 asm ("a0") = __arg6;		\
    LOAD_REGS_5
  #define ASM_ARGS_6	ASM_ARGS_5, "a" (_a0)
  
  #endif /* not __ASSEMBLER__ */
  
  /* Pointer mangling is not yet supported for M68K.  */
  #define PTR_MANGLE(var) (void) (var)
  #define PTR_DEMANGLE(var) (void) (var)
  
  #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
  /* M68K needs system-supplied DSO to access TLS helpers
     even when statically linked.  */
  # define NEED_STATIC_SYSINFO_DSO 1
  #endif
  