[thirdparty/glibc.git] / sysdeps / unix / sysv / linux / mips / mips64 / n32 / sysdep.h

/* Copyright (C) 2000, 2002, 2003, 2004, 2005, 2006
   Free Software Foundation, Inc.
   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, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#ifndef _LINUX_MIPS_SYSDEP_H
#define _LINUX_MIPS_SYSDEP_H 1

/* There is some commonality.  */
#include <sysdeps/unix/mips/mips64/n32/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
#ifdef __STDC__
# define SYS_ify(syscall_name)	__NR_##syscall_name
#else
# define SYS_ify(syscall_name)	__NR_/**/syscall_name
#endif

#ifdef __ASSEMBLER__

/* 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 99b
#endif

#else   /* ! __ASSEMBLER__ */

/* Convert X to a long long, without losing any bits if it is one
   already or warning if it is a 32-bit pointer.  */
#define ARGIFY(X) ((long long) (__typeof__ ((X) - (X))) (X))

/* Define a macro which expands into the inline wrapper code for a system
   call.  */
#undef INLINE_SYSCALL
#define INLINE_SYSCALL(name, nr, args...)                               \
  ({ INTERNAL_SYSCALL_DECL(err);					\
     long result_var = INTERNAL_SYSCALL (name, err, nr, args);      	\
     if ( INTERNAL_SYSCALL_ERROR_P (result_var, err) )  		\
       {                                                                \
         __set_errno (INTERNAL_SYSCALL_ERRNO (result_var, err));      	\
         result_var = -1L;                               		\
       }                                                                \
     result_var; })

#undef INTERNAL_SYSCALL_DECL
#define INTERNAL_SYSCALL_DECL(err) long err

#undef INTERNAL_SYSCALL_ERROR_P
#define INTERNAL_SYSCALL_ERROR_P(val, err)   ((long) (err))

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

#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL(name, err, nr, args...) \
	internal_syscall##nr (, "li\t$2, %2\t\t\t# " #name "\n\t",	\
			      "i" (SYS_ify (name)), err, args)

#undef INTERNAL_SYSCALL_NCS
#define INTERNAL_SYSCALL_NCS(number, err, nr, args...) \
	internal_syscall##nr (= number, , "r" (__v0), err, args)

#define internal_syscall0(ncs_init, cs_init, input, err, dummy...)	\
({ 									\
	long _sys_result;						\
									\
	{								\
	register long long __v0 asm("$2") ncs_init;			\
	register long long __a3 asm("$7");				\
	__asm__ volatile ( 						\
	".set\tnoreorder\n\t" 						\
	cs_init								\
	"syscall\n\t" 							\
	".set reorder" 							\
	: "=r" (__v0), "=r" (__a3) 					\
	: input								\
	: __SYSCALL_CLOBBERS); 						\
	err = __a3;							\
	_sys_result = __v0;						\
	}								\
	_sys_result;							\
})

#define internal_syscall1(ncs_init, cs_init, input, err, arg1)		\
({ 									\
	long _sys_result;						\
									\
	{								\
	register long long __v0 asm("$2") ncs_init;			\
	register long long __a0 asm("$4") = ARGIFY (arg1); 		\
	register long long __a3 asm("$7"); 				\
	__asm__ volatile ( 						\
	".set\tnoreorder\n\t" 						\
	cs_init								\
	"syscall\n\t" 							\
	".set reorder" 							\
	: "=r" (__v0), "=r" (__a3) 					\
	: input, "r" (__a0)		 				\
	: __SYSCALL_CLOBBERS); 						\
	err = __a3;							\
	_sys_result = __v0;						\
	}								\
	_sys_result;							\
})

#define internal_syscall2(ncs_init, cs_init, input, err, arg1, arg2)	\
({ 									\
	long _sys_result;						\
									\
	{								\
	register long long __v0 asm("$2") ncs_init;			\
	register long long __a0 asm("$4") = ARGIFY (arg1); 		\
	register long long __a1 asm("$5") = ARGIFY (arg2); 		\
	register long long __a3 asm("$7"); 				\
	__asm__ volatile ( 						\
	".set\tnoreorder\n\t" 						\
	cs_init								\
	"syscall\n\t" 							\
	".set\treorder" 						\
	: "=r" (__v0), "=r" (__a3) 					\
	: input, "r" (__a0), "r" (__a1)					\
	: __SYSCALL_CLOBBERS); 						\
	err = __a3;							\
	_sys_result = __v0;						\
	}								\
	_sys_result;							\
})

