diff options
| -rw-r--r-- | ChangeLog | 16 | ||||
| -rw-r--r-- | linuxthreads/ChangeLog | 4 | ||||
| -rw-r--r-- | linuxthreads/sysdeps/unix/sysv/linux/hppa/malloc-machine.h | 73 | ||||
| -rw-r--r-- | posix/regcomp.c | 2 | ||||
| -rw-r--r-- | sysdeps/hppa/sysdep.h | 3 | ||||
| -rw-r--r-- | sysdeps/unix/sysv/linux/hppa/sysdep.c | 40 | ||||
| -rw-r--r-- | sysdeps/unix/sysv/linux/hppa/sysdep.h | 276 | ||||
| -rw-r--r-- | sysdeps/unix/sysv/linux/sh/sysdep.h | 15 |
8 files changed, 353 insertions, 76 deletions
diff --git a/ChangeLog b/ChangeLog index ff154a0e6e..0408233170 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,19 @@ +2003-10-12 Carlos O'Donell <carlos@baldric.uwo.ca> + + * sysdeps/hppa/sysdep.h: Undef JUMPTARGET before use. + * sysdeps/unix/sysv/linux/hppa/sysdep.h: Define PSEUDO_ERRVAL, + SYSCALL_ERROR_LABEL under all conditions, INTERNAL_SYSCALL_DECL, + INTERNAL_SYSCALL_ERROR_P, INTERNAL_SYSCALL_ERRNO, INTERNAL_SYSCALL, + and undef JUMPTARGET before use. + [PIC]: Save pic register around syscall. + * sysdeps/unix/sysv/linux/hppa/sysdep.c (syscall): + Cleanup asm statment. + +2003-10-13 Kaz Kojima <kkojima@rr.iij4u.or.jp> + + * sysdeps/unix/sysv/linux/sh/sysdep.h (DO_CALL): Add SYSCALL_INST_PAD + after trapa instruction. + 2003-10-09 Kaz Kojima <kkojima@rr.iij4u.or.jp> * sysdeps/unix/sysv/linux/sh/syscalls.list: Add waitpid. diff --git a/linuxthreads/ChangeLog b/linuxthreads/ChangeLog index de5e3e74b4..a7e0b46daf 100644 --- a/linuxthreads/ChangeLog +++ b/linuxthreads/ChangeLog @@ -1,5 +1,9 @@ 2003-10-10 Carlos O'Donell <carlos@baldric.uwo.ca> + * linuxthreads/sysdeps/unix/sysv/linux/hppa/malloc-machine.h: New file. + +2003-10-10 Carlos O'Donell <carlos@baldric.uwo.ca> + * sysdeps/unix/sysv/linux/hppa/sysdep-cancel.h: New file. 2003-10-07 Jakub Jelinek <jakub@redhat.com> diff --git a/linuxthreads/sysdeps/unix/sysv/linux/hppa/malloc-machine.h b/linuxthreads/sysdeps/unix/sysv/linux/hppa/malloc-machine.h new file mode 100644 index 0000000000..817cf59222 --- /dev/null +++ b/linuxthreads/sysdeps/unix/sysv/linux/hppa/malloc-machine.h @@ -0,0 +1,73 @@ +/* HP-PARISC macro definitions for mutexes, thread-specific data + and parameters for malloc. + Copyright (C) 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Carlos O'Donell <carlos@baldric.uwo.ca>, 2003. + + 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 _MALLOC_MACHINE_H +#define _MALLOC_MACHINE_H + +#undef thread_atfork_static + +#include <atomic.h> +#include <bits/libc-lock.h> + +__libc_lock_define (typedef, mutex_t) + +/* Since our lock structure does not tolerate being initialized to zero, we must + modify the standard function calls made by malloc */ +# define mutex_init(m) \ + __libc_maybe_call (__pthread_mutex_init, (m, NULL), \ + (((m)->__m_lock.__spinlock = __LT_SPINLOCK_INIT),(*(int *)(m))) ) +# define mutex_lock(m) \ + __libc_maybe_call (__pthread_mutex_lock, (m), \ + (__load_and_clear(&((m)->__m_lock.__spinlock)), 0)) +# define mutex_trylock(m) \ + __libc_maybe_call (__pthread_mutex_trylock, (m), \ + (*(int *)(m) ? 1 : (__load_and_clear(&((m)->__m_lock.__spinlock)), 0))) +# define mutex_unlock(m) \ + __libc_maybe_call (__pthread_mutex_unlock, (m), \ + (((m)->__m_lock.__spinlock = __LT_SPINLOCK_INIT), (*(int *)(m))) ) + +/* This is defined by newer gcc version unique for each module. */ +extern void *__dso_handle __attribute__ ((__weak__)); + +#include <fork.h> + +#ifdef SHARED +# define thread_atfork(prepare, parent, child) \ + __register_atfork (prepare, parent, child, __dso_handle) +#else +# define thread_atfork(prepare, parent, child) \ + __register_atfork (prepare, parent, child, \ + &__dso_handle == NULL ? NULL : __dso_handle) +#endif + +/* thread specific data for glibc */ + +#include <bits/libc-tsd.h> + +typedef int tsd_key_t[1]; /* no key data structure, libc magic does it */ +__libc_tsd_define (static, MALLOC) /* declaration/common definition */ +#define tsd_key_create(key, destr) ((void) (key)) +#define tsd_setspecific(key, data) __libc_tsd_set (MALLOC, (data)) +#define tsd_getspecific(key, vptr) ((vptr) = __libc_tsd_get (MALLOC)) + +#include <sysdeps/generic/malloc-machine.h> + +#endif /* !defined(_MALLOC_MACHINE_H) */ diff --git a/posix/regcomp.c b/posix/regcomp.c index 35a3b83f50..b0093d940e 100644 --- a/posix/regcomp.c +++ b/posix/regcomp.c @@ -1149,6 +1149,8 @@ calc_epsdest (dfa, node) || dfa->nodes[idx].type == OP_CLOSE_SUBEXP || dfa->nodes[idx].type == OP_BACK_REF) re_node_set_init_1 (dfa->edests + idx, node->next); + else + assert (!IS_EPSILON_NODE (dfa->nodes[idx].type)); } } diff --git a/sysdeps/hppa/sysdep.h b/sysdeps/hppa/sysdep.h index 1f47fadb3f..be36567434 100644 --- a/sysdeps/hppa/sysdep.h +++ b/sysdeps/hppa/sysdep.h @@ -1,5 +1,5 @@ /* Assembler macros for HP/PA. - Copyright (C) 1999 Free Software Foundation, Inc. + Copyright (C) 1999, 2003 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Ulrich Drepper, <drepper@cygnus.com>, August 1999. @@ -70,6 +70,7 @@ #define PSEUDO_END(name) \ END (name) +#undef JUMPTARGET #define JUMPTARGET(name) name #define SYSCALL_PIC_SETUP /* Nothing. */ diff --git a/sysdeps/unix/sysv/linux/hppa/sysdep.c b/sysdeps/unix/sysv/linux/hppa/sysdep.c index bf4d4af5c7..192efbaf75 100644 --- a/sysdeps/unix/sysv/linux/hppa/sysdep.c +++ b/sysdeps/unix/sysv/linux/hppa/sysdep.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1997, 1998, 2001 Free Software Foundation, Inc. +/* Copyright (C) 1997, 1998, 2001, 2003 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 @@ -19,6 +19,10 @@ #include <sysdep.h> #include <errno.h> +extern int __syscall_error(int err_no); +extern int syscall (int sysnum, int arg0, int arg1, int arg2, + int arg3, int arg4, int arg5); + /* This routine is jumped to by all the syscall handlers, to stash an error number into errno. */ int @@ -30,25 +34,31 @@ __syscall_error (int err_no) /* HPPA implements syscall() in 'C'; the assembler version would - typically be in syscall.S. */ - + typically be in syscall.S. Also note that we have INLINE_SYSCALL, + INTERNAL_SYSCALL, and all the generated pure assembly syscall wrappers. + How often the function is used is unknown. */ int -syscall (int sysnum, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5) +syscall (int sysnum, int arg0, int arg1, int arg2, int arg3, int arg4, + int arg5) { - long __sys_res; + /* FIXME: Keep this matching INLINE_SYSCALL for hppa */ + long int __sys_res; { - register unsigned long __res asm("r28"); - LOAD_ARGS_6(arg0, arg1, arg2, arg3, arg4, arg5) - asm volatile ("ble 0x100(%%sr2, %%r0)\n\t" - "copy %1, %%r20" - : "=r" (__res) - : "r" (sysnum) ASM_ARGS_6); + register unsigned long int __res asm("r28"); + LOAD_ARGS_6 (arg0, arg1, arg2, arg3, arg4, arg5) + asm volatile (STW_ASM_PIC + " ble 0x100(%%sr2, %%r0) \n" + " copy %1, %%r20 \n" + LDW_ASM_PIC + : "=r" (__res) + : "r" (sysnum) ASM_ARGS_6 + : CALL_CLOB_REGS CLOB_ARGS_6); __sys_res = __res; } - if ((unsigned long) __sys_res >= (unsigned long)-4095) + if ((unsigned long int) __sys_res >= (unsigned long int) -4095) { - __set_errno(-__sys_res); - __sys_res = -1; - } + __set_errno (-__sys_res); + __sys_res = -1; + } return __sys_res; } diff --git a/sysdeps/unix/sysv/linux/hppa/sysdep.h b/sysdeps/unix/sysv/linux/hppa/sysdep.h index 771c55c400..bb5e31dbb9 100644 --- a/sysdeps/unix/sysv/linux/hppa/sysdep.h +++ b/sysdeps/unix/sysv/linux/hppa/sysdep.h @@ -25,12 +25,26 @@ #include "config.h" #ifndef ASM_LINE_SEP -#define ASM_LINE_SEP ; +# define ASM_LINE_SEP ; #endif #undef SYS_ify #define SYS_ify(syscall_name) (__NR_##syscall_name) +#ifdef PIC +/* WARNING: CANNOT BE USED IN A NOP! */ +# define STW_PIC stw %r19, -32(%sr0, %sp) ASM_LINE_SEP +# define LDW_PIC ldw -32(%sr0, %sp), %r19 ASM_LINE_SEP +# define STW_ASM_PIC " copy %%r19, %%r4\n" +# define LDW_ASM_PIC " copy %%r4, %%r19\n" +# define USING_GR4 "%r4", +#else +# define STW_PIC ASM_LINE_SEP +# define LDW_PIC ASM_LINE_SEP +# define STW_ASM_PIC " \n" +# define LDW_ASM_PIC " \n" +# define USING_GR4 +#endif #ifdef __ASSEMBLER__ @@ -77,20 +91,13 @@ .text ASM_LINE_SEP \ .export C_SYMBOL_NAME(name) ASM_LINE_SEP \ .type C_SYMBOL_NAME(name),@function ASM_LINE_SEP \ - C_LABEL(name) \ - CALL_MCOUNT - -#define ret \ - bv 0(2) ASM_LINE_SEP \ - nop - -#define ret_NOERRNO \ - bv 0(2) ASM_LINE_SEP \ - nop + C_LABEL(name) ASM_LINE_SEP \ + CALL_MCOUNT ASM_LINE_SEP #undef END -#define END(name) \ -1: .size C_SYMBOL_NAME(name),1b-C_SYMBOL_NAME(name) +#define END(name) \ +1: ASM_LINE_SEP \ +.size C_SYMBOL_NAME(name),1b-C_SYMBOL_NAME(name) ASM_LINE_SEP /* If compiled for profiling, call `mcount' at the start of each function. */ /* No, don't bother. gcc will put the call in for us. */ @@ -110,27 +117,83 @@ nop */ -#define PSEUDO(name, syscall_name, args) \ - ENTRY (name) \ - DO_CALL(syscall_name, args) ASM_LINE_SEP \ - nop +#define PSEUDO(name, syscall_name, args) \ + ENTRY (name) \ + DO_CALL(syscall_name, args) ASM_LINE_SEP \ + nop ASM_LINE_SEP + +#define ret \ + /* Return value set by ERRNO code */ ASM_LINE_SEP \ + bv 0(2) ASM_LINE_SEP \ + nop ASM_LINE_SEP #undef PSEUDO_END -#define PSEUDO_END(name) \ +#define PSEUDO_END(name) \ END (name) -#define PSEUDO_NOERRNO(name, syscall_name, args) \ - ENTRY (name) \ - DO_CALL(syscall_name, args) ASM_LINE_SEP \ - nop +/* We don't set the errno on the return from the syscall */ +#define PSEUDO_NOERRNO(name, syscall_name, args) \ + ENTRY (name) \ + DO_CALL_NOERRNO(syscall_name, args) ASM_LINE_SEP \ + nop ASM_LINE_SEP + +#define ret_NOERRNO ret #undef PSEUDO_END_NOERRNO -#define PSEUDO_END_NOERRNO(name) \ +#define PSEUDO_END_NOERRNO(name) \ END (name) +/* This has to return the error value */ +#undef PSEUDO_ERRVAL +#define PSEUDO_ERRVAL(name, syscall_name, args) \ + ENTRY(name) \ + DO_CALL_ERRVAL(syscall_name, args) ASM_LINE_SEP \ + nop ASM_LINE_SEP + +#define ret_ERRVAL ret + +#undef PSEUDO_END_ERRVAL +#define PSEUDO_END_ERRVAL(name) \ + END(name) + +#undef JUMPTARGET #define JUMPTARGET(name) name #define SYSCALL_PIC_SETUP /* Nothing. */ + +/* All the syscall assembly macros rely on finding the approriate + SYSCALL_ERROR_LABEL or rather HANDLER. */ + +/* int * __errno_location(void) so you have to store your value + into the return address! */ +#define DEFAULT_SYSCALL_ERROR_HANDLER \ + .import __errno_location,code ASM_LINE_SEP \ + /* branch to errno handler */ ASM_LINE_SEP \ + bl __errno_location,%rp ASM_LINE_SEP + +/* Here are the myriad of configuration options that the above can + work for... what we've done is provide the framework for future + changes if required to each section */ + +#ifdef PIC +# if RTLD_PRIVATE_ERRNO +# define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER +# else /* !RTLD_PRIVATE_ERRNO */ +# if defined _LIBC_REENTRANT +# define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER +# else /* !_LIBC_REENTRANT */ +# define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER +# endif /* _LIBC_REENTRANT */ +# endif /* RTLD_PRIVATE_ERRNO */ +#else +# ifndef _LIBC_REENTRANT +# define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER +# else +# define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER +# endif +#endif + + /* Linux takes system call arguments in registers: syscall number gr20 arg 1 gr26 @@ -159,25 +222,61 @@ #undef DO_CALL #define DO_CALL(syscall_name, args) \ - DOARGS_##args \ + DOARGS_##args ASM_LINE_SEP \ + STW_PIC ASM_LINE_SEP \ + /* Do syscall, delay loads # */ ASM_LINE_SEP \ ble 0x100(%sr2,%r0) ASM_LINE_SEP \ ldi SYS_ify (syscall_name), %r20 ASM_LINE_SEP \ ldi -0x1000,%r1 ASM_LINE_SEP \ cmpb,>>=,n %r1,%ret0,0f ASM_LINE_SEP \ - stw %rp, -20(%sr0,%r30) ASM_LINE_SEP \ - stw %ret0, -24(%sr0,%r30) ASM_LINE_SEP \ - .import __errno_location,code ASM_LINE_SEP \ - bl __errno_location,%rp ASM_LINE_SEP \ - ldo 64(%r30), %r30 ASM_LINE_SEP \ - ldo -64(%r30), %r30 ASM_LINE_SEP \ - ldw -24(%r30), %r26 ASM_LINE_SEP \ + /* save rp or we get lost */ ASM_LINE_SEP \ + stw %rp, -20(%sr0,%sp) ASM_LINE_SEP \ + /* Restore r19 from frame */ ASM_LINE_SEP \ + LDW_PIC ASM_LINE_SEP \ + stw %ret0, -24(%sr0,%sp) ASM_LINE_SEP \ + SYSCALL_ERROR_HANDLER ASM_LINE_SEP \ + /* create frame */ ASM_LINE_SEP \ + ldo 64(%sp), %sp ASM_LINE_SEP \ + ldo -64(%sp), %sp ASM_LINE_SEP \ + /* OPTIMIZE: Don't reload r19 */ ASM_LINE_SEP \ + /* do a -1*syscall_ret0 */ ASM_LINE_SEP \ + ldw -24(%sr0,%sp), %r26 ASM_LINE_SEP \ sub %r0, %r26, %r26 ASM_LINE_SEP \ + /* Store into errno location */ ASM_LINE_SEP \ stw %r26, 0(%sr0,%ret0) ASM_LINE_SEP \ + /* return -1 as error */ ASM_LINE_SEP \ ldo -1(%r0), %ret0 ASM_LINE_SEP \ - ldw -20(%r30), %rp ASM_LINE_SEP \ + ldw -20(%sr0,%sp), %rp ASM_LINE_SEP \ 0: ASM_LINE_SEP \ + UNDOARGS_##args ASM_LINE_SEP + +/* We do nothing with the return, except hand it back to someone else */ +#undef DO_CALL_NOERRNO +#define DO_CALL_NOERRNO(syscall_name, args) \ + DOARGS_##args \ + /* No need to store r19 */ ASM_LINE_SEP \ + ble 0x100(%sr2,%r0) ASM_LINE_SEP \ + ldi SYS_ify (syscall_name), %r20 ASM_LINE_SEP \ + /* Caller will restore r19 */ ASM_LINE_SEP \ UNDOARGS_##args +/* Here, we return the ERRVAL in assembly, note we don't call the + error handler function, but we do 'negate' the return _IF_ + it's an error. Not sure if this is the right semantic. */ + +#undef DO_CALL_ERRVAL +#define DO_CALL_ERRVAL(syscall_name, args) \ + DOARGS_##args ASM_LINE_SEP \ + /* No need to store r19 */ ASM_LINE_SEP \ + ble 0x100(%sr2,%r0) ASM_LINE_SEP \ + ldi SYS_ify (syscall_name), %r20 ASM_LINE_SEP \ + /* Caller will restore r19 */ ASM_LINE_SEP \ + ldi -0x1000,%r1 ASM_LINE_SEP \ + cmpb,>>=,n %r1,%ret0,0f ASM_LINE_SEP \ + sub %r0, %ret0, %ret0 ASM_LINE_SEP \ +0: ASM_LINE_SEP \ + UNDOARGS_##args ASM_LINE_SEP + #define DOARGS_0 /* nothing */ #define DOARGS_1 /* nothing */ #define DOARGS_2 /* nothing */ @@ -198,53 +297,124 @@ #else +/* GCC has to be warned that a syscall may clobber all the ABI + registers listed as "caller-saves", see page 8, Table 2 + in section 2.2.6 of the PA-RISC RUN-TIME architecture + document. However! r28 is the result and will conflict with + the clobber list so it is left out. Also the input arguments + registers r20 -> r26 will conflict with the list so they + are treated specially. Although r19 is clobbered by the syscall + we cannot say this because it would violate ABI, thus we say + r4 is clobbered and use that register to save/restore r19 + across the syscall. */ + +#define CALL_CLOB_REGS "%r1", "%r2", USING_GR4 \ + "%r20", "%r29", "%r31" + #undef INLINE_SYSCALL -#define INLINE_SYSCALL(name, nr, args...) ({ \ +#define INLINE_SYSCALL(name, nr, args...) ({ \ + long __sys_res; \ + { \ + register unsigned long __res asm("r28"); \ + LOAD_ARGS_##nr(args) \ + /* FIXME: HACK stw/ldw r19 around syscall */ \ + asm volatile( \ + STW_ASM_PIC \ + " ble 0x100(%%sr2, %%r0)\n" \ + " ldi %1, %%r20\n" \ + LDW_ASM_PIC \ + : "=r" (__res) \ + : "i" (SYS_ify(name)) ASM_ARGS_##nr \ + : CALL_CLOB_REGS CLOB_ARGS_##nr \ + ); \ + __sys_res = (long)__res; \ + } \ + if ( (unsigned long)__sys_res >= (unsigned long)-4095 ){ \ + __set_errno(-__sys_res); \ + __sys_res = -1; \ + } \ + __sys_res; \ +}) + +/* INTERNAL_SYSCALL_DECL - Allows us to setup some function static + value to use within the context of the syscall + INTERNAL_SYSCALL_ERROR_P - Returns 0 if it wasn't an error, 1 otherwise + You are allowed to use the syscall result (val) and the DECL error variable + to determine what went wrong. + INTERLAL_SYSCALL_ERRNO - Munges the val/err pair into the error number. + In our case we just flip the sign. */ + +#undef INTERNAL_SYSCALL_DECL +#define INTERNAL_SYSCALL_DECL(err) do { } while (0) + +/* Equivalent to (val < 0)&&(val > -4095) which is what we want */ +#undef INTERNAL_SYSCALL_ERROR_P +#define INTERNAL_SYSCALL_ERROR_P(val, err) \ + ((unsigned long)val >= (unsigned long)-4095) + +#undef INTERNAL_SYSCALL_ERRNO +#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val)) + +/* Similar to INLINE_SYSCALL but we don't set errno */ +#undef INTERNAL_SYSCALL +#define INTERNAL_SYSCALL(name, err, nr, args...) \ +({ \ long __sys_res; \ { \ register unsigned long __res asm("r28"); \ LOAD_ARGS_##nr(args) \ + /* FIXME: HACK stw/ldw r19 around syscall */ \ asm volatile( \ - "ble 0x100(%%sr2, %%r0)\n\t" \ - " ldi %1, %%r20" \ + STW_ASM_PIC \ + " ble 0x100(%%sr2, %%r0)\n" \ + " ldi %1, %%r20\n" \ + LDW_ASM_PIC \ : "=r" (__res) \ : "i" (SYS_ify(name)) ASM_ARGS_##nr \ ); \ - __sys_res = __res; \ - } \ - if ((unsigned long)__sys_res >= (unsigned long)-4095) { \ - __set_errno(-__sys_res); \ - __sys_res = -1; \ + : CALL_CLOB_REGS CLOB_ARGS_##nr \ + ); \ + __sys_res = (long)__res; \ } \ __sys_res; \ -}) + }) #define LOAD_ARGS_0() #define LOAD_ARGS_1(r26) \ - register unsigned long __r26 __asm__("r26") = (unsigned long)r26; \ + register unsigned long __r26 __asm__("r26") = (unsigned long)r26; \ LOAD_ARGS_0() #define LOAD_ARGS_2(r26,r25) \ - register unsigned long __r25 __asm__("r25") = (unsigned long)r25; \ + register unsigned long __r25 __asm__("r25") = (unsigned long)r25; \ LOAD_ARGS_1(r26) #define LOAD_ARGS_3(r26,r25,r24) \ - register unsigned long __r24 __asm__("r24") = (unsigned long)r24; \ + register unsigned long __r24 __asm__("r24") = (unsigned long)r24; \ LOAD_ARGS_2(r26,r25) #define LOAD_ARGS_4(r26,r25,r24,r23) \ - register unsigned long __r23 __asm__("r23") = (unsigned long)r23; \ + register unsigned long __r23 __asm__("r23") = (unsigned long)r23; \ LOAD_ARGS_3(r26,r25,r24) #define LOAD_ARGS_5(r26,r25,r24,r23,r22) \ - register unsigned long __r22 __asm__("r22") = (unsigned long)r22; \ + register unsigned long __r22 __asm__("r22") = (unsigned long)r22; \ LOAD_ARGS_4(r26,r25,r24,r23) #define LOAD_ARGS_6(r26,r25,r24,r23,r22,r21) \ - register unsigned long __r21 __asm__("r21") = (unsigned long)r21; \ + register unsigned long __r21 __asm__("r21") = (unsigned long)r21; \ LOAD_ARGS_5(r26,r25,r24,r23,r22) +/* Even with zero args we use r20 for the syscall number */ #define ASM_ARGS_0 -#define ASM_ARGS_1 , "r" (__r26) -#define ASM_ARGS_2 , "r" (__r26), "r" (__r25) -#define ASM_ARGS_3 , "r" (__r26), "r" (__r25), "r" (__r24) -#define ASM_ARGS_4 , "r" (__r26), "r" (__r25), "r" (__r24), "r" (__r23) -#define ASM_ARGS_5 , "r" (__r26), "r" (__r25), "r" (__r24), "r" (__r23), "r" (__r22) -#define ASM_ARGS_6 , "r" (__r26), "r" (__r25), "r" (__r24), "r" (__r23), "r" (__r22), "r" (__r21) +#define ASM_ARGS_1 ASM_ARGS_0, "r" (__r26) +#define ASM_ARGS_2 ASM_ARGS_1, "r" (__r25) +#define ASM_ARGS_3 ASM_ARGS_2, "r" (__r24) +#define ASM_ARGS_4 ASM_ARGS_3, "r" (__r23) +#define ASM_ARGS_5 ASM_ARGS_4, "r" (__r22) +#define ASM_ARGS_6 ASM_ARGS_5, "r" (__r21) + +/* The registers not listed as inputs but clobbered */ +#define CLOB_ARGS_6 +#define CLOB_ARGS_5 CLOB_ARGS_6, "%r21" +#define CLOB_ARGS_4 CLOB_ARGS_5, "%r22" +#define CLOB_ARGS_3 CLOB_ARGS_4, "%r23" +#define CLOB_ARGS_2 CLOB_ARGS_3, "%r24" +#define CLOB_ARGS_1 CLOB_ARGS_2, "%r25" +#define CLOB_ARGS_0 CLOB_ARGS_1, "%r26" #endif /* __ASSEMBLER__ */ diff --git a/sysdeps/unix/sysv/linux/sh/sysdep.h b/sysdeps/unix/sysv/linux/sh/sysdep.h index ee6eec1956..cb36ec7663 100644 --- a/sysdeps/unix/sysv/linux/sh/sysdep.h +++ b/sysdeps/unix/sysv/linux/sh/sysdep.h @@ -183,6 +183,13 @@ # endif /* _LIBC_REENTRANT */ #endif /* PIC */ +# ifdef NEED_SYSCALL_INST_PAD +# define SYSCALL_INST_PAD \ + or r0,r0; or r0,r0; or r0,r0; or r0,r0; or r0,r0 +# else +# define SYSCALL_INST_PAD +# endif + #define SYSCALL_INST0 trapa #0x10 #define SYSCALL_INST1 trapa #0x11 #define SYSCALL_INST2 trapa #0x12 @@ -195,19 +202,13 @@ #define DO_CALL(syscall_name, args) \ mov.l 1f,r3; \ SYSCALL_INST##args; \ + SYSCALL_INST_PAD; \ bra 2f; \ nop; \ .align 2; \ 1: .long SYS_ify (syscall_name); \ 2: -# ifdef NEED_SYSCALL_INST_PAD -# define SYSCALL_INST_PAD \ - or r0,r0; or r0,r0; or r0,r0; or r0,r0; or r0,r0 -# else -# define SYSCALL_INST_PAD -# endif - #else /* not __ASSEMBLER__ */ #define SYSCALL_INST_STR0 "trapa #0x10\n\t" |