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

/* Copyright (C) 2000-2018 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
   <http://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__ */

#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
688903eb	1	/* Copyright (C) 2000-2018 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 PE	16	License along with the GNU C Library; if not, see
59ba27a6 PE	17	<http://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
4d76a0ec	37	#undef INLINE_SYSCALL
3ba57516 DM	38	#define INLINE_SYSCALL(name, nr, args...) \
3ba57516 DM	39	({ INTERNAL_SYSCALL_DECL(err); \
a1bcbd40	40	unsigned long resultvar = INTERNAL_SYSCALL(name, err, nr, args);\
e9258400	41	if (INTERNAL_SYSCALL_ERROR_P (resultvar, err)) \
3ba57516 DM	42	{ \
3ba57516 DM	43	__set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, err)); \
a1bcbd40	44	resultvar = (unsigned long) -1; \
3ba57516	45	} \
a1bcbd40	46	(long) resultvar; \
3ba57516	47	})
4d76a0ec	48
6aca81bb	49	#undef INTERNAL_SYSCALL_DECL
3ba57516 DM	50	#define INTERNAL_SYSCALL_DECL(err) \
3ba57516 DM	51	register long err __asm__("g1");
6aca81bb	52
369b849f	53	#undef INTERNAL_SYSCALL
6aca81bb	54	#define INTERNAL_SYSCALL(name, err, nr, args...) \
3ba57516	55	inline_syscall##nr(__SYSCALL_STRING, err, __NR_##name, args)
bbb5e55c UD	56
	57	#undef INTERNAL_SYSCALL_NCS
	58	#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
3ba57516	59	inline_syscall##nr(__SYSCALL_STRING, err, name, args)
369b849f RM	60
369b849f RM	61	#undef INTERNAL_SYSCALL_ERROR_P
e9258400 DM	62	#define INTERNAL_SYSCALL_ERROR_P(val, err) \
e9258400 DM	63	((void) (val), __builtin_expect((err) != 0, 0))
369b849f RM	64
369b849f RM	65	#undef INTERNAL_SYSCALL_ERRNO
6aca81bb	66	#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
369b849f	67
3ba57516	68	#define inline_syscall0(string,err,name,dummy...) \
4d76a0ec UD	69	({ \
4d76a0ec UD	70	register long __o0 __asm__ ("o0"); \
3ba57516 DM	71	err = name; \
	72	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	73	"0" (err) : \
72d4c33d	74	__SYSCALL_CLOBBERS); \
4d76a0ec UD	75	__o0; \
	76	})
	77
3ba57516	78	#define inline_syscall1(string,err,name,arg1) \
4d76a0ec UD	79	({ \
4d76a0ec UD	80	register long __o0 __asm__ ("o0") = (long)(arg1); \
3ba57516 DM	81	err = name; \
	82	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	83	"0" (err), "1" (__o0) : \
72d4c33d	84	__SYSCALL_CLOBBERS); \
4d76a0ec UD	85	__o0; \
	86	})
	87
3ba57516	88	#define inline_syscall2(string,err,name,arg1,arg2) \
4d76a0ec UD	89	({ \
	90	register long __o0 __asm__ ("o0") = (long)(arg1); \
	91	register long __o1 __asm__ ("o1") = (long)(arg2); \
3ba57516 DM	92	err = name; \
	93	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	94	"0" (err), "1" (__o0), "r" (__o1) : \
72d4c33d	95	__SYSCALL_CLOBBERS); \
4d76a0ec UD	96	__o0; \
	97	})
	98
3ba57516	99	#define inline_syscall3(string,err,name,arg1,arg2,arg3) \
4d76a0ec UD	100	({ \
	101	register long __o0 __asm__ ("o0") = (long)(arg1); \
	102	register long __o1 __asm__ ("o1") = (long)(arg2); \
	103	register long __o2 __asm__ ("o2") = (long)(arg3); \
3ba57516 DM	104	err = name; \
	105	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	106	"0" (err), "1" (__o0), "r" (__o1), \
72d4c33d RM	107	"r" (__o2) : \
72d4c33d RM	108	__SYSCALL_CLOBBERS); \
4d76a0ec UD	109	__o0; \
	110	})
	111
3ba57516	112	#define inline_syscall4(string,err,name,arg1,arg2,arg3,arg4) \
4d76a0ec UD	113	({ \
	114	register long __o0 __asm__ ("o0") = (long)(arg1); \
	115	register long __o1 __asm__ ("o1") = (long)(arg2); \
	116	register long __o2 __asm__ ("o2") = (long)(arg3); \
	117	register long __o3 __asm__ ("o3") = (long)(arg4); \
3ba57516 DM	118	err = name; \
	119	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	120	"0" (err), "1" (__o0), "r" (__o1), \
72d4c33d RM	121	"r" (__o2), "r" (__o3) : \
72d4c33d RM	122	__SYSCALL_CLOBBERS); \
4d76a0ec UD	123	__o0; \
	124	})
	125
3ba57516	126	#define inline_syscall5(string,err,name,arg1,arg2,arg3,arg4,arg5) \
4d76a0ec UD	127	({ \
	128	register long __o0 __asm__ ("o0") = (long)(arg1); \
	129	register long __o1 __asm__ ("o1") = (long)(arg2); \
	130	register long __o2 __asm__ ("o2") = (long)(arg3); \
	131	register long __o3 __asm__ ("o3") = (long)(arg4); \
	132	register long __o4 __asm__ ("o4") = (long)(arg5); \
3ba57516 DM	133	err = name; \
	134	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	135	"0" (err), "1" (__o0), "r" (__o1), \
72d4c33d RM	136	"r" (__o2), "r" (__o3), "r" (__o4) : \
72d4c33d RM	137	__SYSCALL_CLOBBERS); \
4d76a0ec UD	138	__o0; \
	139	})
	140
3ba57516	141	#define inline_syscall6(string,err,name,arg1,arg2,arg3,arg4,arg5,arg6) \
4d76a0ec UD	142	({ \
	143	register long __o0 __asm__ ("o0") = (long)(arg1); \
	144	register long __o1 __asm__ ("o1") = (long)(arg2); \
	145	register long __o2 __asm__ ("o2") = (long)(arg3); \
	146	register long __o3 __asm__ ("o3") = (long)(arg4); \
	147	register long __o4 __asm__ ("o4") = (long)(arg5); \
	148	register long __o5 __asm__ ("o5") = (long)(arg6); \
3ba57516 DM	149	err = name; \
	150	__asm __volatile (string : "=r" (err), "=r" (__o0) : \
	151	"0" (err), "1" (__o0), "r" (__o1), \
72d4c33d RM	152	"r" (__o2), "r" (__o3), "r" (__o4), \
	153	"r" (__o5) : \
	154	__SYSCALL_CLOBBERS); \
4d76a0ec UD	155	__o0; \
	156	})
	157
cd2fbe58 UD	158	#define INLINE_CLONE_SYSCALL(arg1,arg2,arg3,arg4,arg5) \
	159	({ \
	160	register long __o0 __asm__ ("o0") = (long)(arg1); \
	161	register long __o1 __asm__ ("o1") = (long)(arg2); \
	162	register long __o2 __asm__ ("o2") = (long)(arg3); \
	163	register long __o3 __asm__ ("o3") = (long)(arg4); \
	164	register long __o4 __asm__ ("o4") = (long)(arg5); \
	165	register long __g1 __asm__ ("g1") = __NR_clone; \
3ba57516	166	__asm __volatile (__SYSCALL_STRING : \
cd2fbe58 UD	167	"=r" (__g1), "=r" (__o0), "=r" (__o1) : \
	168	"0" (__g1), "1" (__o0), "2" (__o1), \
	169	"r" (__o2), "r" (__o3), "r" (__o4) : \
	170	__SYSCALL_CLOBBERS); \
e9258400	171	if (INTERNAL_SYSCALL_ERROR_P (__o0, __g1)) \
3ba57516 DM	172	{ \
	173	__set_errno (INTERNAL_SYSCALL_ERRNO (__o0, __g1)); \
	174	__o0 = -1L; \
	175	} \
	176	else \
	177	{ \
	178	__o0 &= (__o1 - 1); \
	179	} \
cd2fbe58 UD	180	__o0; \
	181	})
	182
aab39a09	183	#endif /* __ASSEMBLER__ */
cd2fbe58	184
4d76a0ec	185	#endif /* _LINUX_SPARC_SYSDEP_H */