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

/* Copyright (C) 2000-2019 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Jakub Jelinek <jakub@redhat.com>, 2000.

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

#ifndef _LINUX_SPARC_SYSDEP_H
#define _LINUX_SPARC_SYSDEP_H 1

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

#ifdef __ASSEMBLER__

#define	ret		retl; nop
#define	ret_NOERRNO	retl; nop
#define	ret_ERRVAL	retl; nop
#define	r0		%o0
#define	r1		%o1
#define	MOVE(x,y)	mov x, y

#else	/* __ASSEMBLER__ */

#define INTERNAL_VSYSCALL_CALL(funcptr, err, nr, args...)		\
  ({									\
    long _ret = funcptr (args);						\
    err = ((unsigned long) (_ret) >= (unsigned long) -4095L);		\
    _ret;								\
  })

/* List of system calls which are supported as vsyscalls.  */
# define HAVE_CLOCK_GETTIME_VSYSCALL	1
# define HAVE_GETTIMEOFDAY_VSYSCALL	1

#undef INLINE_SYSCALL
#define INLINE_SYSCALL(name, nr, args...) 				\
({	INTERNAL_SYSCALL_DECL(err);  					\
	unsigned long resultvar = INTERNAL_SYSCALL(name, err, nr, args);\
	if (INTERNAL_SYSCALL_ERROR_P (resultvar, err))			\
	  {		     			       		   	\
	    __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, err));	\
	    resultvar = (unsigned long) -1;				\
	  } 	      							\
	(long) resultvar;						\
})

#undef INTERNAL_SYSCALL_DECL
#define INTERNAL_SYSCALL_DECL(err) \
	register long err __asm__("g1");

#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL(name, err, nr, args...) \
  inline_syscall##nr(__SYSCALL_STRING, err, __NR_##name, args)

#undef INTERNAL_SYSCALL_NCS
#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
  inline_syscall##nr(__SYSCALL_STRING, err, name, args)

#undef INTERNAL_SYSCALL_ERROR_P
#define INTERNAL_SYSCALL_ERROR_P(val, err) \
  ((void) (val), __builtin_expect((err) != 0, 0))

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

#define inline_syscall0(string,err,name,dummy...)			\
({									\
	register long __o0 __asm__ ("o0");				\
	err = name;							\
	__asm __volatile (string : "=r" (err), "=r" (__o0) :		\
			  "0" (err) :					\
			  __SYSCALL_CLOBBERS);				\
	__o0;								\
})

#define inline_syscall1(string,err,name,arg1)				\
({									\
	register long __o0 __asm__ ("o0") = (long)(arg1);		\
	err = name;							\
	__asm __volatile (string : "=r" (err), "=r" (__o0) :		\
			  "0" (err), "1" (__o0) :			\
			  __SYSCALL_CLOBBERS);				\
	__o0;								\
})

#define inline_syscall2(string,err,name,arg1,arg2)			\
({									\
	register long __o0 __asm__ ("o0") = (long)(arg1);		\
	register long __o1 __asm__ ("o1") = (long)(arg2);		\
	err = name;							\
	__asm __volatile (string : "=r" (err), "=r" (__o0) :		\
			  "0" (err), "1" (__o0), "r" (__o1) :		\
			  __SYSCALL_CLOBBERS);				\
	__o0;								\
})

#define inline_syscall3(string,err,name,arg1,arg2,arg3)			\
({									\
	register long __o0 __asm__ ("o0") = (long)(arg1);		\
	register long __o1 __asm__ ("o1") = (long)(arg2);		\
	register long __o2 __asm__ ("o2") = (long)(arg3);		\
	err = name;							\
	__asm __volatile (string : "=r" (err), "=r" (__o0) :		\
			  "0" (err), "1" (__o0), "r" (__o1),		\
			  "r" (__o2) :					\
			  __SYSCALL_CLOBBERS);				\
	__o0;								\
})

#define inline_syscall4(string,err,name,arg1,arg2,arg3,arg4)		\
({									\
	register long __o0 __asm__ ("o0") = (long)(arg1);		\
	register long __o1 __asm__ ("o1") = (long)(arg2);		\
	register long __o2 __asm__ ("o2") = (long)(arg3);		\
	register long __o3 __asm__ ("o3") = (long)(arg4);		\
	err = name;							\
	__asm __volatile (string : "=r" (err), "=r" (__o0) :		\
			  "0" (err), "1" (__o0), "r" (__o1),		\
			  "r" (__o2), "r" (__o3) :			\
			  __SYSCALL_CLOBBERS);				\
	__o0;								\
})