#define internal_syscall3(ncs_init, cs_init, input, err, arg1, arg2, arg3) \
({ 									\
	long _sys_result;						\
									\
	{								\
	register long long __v0 asm("$2") ncs_init;			\
	register long long __a0 asm("$4") = ARGIFY (arg1); 		\
	register long long __a1 asm("$5") = ARGIFY (arg2); 		\
	register long long __a2 asm("$6") = ARGIFY (arg3); 		\
	register long long __a3 asm("$7"); 				\
	__asm__ volatile ( 						\
	".set\tnoreorder\n\t" 						\
	cs_init								\
	"syscall\n\t" 							\
	".set\treorder" 						\
	: "=r" (__v0), "=r" (__a3) 					\
	: input, "r" (__a0), "r" (__a1), "r" (__a2)			\
	: __SYSCALL_CLOBBERS); 						\
	err = __a3;							\
	_sys_result = __v0;						\
	}								\
	_sys_result;							\
})

#define internal_syscall4(ncs_init, cs_init, input, err, arg1, arg2, arg3, arg4) \
({ 									\
	long _sys_result;						\
									\
	{								\
	register long long __v0 asm("$2") ncs_init;			\
	register long long __a0 asm("$4") = ARGIFY (arg1); 		\
	register long long __a1 asm("$5") = ARGIFY (arg2); 		\
	register long long __a2 asm("$6") = ARGIFY (arg3); 		\
	register long long __a3 asm("$7") = ARGIFY (arg4); 		\
	__asm__ volatile ( 						\
	".set\tnoreorder\n\t" 						\
	cs_init								\
	"syscall\n\t" 							\
	".set\treorder" 						\
	: "=r" (__v0), "+r" (__a3) 					\
	: input, "r" (__a0), "r" (__a1), "r" (__a2)		 	\
	: __SYSCALL_CLOBBERS); 						\
	err = __a3;							\
	_sys_result = __v0;						\
	}								\
	_sys_result;							\
})

#define internal_syscall5(ncs_init, cs_init, input, err, arg1, arg2, arg3, arg4, arg5) \
({ 									\
	long _sys_result;						\
									\
	{								\
	register long long __v0 asm("$2") ncs_init;			\
	register long long __a0 asm("$4") = ARGIFY (arg1); 		\
	register long long __a1 asm("$5") = ARGIFY (arg2); 		\
	register long long __a2 asm("$6") = ARGIFY (arg3); 		\
	register long long __a3 asm("$7") = ARGIFY (arg4); 		\
	register long long __a4 asm("$8") = ARGIFY (arg5); 		\
	__asm__ volatile ( 						\
	".set\tnoreorder\n\t" 						\
	cs_init								\
	"syscall\n\t" 							\
	".set\treorder" 						\
	: "=r" (__v0), "+r" (__a3) 					\
	: input, "r" (__a0), "r" (__a1), "r" (__a2), "r" (__a4)		\
	: __SYSCALL_CLOBBERS); 						\
	err = __a3;							\
	_sys_result = __v0;						\
	}								\
	_sys_result;							\
})

#define internal_syscall6(ncs_init, cs_init, input, err, arg1, arg2, arg3, arg4, arg5, arg6) \
({ 									\
	long _sys_result;						\
									\
	{								\
	register long long __v0 asm("$2") ncs_init;			\
	register long long __a0 asm("$4") = ARGIFY (arg1); 		\
	register long long __a1 asm("$5") = ARGIFY (arg2); 		\
	register long long __a2 asm("$6") = ARGIFY (arg3); 		\
	register long long __a3 asm("$7") = ARGIFY (arg4); 		\
	register long long __a4 asm("$8") = ARGIFY (arg5); 		\
	register long long __a5 asm("$9") = ARGIFY (arg6); 		\
	__asm__ volatile ( 						\
	".set\tnoreorder\n\t" 						\
	cs_init								\
	"syscall\n\t" 							\
	".set\treorder" 						\
	: "=r" (__v0), "+r" (__a3) 					\
	: input, "r" (__a0), "r" (__a1), "r" (__a2), "r" (__a4),	\
	  "r" (__a5)							\
	: __SYSCALL_CLOBBERS); 						\
	err = __a3;							\
	_sys_result = __v0;						\
	}								\
	_sys_result;							\
})

