/* Assembler macros for 64 bit S/390.

   Copyright (C) 2001-2018 Free Software Foundation, Inc.

   Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).

   This file is part of the GNU C Library.

   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_S390_SYSDEP_H

#define _LINUX_S390_SYSDEP_H

#include <sysdeps/s390/s390-64/sysdep.h>

#include <sysdeps/unix/sysdep.h>

#include <sysdeps/unix/sysv/linux/sysdep.h>

#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

   so we have to redefine the `SYS_ify' macro here.  */

/* In newer 2.1 kernels __NR_syscall is missing so we define it here.  */

#define __NR_syscall 0

/*

 * Newer kernel versions redefined __NR_pread and __NR_pwrite to

 * __NR_pread64 and __NR_pwrite64.

 */

#ifndef __NR_pread

# define __NR_pread __NR_pread64

#endif

#ifndef __NR_pwrite

# define __NR_pwrite __NR_pwrite64

#endif

#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 gpr2 is a real error

   number.  Linus said he will make sure that no syscall returns a value

   in -1 .. -4095 as a valid result so we can savely test with -4095.  */

#undef PSEUDO

#define	PSEUDO(name, syscall_name, args)				      \

  .text;								      \

  ENTRY (name)								      \

    DO_CALL (syscall_name, args);					      \

    lghi %r4,-4095 ;							      \

    clgr %r2,%r4 ;							      \

    jgnl 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)					      \

  SYSCALL_ERROR_HANDLER;						      \

  END (name)

#undef PSEUDO_ERRVAL

#define	PSEUDO_ERRVAL(name, syscall_name, args)				      \

  .text;								      \

  ENTRY (name)								      \

    DO_CALL (syscall_name, args);					      \

    lcgr %r2,%r2

#undef PSEUDO_END_ERRVAL

#define PSEUDO_END_ERRVAL(name)						      \

  SYSCALL_ERROR_HANDLER;						      \

  END (name)

#ifndef PIC

# define SYSCALL_ERROR_LABEL syscall_error

# define SYSCALL_ERROR_HANDLER

#else

# if RTLD_PRIVATE_ERRNO

#  define SYSCALL_ERROR_LABEL 0f

#  define SYSCALL_ERROR_HANDLER \

0:  larl  %r1,rtld_errno;						      \

    lcr   %r2,%r2;							      \

    st    %r2,0(%r1);							      \

    lghi  %r2,-1;							      \

    br    %r14

# elif defined _LIBC_REENTRANT

#  if IS_IN (libc)

#   define SYSCALL_ERROR_ERRNO __libc_errno

#  else

#   define SYSCALL_ERROR_ERRNO errno

#  endif

#  define SYSCALL_ERROR_LABEL 0f

#  define SYSCALL_ERROR_HANDLER \

0:  lcr   %r0,%r2;							      \

    larl  %r1,SYSCALL_ERROR_ERRNO@indntpoff;				      \

    lg    %r1,0(%r1);							      \

    ear   %r2,%a0;							      \

    sllg  %r2,%r2,32;							      \

    ear   %r2,%a1;							      \

    st    %r0,0(%r1,%r2);						      \

    lghi   %r2,-1;							      \

    br    %r14

# else

#  define SYSCALL_ERROR_LABEL 0f

#  define SYSCALL_ERROR_HANDLER \

0:  larl  %r1,_GLOBAL_OFFSET_TABLE_;					      \

    lg    %r1,errno@GOT(%r1);						      \

    lcr   %r2,%r2;							      \

    st    %r2,0(%r1);							      \

    lghi  %r2,-1;							      \

    br    %r14

# endif /* _LIBC_REENTRANT */

#endif /* PIC */

/* Linux takes system call arguments in registers:

	syscall number	1	     call-clobbered

	arg 1		2	     call-clobbered

	arg 2		3	     call-clobbered

	arg 3		4	     call-clobbered

	arg 4		5	     call-clobbered

	arg 5		6	     call-saved

	arg 6		7	     call-saved

   (Of course a function with say 3 arguments does not have entries for

   arguments 4 and 5.)

   For system calls with 6 parameters a stack operation is required

   to load the 6th parameter to register 7. Call saved register 7 is

   moved to register 0 and back to avoid an additional stack frame.

 */

#define DO_CALL(syscall, args)						      \

  .if args > 5;								      \

    lgr %r0,%r7;							      \

    lg %r7,160(%r15);							      \

  .endif;								      \

  .if SYS_ify (syscall) < 256;						      \

    svc SYS_ify (syscall);						      \

  .else;								      \

    lghi %r1,SYS_ify (syscall);						      \

    svc 0;								      \

  .endif;								      \

  .if args > 5;								      \

    lgr %r7,%r0;							      \

  .endif

#define ret								      \

    br	    14

#define ret_NOERRNO							      \

    br	    14

#define ret_ERRVAL							      \

    br	    14

#endif /* __ASSEMBLER__ */

#undef INLINE_SYSCALL