#define inline_syscall5(string,err,name,arg1,arg2,arg3,arg4,arg5)	\
({									\
	register long __o0 __asm__ ("o0") = (long)(arg1);		\
	register long __o1 __asm__ ("o1") = (long)(arg2);		\
	register long __o2 __asm__ ("o2") = (long)(arg3);		\
	register long __o3 __asm__ ("o3") = (long)(arg4);		\
	register long __o4 __asm__ ("o4") = (long)(arg5);		\
	err = name;							\
	__asm __volatile (string : "=r" (err), "=r" (__o0) :		\
			  "0" (err), "1" (__o0), "r" (__o1),		\
			  "r" (__o2), "r" (__o3), "r" (__o4) :		\
			  __SYSCALL_CLOBBERS);				\
	__o0;								\
})

#define inline_syscall6(string,err,name,arg1,arg2,arg3,arg4,arg5,arg6)	\
({									\
	register long __o0 __asm__ ("o0") = (long)(arg1);		\
	register long __o1 __asm__ ("o1") = (long)(arg2);		\
	register long __o2 __asm__ ("o2") = (long)(arg3);		\
	register long __o3 __asm__ ("o3") = (long)(arg4);		\
	register long __o4 __asm__ ("o4") = (long)(arg5);		\
	register long __o5 __asm__ ("o5") = (long)(arg6);		\
	err = name;							\
	__asm __volatile (string : "=r" (err), "=r" (__o0) :		\
			  "0" (err), "1" (__o0), "r" (__o1),		\
			  "r" (__o2), "r" (__o3), "r" (__o4),		\
			  "r" (__o5) :					\
			  __SYSCALL_CLOBBERS);				\
	__o0;								\
})

#define INLINE_CLONE_SYSCALL(arg1,arg2,arg3,arg4,arg5)			\
({									\
	register long __o0 __asm__ ("o0") = (long)(arg1);		\
	register long __o1 __asm__ ("o1") = (long)(arg2);		\
	register long __o2 __asm__ ("o2") = (long)(arg3);		\
	register long __o3 __asm__ ("o3") = (long)(arg4);		\
	register long __o4 __asm__ ("o4") = (long)(arg5);		\
	register long __g1 __asm__ ("g1") = __NR_clone;			\
	__asm __volatile (__SYSCALL_STRING :				\
			  "=r" (__g1), "=r" (__o0), "=r" (__o1)	:	\
			  "0" (__g1), "1" (__o0), "2" (__o1),		\
			  "r" (__o2), "r" (__o3), "r" (__o4) :		\
			  __SYSCALL_CLOBBERS);				\
	if (INTERNAL_SYSCALL_ERROR_P (__o0, __g1))			\
	  {		     			       		   	\
	    __set_errno (INTERNAL_SYSCALL_ERRNO (__o0, __g1));		\
	    __o0 = -1L;			    				\
	  } 	      							\
	else								\
	  { 	      							\
	    __o0 &= (__o1 - 1);						\
	  } 	    	    						\
	__o0;								\
})

#endif	/* __ASSEMBLER__ */

#endif /* _LINUX_SPARC_SYSDEP_H */
Commit	Line	Data
04277e02	1	/* Copyright (C) 2000-2019 Free Software Foundation, Inc.
4d76a0ec UD	2	This file is part of the GNU C Library.
	3	Contributed by Jakub Jelinek <jakub@redhat.com>, 2000.
	4
	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.
4d76a0ec 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.
4d76a0ec	14
41bdb6e2	15	You should have received a copy of the GNU Lesser General Public
59ba27a6	16	License along with the GNU C Library; if not, see
5a82c748	17	<https://www.gnu.org/licenses/>. */
4d76a0ec UD	18
	19	#ifndef _LINUX_SPARC_SYSDEP_H
	20	#define _LINUX_SPARC_SYSDEP_H 1
	21
aab39a09	22	#include <sysdeps/unix/sysdep.h>
fb1cf108	23	#include <sysdeps/unix/sysv/linux/sysdep.h>
aab39a09 DM	24	#include <sysdeps/sparc/sysdep.h>
	25
	26	#ifdef __ASSEMBLER__
	27
	28	#define ret retl; nop
	29	#define ret_NOERRNO retl; nop
	30	#define ret_ERRVAL retl; nop
	31	#define r0 %o0
	32	#define r1 %o1
	33	#define MOVE(x,y) mov x, y
	34
	35	#else /* __ASSEMBLER__ */
	36