#define __SYSCALL_CLOBBERS "$1", "$3", "$10", "$11", "$12", "$13", \
	"$14", "$15", "$24", "$25", "memory"
#endif /* __ASSEMBLER__ */

/* Pointer mangling is not yet supported for MIPS.  */
#define PTR_MANGLE(var) (void) (var)
#define PTR_DEMANGLE(var) (void) (var)

#endif /* linux/mips/sysdep.h */
Commit	Line	Data
6428ce3c DJ	1	/* Copyright (C) 2000, 2002, 2003, 2004, 2005, 2006
6428ce3c DJ	2	Free Software Foundation, Inc.
be122291 AO	3	This file is part of the GNU C Library.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
	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.
	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
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with the GNU C Library; if not, write to the Free
	17	Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	18	02111-1307 USA. */
	19
	20	#ifndef _LINUX_MIPS_SYSDEP_H
	21	#define _LINUX_MIPS_SYSDEP_H 1
	22
	23	/* There is some commonality. */
	24	#include <sysdeps/unix/mips/mips64/n32/sysdep.h>
	25
	26	/* For Linux we can use the system call table in the header file
	27	/usr/include/asm/unistd.h
	28	of the kernel. But these symbols do not follow the SYS_* syntax
	29	so we have to redefine the `SYS_ify' macro here. */
	30	#undef SYS_ify
	31	#ifdef __STDC__
68f3ec56	32	# define SYS_ify(syscall_name) __NR_##syscall_name
be122291	33	#else
68f3ec56	34	# define SYS_ify(syscall_name) __NR_/**/syscall_name
be122291 AO	35	#endif
be122291 AO	36
66a1dc87 RM	37	#ifdef __ASSEMBLER__
	38
	39	/* We don't want the label for the error handler to be visible in the symbol
	40	table when we define it here. */
	41	#ifdef __PIC__
	42	# define SYSCALL_ERROR_LABEL 99b
	43	#endif
	44
	45	#else /* ! __ASSEMBLER__ */
be122291	46
ffd39823 DJ	47	/* Convert X to a long long, without losing any bits if it is one
	48	already or warning if it is a 32-bit pointer. */
	49	#define ARGIFY(X) ((long long) (__typeof__ ((X) - (X))) (X))
	50
be122291 AO	51	/* Define a macro which expands into the inline wrapper code for a system
	52	call. */
	53	#undef INLINE_SYSCALL
	54	#define INLINE_SYSCALL(name, nr, args...) \
	55	({ INTERNAL_SYSCALL_DECL(err); \
	56	long result_var = INTERNAL_SYSCALL (name, err, nr, args); \
	57	if ( INTERNAL_SYSCALL_ERROR_P (result_var, err) ) \
	58	{ \
	59	__set_errno (INTERNAL_SYSCALL_ERRNO (result_var, err)); \
	60	result_var = -1L; \
	61	} \
	62	result_var; })
	63
	64	#undef INTERNAL_SYSCALL_DECL
	65	#define INTERNAL_SYSCALL_DECL(err) long err
	66
	67	#undef INTERNAL_SYSCALL_ERROR_P
	68	#define INTERNAL_SYSCALL_ERROR_P(val, err) ((long) (err))
	69
	70	#undef INTERNAL_SYSCALL_ERRNO
	71	#define INTERNAL_SYSCALL_ERRNO(val, err) (val)
	72
	73	#undef INTERNAL_SYSCALL
6428ce3c DJ	74	#define INTERNAL_SYSCALL(name, err, nr, args...) \
	75	internal_syscall##nr (, "li\t$2, %2\t\t\t# " #name "\n\t", \
	76	"i" (SYS_ify (name)), err, args)
be122291	77
6428ce3c DJ	78	#undef INTERNAL_SYSCALL_NCS
	79	#define INTERNAL_SYSCALL_NCS(number, err, nr, args...) \
	80	internal_syscall##nr (= number, , "r" (__v0), err, args)
	81
	82	#define internal_syscall0(ncs_init, cs_init, input, err, dummy...) \