#define INLINE_SYSCALL(name, nr, args...)				      \

  ({									      \

    long _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...)			      \

  ({									      \

    DECLARGS_##nr(args)							      \

    register long _ret __asm__("2");					      \

    __asm__ __volatile__ (						      \

			  "svc    %b1\n\t"				      \

			  : "=d" (_ret)					      \

			  : "i" (__NR_##name) ASMFMT_##nr		      \

			  : "memory" );					      \

    _ret; })

#undef INTERNAL_SYSCALL_SVC0

#define INTERNAL_SYSCALL_SVC0(name, err, nr, args...)			      \

  ({									      \

    DECLARGS_##nr(args)							      \

    register unsigned long _nr __asm__("1") = (unsigned long)(__NR_##name);   \

    register long _ret __asm__("2");					      \

    __asm__ __volatile__ (						      \

			  "svc    0\n\t"				      \

			  : "=d" (_ret)					      \

			  : "d" (_nr) ASMFMT_##nr			      \

			  : "memory" );					      \

    _ret; })

#undef INTERNAL_SYSCALL_NCS

#define INTERNAL_SYSCALL_NCS(no, err, nr, args...)			      \

  ({									      \

    DECLARGS_##nr(args)							      \

    register unsigned long _nr __asm__("1") = (unsigned long)(no);	      \

    register long _ret __asm__("2");					      \

    __asm__ __volatile__ (						      \

			  "svc    0\n\t"				      \

			  : "=d" (_ret)					      \

			  : "d" (_nr) ASMFMT_##nr			      \

			  : "memory" );					      \

    _ret; })

#undef INTERNAL_SYSCALL

#define INTERNAL_SYSCALL(name, err, nr, args...)			      \

  (((__NR_##name) < 256) ?						      \

    INTERNAL_SYSCALL_DIRECT(name, err, nr, args) :			      \

    INTERNAL_SYSCALL_SVC0(name, err,nr, args))

#undef INTERNAL_SYSCALL_ERROR_P

#define INTERNAL_SYSCALL_ERROR_P(val, err)				      \

  ((unsigned long) (val) >= -4095UL)

#undef INTERNAL_SYSCALL_ERRNO

#define INTERNAL_SYSCALL_ERRNO(val, err)	(-(val))

#define DECLARGS_0()

#define DECLARGS_1(arg1) \

	register unsigned long gpr2 __asm__ ("2") = (unsigned long)(arg1);

#define DECLARGS_2(arg1, arg2) \

	DECLARGS_1(arg1) \

	register unsigned long gpr3 __asm__ ("3") = (unsigned long)(arg2);

#define DECLARGS_3(arg1, arg2, arg3) \

	DECLARGS_2(arg1, arg2) \

	register unsigned long gpr4 __asm__ ("4") = (unsigned long)(arg3);

#define DECLARGS_4(arg1, arg2, arg3, arg4) \

	DECLARGS_3(arg1, arg2, arg3) \

	register unsigned long gpr5 __asm__ ("5") = (unsigned long)(arg4);

#define DECLARGS_5(arg1, arg2, arg3, arg4, arg5) \

	DECLARGS_4(arg1, arg2, arg3, arg4) \

	register unsigned long gpr6 __asm__ ("6") = (unsigned long)(arg5);

#define DECLARGS_6(arg1, arg2, arg3, arg4, arg5, arg6) \

	DECLARGS_5(arg1, arg2, arg3, arg4, arg5) \

	register unsigned long gpr7 __asm__ ("7") = (unsigned long)(arg6);

#define ASMFMT_0

#define ASMFMT_1 , "0" (gpr2)

#define ASMFMT_2 , "0" (gpr2), "d" (gpr3)

#define ASMFMT_3 , "0" (gpr2), "d" (gpr3), "d" (gpr4)

#define ASMFMT_4 , "0" (gpr2), "d" (gpr3), "d" (gpr4), "d" (gpr5)

#define ASMFMT_5 , "0" (gpr2), "d" (gpr3), "d" (gpr4), "d" (gpr5), "d" (gpr6)

#define ASMFMT_6 , "0" (gpr2), "d" (gpr3), "d" (gpr4), "d" (gpr5), "d" (gpr6), "d" (gpr7)

/* List of system calls which are supported as vsyscalls.  */

#define HAVE_CLOCK_GETRES_VSYSCALL	1

#define HAVE_CLOCK_GETTIME_VSYSCALL	1

#define HAVE_GETTIMEOFDAY_VSYSCALL	1

#define HAVE_GETCPU_VSYSCALL		1

#define SINGLE_THREAD_BY_GLOBAL		1

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

#else

/* For the time being just use stack_guard rather than a separate

   pointer_guard.  */

# ifdef __ASSEMBLER__

#  define PTR_MANGLE(reg, tmpreg) \

  ear     tmpreg,%a0;			\

  sllg    tmpreg,tmpreg,32;		\

  ear     tmpreg,%a1;			\

  xg      reg,STACK_GUARD(tmpreg)

#  define PTR_MANGLE2(reg, tmpreg) \

  xg      reg,STACK_GUARD(tmpreg)

#  define PTR_DEMANGLE(reg, tmpreg) PTR_MANGLE (reg, tmpreg)

# else

#  define PTR_MANGLE(var) \

  (var) = (void *) ((uintptr_t) (var) ^ THREAD_GET_POINTER_GUARD ())

#  define PTR_DEMANGLE(var)	PTR_MANGLE (var)

# endif

#endif

#endif /* _LINUX_S390_SYSDEP_H */