94a3a27f DM	37	#define INTERNAL_VSYSCALL_CALL(funcptr, err, nr, args...) \
	38	({ \
	39	long _ret = funcptr (args); \
	40	err = ((unsigned long) (_ret) >= (unsigned long) -4095L); \
	41	_ret; \
	42	})
	43
	44	/* List of system calls which are supported as vsyscalls. */
	45	# define HAVE_CLOCK_GETTIME_VSYSCALL 1
	46	# define HAVE_GETTIMEOFDAY_VSYSCALL 1
	47
4d76a0ec	48	#undef INLINE_SYSCALL
3ba57516 DM	49	#define INLINE_SYSCALL(name, nr, args...) \
3ba57516 DM	50	({ INTERNAL_SYSCALL_DECL(err); \
a1bcbd40	51	unsigned long resultvar = INTERNAL_SYSCALL(name, err, nr, args);\
e9258400	52	if (INTERNAL_SYSCALL_ERROR_P (resultvar, err)) \
3ba57516 DM	53	{ \
3ba57516 DM	54	__set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, err)); \
a1bcbd40	55	resultvar = (unsigned long) -1; \
3ba57516	56	} \
a1bcbd40	57	(long) resultvar; \
3ba57516	58	})
4d76a0ec	59
6aca81bb	60	#undef INTERNAL_SYSCALL_DECL
3ba57516 DM	61	#define INTERNAL_SYSCALL_DECL(err) \
3ba57516 DM	62	register long err __asm__("g1");
6aca81bb	63
369b849f	64	#undef INTERNAL_SYSCALL
6aca81bb	65	#define INTERNAL_SYSCALL(name, err, nr, args...) \
3ba57516	66	inline_syscall##nr(__SYSCALL_STRING, err, __NR_##name, args)
bbb5e55c UD	67
	68	#undef INTERNAL_SYSCALL_NCS
	69	#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
3ba57516	70	inline_syscall##nr(__SYSCALL_STRING, err, name, args)
369b849f RM	71
369b849f RM	72	#undef INTERNAL_SYSCALL_ERROR_P
e9258400 DM	73	#define INTERNAL_SYSCALL_ERROR_P(val, err) \
e9258400 DM	74	((void) (val), __builtin_expect((err) != 0, 0))
369b849f RM	75
369b849f RM	76	#undef INTERNAL_SYSCALL_ERRNO
6aca81bb	77	#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
369b849f	78
3ba57516	79	#define inline_syscall0(string,err,name,dummy...) \
4d76a0ec UD	80	({ \
4d76a0ec UD	81	register long __o0 __asm__ ("o0"); \
3ba57516 DM	82	err = name; \
	83	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	84	"0" (err) : \
72d4c33d	85	__SYSCALL_CLOBBERS); \
4d76a0ec UD	86	__o0; \
	87	})
	88
3ba57516	89	#define inline_syscall1(string,err,name,arg1) \
4d76a0ec UD	90	({ \
4d76a0ec UD	91	register long __o0 __asm__ ("o0") = (long)(arg1); \
3ba57516 DM	92	err = name; \
	93	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	94	"0" (err), "1" (__o0) : \
72d4c33d	95	__SYSCALL_CLOBBERS); \
4d76a0ec UD	96	__o0; \
	97	})
	98
3ba57516	99	#define inline_syscall2(string,err,name,arg1,arg2) \
4d76a0ec UD	100	({ \
	101	register long __o0 __asm__ ("o0") = (long)(arg1); \
	102	register long __o1 __asm__ ("o1") = (long)(arg2); \
3ba57516 DM	103	err = name; \
	104	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	105	"0" (err), "1" (__o0), "r" (__o1) : \
72d4c33d	106	__SYSCALL_CLOBBERS); \
4d76a0ec UD	107	__o0; \
	108	})
	109
3ba57516	110	#define inline_syscall3(string,err,name,arg1,arg2,arg3) \
4d76a0ec UD	111	({ \
	112	register long __o0 __asm__ ("o0") = (long)(arg1); \
	113	register long __o1 __asm__ ("o1") = (long)(arg2); \
	114	register long __o2 __asm__ ("o2") = (long)(arg3); \
3ba57516 DM	115	err = name; \
	116	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	117	"0" (err), "1" (__o0), "r" (__o1), \
72d4c33d RM	118	"r" (__o2) : \
72d4c33d RM	119	__SYSCALL_CLOBBERS); \
4d76a0ec UD	120	__o0; \
	121	})
	122