be122291 AO	83	({ \
	84	long _sys_result; \
	85	\
	86	{ \
6428ce3c DJ	87	register long long __v0 asm("$2") ncs_init; \
6428ce3c DJ	88	register long long __a3 asm("$7"); \
be122291 AO	89	__asm__ volatile ( \
be122291 AO	90	".set\tnoreorder\n\t" \
6428ce3c	91	cs_init \
be122291 AO	92	"syscall\n\t" \
	93	".set reorder" \
	94	: "=r" (__v0), "=r" (__a3) \
6428ce3c	95	: input \
be122291 AO	96	: __SYSCALL_CLOBBERS); \
	97	err = __a3; \
	98	_sys_result = __v0; \
	99	} \
	100	_sys_result; \
	101	})
	102
6428ce3c	103	#define internal_syscall1(ncs_init, cs_init, input, err, arg1) \
be122291 AO	104	({ \
	105	long _sys_result; \
	106	\
	107	{ \
6428ce3c	108	register long long __v0 asm("$2") ncs_init; \
ffd39823	109	register long long __a0 asm("$4") = ARGIFY (arg1); \
be122291 AO	110	register long long __a3 asm("$7"); \
	111	__asm__ volatile ( \
	112	".set\tnoreorder\n\t" \
6428ce3c	113	cs_init \
be122291 AO	114	"syscall\n\t" \
	115	".set reorder" \
	116	: "=r" (__v0), "=r" (__a3) \
6428ce3c	117	: input, "r" (__a0) \
be122291 AO	118	: __SYSCALL_CLOBBERS); \
	119	err = __a3; \
	120	_sys_result = __v0; \
	121	} \
	122	_sys_result; \
	123	})
	124
6428ce3c	125	#define internal_syscall2(ncs_init, cs_init, input, err, arg1, arg2) \
be122291 AO	126	({ \
	127	long _sys_result; \
	128	\
	129	{ \
6428ce3c	130	register long long __v0 asm("$2") ncs_init; \
ffd39823 DJ	131	register long long __a0 asm("$4") = ARGIFY (arg1); \
ffd39823 DJ	132	register long long __a1 asm("$5") = ARGIFY (arg2); \
be122291 AO	133	register long long __a3 asm("$7"); \
	134	__asm__ volatile ( \
	135	".set\tnoreorder\n\t" \
6428ce3c	136	cs_init \
be122291 AO	137	"syscall\n\t" \
	138	".set\treorder" \
	139	: "=r" (__v0), "=r" (__a3) \
6428ce3c	140	: input, "r" (__a0), "r" (__a1) \
be122291 AO	141	: __SYSCALL_CLOBBERS); \
	142	err = __a3; \
	143	_sys_result = __v0; \
	144	} \
	145	_sys_result; \
	146	})
	147
6428ce3c	148	#define internal_syscall3(ncs_init, cs_init, input, err, arg1, arg2, arg3) \
be122291 AO	149	({ \
	150	long _sys_result; \
	151	\
	152	{ \
6428ce3c	153	register long long __v0 asm("$2") ncs_init; \
ffd39823 DJ	154	register long long __a0 asm("$4") = ARGIFY (arg1); \
	155	register long long __a1 asm("$5") = ARGIFY (arg2); \
	156	register long long __a2 asm("$6") = ARGIFY (arg3); \
be122291 AO	157	register long long __a3 asm("$7"); \
	158	__asm__ volatile ( \
	159	".set\tnoreorder\n\t" \
6428ce3c	160	cs_init \
be122291 AO	161	"syscall\n\t" \
	162	".set\treorder" \
	163	: "=r" (__v0), "=r" (__a3) \
6428ce3c	164	: input, "r" (__a0), "r" (__a1), "r" (__a2) \
be122291 AO	165	: __SYSCALL_CLOBBERS); \
	166	err = __a3; \
	167	_sys_result = __v0; \
	168	} \
	169	_sys_result; \
	170	})
	171
6428ce3c	172	#define internal_syscall4(ncs_init, cs_init, input, err, arg1, arg2, arg3, arg4) \
be122291 AO	173	({ \
	174	long _sys_result; \
	175	\
	176	{ \
6428ce3c	177	register long long __v0 asm("$2") ncs_init; \
ffd39823 DJ	178	register long long __a0 asm("$4") = ARGIFY (arg1); \
	179	register long long __a1 asm("$5") = ARGIFY (arg2); \
	180	register long long __a2 asm("$6") = ARGIFY (arg3); \
	181	register long long __a3 asm("$7") = ARGIFY (arg4); \
be122291 AO	182	__asm__ volatile ( \
be122291 AO	183	".set\tnoreorder\n\t" \
6428ce3c	184	cs_init \
be122291 AO	185	"syscall\n\t" \
	186	".set\treorder" \
	187	: "=r" (__v0), "+r" (__a3) \
6428ce3c	188	: input, "r" (__a0), "r" (__a1), "r" (__a2) \
be122291 AO	189	: __SYSCALL_CLOBBERS); \
	190	err = __a3; \
	191	_sys_result = __v0; \
	192	} \
	193	_sys_result; \
	194	})
	195
6428ce3c	196	#define internal_syscall5(ncs_init, cs_init, input, err, arg1, arg2, arg3, arg4, arg5) \
be122291 AO	197	({ \
	198	long _sys_result; \
	199	\
	200	{ \
6428ce3c	201	register long long __v0 asm("$2") ncs_init; \
ffd39823 DJ	202	register long long __a0 asm("$4") = ARGIFY (arg1); \
	203	register long long __a1 asm("$5") = ARGIFY (arg2); \
	204	register long long __a2 asm("$6") = ARGIFY (arg3); \
	205	register long long __a3 asm("$7") = ARGIFY (arg4); \
	206	register long long __a4 asm("$8") = ARGIFY (arg5); \
be122291 AO	207	__asm__ volatile ( \
be122291 AO	208	".set\tnoreorder\n\t" \
6428ce3c	209	cs_init \
be122291 AO	210	"syscall\n\t" \
	211	".set\treorder" \
	212	: "=r" (__v0), "+r" (__a3) \
6428ce3c	213	: input, "r" (__a0), "r" (__a1), "r" (__a2), "r" (__a4) \
be122291 AO	214	: __SYSCALL_CLOBBERS); \
	215	err = __a3; \
	216	_sys_result = __v0; \
	217	} \
	218	_sys_result; \
	219	})
	220
6428ce3c	221	#define internal_syscall6(ncs_init, cs_init, input, err, arg1, arg2, arg3, arg4, arg5, arg6) \
be122291 AO	222	({ \
	223	long _sys_result; \
	224	\
	225	{ \
6428ce3c	226	register long long __v0 asm("$2") ncs_init; \
ffd39823 DJ	227	register long long __a0 asm("$4") = ARGIFY (arg1); \
	228	register long long __a1 asm("$5") = ARGIFY (arg2); \
	229	register long long __a2 asm("$6") = ARGIFY (arg3); \
	230	register long long __a3 asm("$7") = ARGIFY (arg4); \
	231	register long long __a4 asm("$8") = ARGIFY (arg5); \
	232	register long long __a5 asm("$9") = ARGIFY (arg6); \
be122291 AO	233	__asm__ volatile ( \
be122291 AO	234	".set\tnoreorder\n\t" \
6428ce3c	235	cs_init \
be122291 AO	236	"syscall\n\t" \
	237	".set\treorder" \
	238	: "=r" (__v0), "+r" (__a3) \
6428ce3c DJ	239	: input, "r" (__a0), "r" (__a1), "r" (__a2), "r" (__a4), \
6428ce3c DJ	240	"r" (__a5) \
be122291 AO	241	: __SYSCALL_CLOBBERS); \
	242	err = __a3; \
	243	_sys_result = __v0; \
	244	} \
	245	_sys_result; \
	246	})
	247
145f3f8a AJ	248	#define __SYSCALL_CLOBBERS "$1", "$3", "$10", "$11", "$12", "$13", \
145f3f8a AJ	249	"$14", "$15", "$24", "$25", "memory"
be122291 AO	250	#endif /* __ASSEMBLER__ */
be122291 AO	251
908afa83 DJ	252	/* Pointer mangling is not yet supported for MIPS. */
	253	#define PTR_MANGLE(var) (void) (var)
	254	#define PTR_DEMANGLE(var) (void) (var)
	255
be122291	256	#endif /* linux/mips/sysdep.h */