3ba57516	123	#define inline_syscall4(string,err,name,arg1,arg2,arg3,arg4) \
4d76a0ec UD	124	({ \
	125	register long __o0 __asm__ ("o0") = (long)(arg1); \
	126	register long __o1 __asm__ ("o1") = (long)(arg2); \
	127	register long __o2 __asm__ ("o2") = (long)(arg3); \
	128	register long __o3 __asm__ ("o3") = (long)(arg4); \
3ba57516 DM	129	err = name; \
	130	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	131	"0" (err), "1" (__o0), "r" (__o1), \
72d4c33d RM	132	"r" (__o2), "r" (__o3) : \
72d4c33d RM	133	__SYSCALL_CLOBBERS); \
4d76a0ec UD	134	__o0; \
	135	})
	136
3ba57516	137	#define inline_syscall5(string,err,name,arg1,arg2,arg3,arg4,arg5) \
4d76a0ec UD	138	({ \
	139	register long __o0 __asm__ ("o0") = (long)(arg1); \
	140	register long __o1 __asm__ ("o1") = (long)(arg2); \
	141	register long __o2 __asm__ ("o2") = (long)(arg3); \
	142	register long __o3 __asm__ ("o3") = (long)(arg4); \
	143	register long __o4 __asm__ ("o4") = (long)(arg5); \
3ba57516 DM	144	err = name; \
	145	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	146	"0" (err), "1" (__o0), "r" (__o1), \
72d4c33d RM	147	"r" (__o2), "r" (__o3), "r" (__o4) : \
72d4c33d RM	148	__SYSCALL_CLOBBERS); \
4d76a0ec UD	149	__o0; \
	150	})
	151
3ba57516	152	#define inline_syscall6(string,err,name,arg1,arg2,arg3,arg4,arg5,arg6) \
4d76a0ec UD	153	({ \
	154	register long __o0 __asm__ ("o0") = (long)(arg1); \
	155	register long __o1 __asm__ ("o1") = (long)(arg2); \
	156	register long __o2 __asm__ ("o2") = (long)(arg3); \
	157	register long __o3 __asm__ ("o3") = (long)(arg4); \
	158	register long __o4 __asm__ ("o4") = (long)(arg5); \
	159	register long __o5 __asm__ ("o5") = (long)(arg6); \
3ba57516 DM	160	err = name; \
	161	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	162	"0" (err), "1" (__o0), "r" (__o1), \
72d4c33d RM	163	"r" (__o2), "r" (__o3), "r" (__o4), \
	164	"r" (__o5) : \
	165	__SYSCALL_CLOBBERS); \
4d76a0ec UD	166	__o0; \
	167	})
	168
cd2fbe58 UD	169	#define INLINE_CLONE_SYSCALL(arg1,arg2,arg3,arg4,arg5) \
	170	({ \
	171	register long __o0 __asm__ ("o0") = (long)(arg1); \
	172	register long __o1 __asm__ ("o1") = (long)(arg2); \
	173	register long __o2 __asm__ ("o2") = (long)(arg3); \
	174	register long __o3 __asm__ ("o3") = (long)(arg4); \
	175	register long __o4 __asm__ ("o4") = (long)(arg5); \
	176	register long __g1 __asm__ ("g1") = __NR_clone; \
3ba57516	177	__asm __volatile (__SYSCALL_STRING : \
cd2fbe58 UD	178	"=r" (__g1), "=r" (__o0), "=r" (__o1) : \
	179	"0" (__g1), "1" (__o0), "2" (__o1), \
	180	"r" (__o2), "r" (__o3), "r" (__o4) : \
	181	__SYSCALL_CLOBBERS); \
e9258400	182	if (INTERNAL_SYSCALL_ERROR_P (__o0, __g1)) \
3ba57516 DM	183	{ \
	184	__set_errno (INTERNAL_SYSCALL_ERRNO (__o0, __g1)); \
	185	__o0 = -1L; \
	186	} \
	187	else \
	188	{ \
	189	__o0 &= (__o1 - 1); \
	190	} \
cd2fbe58 UD	191	__o0; \
	192	})
	193
aab39a09	194	#endif /* __ASSEMBLER__ */
cd2fbe58	195
4d76a0ec	196	#endif /* _LINUX_SPARC_SYSDEP_H */