diff options
Diffstat (limited to 'sysdeps/unix/sysv/linux/hppa/sysdep.h')
| -rw-r--r-- | sysdeps/unix/sysv/linux/hppa/sysdep.h | 512 |
1 files changed, 0 insertions, 512 deletions
diff --git a/sysdeps/unix/sysv/linux/hppa/sysdep.h b/sysdeps/unix/sysv/linux/hppa/sysdep.h deleted file mode 100644 index d8dd0431a4..0000000000 --- a/sysdeps/unix/sysv/linux/hppa/sysdep.h +++ /dev/null @@ -1,512 +0,0 @@ -/* Assembler macros for PA-RISC. - Copyright (C) 1999-2017 Free Software Foundation, Inc. - This file is part of the GNU C Library. - Contributed by Ulrich Drepper, <drepper@cygnus.com>, August 1999. - Linux/PA-RISC changes by Philipp Rumpf, <prumpf@tux.org>, March 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_HPPA_SYSDEP_H -#define _LINUX_HPPA_SYSDEP_H 1 - -#include <sysdeps/unix/sysdep.h> -#include <sysdeps/unix/sysv/linux/sysdep.h> -#include <sysdeps/hppa/sysdep.h> - -/* Defines RTLD_PRIVATE_ERRNO. */ -#include <dl-sysdep.h> - -/* In order to get __set_errno() definition in INLINE_SYSCALL. */ -#ifndef __ASSEMBLER__ -#include <errno.h> -#endif - -#undef ASM_LINE_SEP -#define ASM_LINE_SEP ! - -#undef SYS_ify -#define SYS_ify(syscall_name) (__NR_##syscall_name) - -/* The vfork, fork, and clone syscalls clobber r19 - * and r21. We list r21 as either clobbered or as an - * input to a 6-argument syscall. We must save and - * restore r19 in both PIC and non-PIC cases. - */ -/* WARNING: TREG must be a callee saves register so - that it doesn't have to be restored after a call - to another function */ -#define TREG 4 -#define SAVE_PIC(SREG) \ - copy %r19, SREG ASM_LINE_SEP \ - .cfi_register 19, SREG -#define LOAD_PIC(LREG) \ - copy LREG , %r19 ASM_LINE_SEP \ - .cfi_restore 19 -/* Inline assembly defines */ -#define TREG_ASM "%r4" /* Cant clobber r3, it holds framemarker */ -#define SAVE_ASM_PIC " copy %%r19, %" TREG_ASM "\n" -#define LOAD_ASM_PIC " copy %" TREG_ASM ", %%r19\n" -#define CLOB_TREG TREG_ASM , -#define PIC_REG_DEF register unsigned long __r19 asm("r19"); -#define PIC_REG_USE , "r" (__r19) - -#ifdef __ASSEMBLER__ - -/* Syntactic details of assembler. */ - -#define ALIGNARG(log2) log2 - -/* 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 -#define SYS_ify(syscall_name) __NR_##syscall_name - -/* ELF-like local names start with `.L'. */ -#undef L -#define L(name) .L##name - -/* 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 %eax - is a real error number. Linus said he will make sure the no syscall - returns a value in -1 .. -4095 as a valid result so we can safely - test with -4095. */ - -/* We don't want the label for the error handle to be global when we define - it here. */ -/*#ifdef PIC -# define SYSCALL_ERROR_LABEL 0f -#else -# define SYSCALL_ERROR_LABEL syscall_error -#endif*/ - -/* Argument manipulation from the stack for preparing to - make a syscall */ - -#define DOARGS_0 /* nothing */ -#define DOARGS_1 /* nothing */ -#define DOARGS_2 /* nothing */ -#define DOARGS_3 /* nothing */ -#define DOARGS_4 /* nothing */ -#define DOARGS_5 ldw -52(%sp), %r22 ASM_LINE_SEP -#define DOARGS_6 DOARGS_5 ldw -56(%sp), %r21 ASM_LINE_SEP - -#define UNDOARGS_0 /* nothing */ -#define UNDOARGS_1 /* nothing */ -#define UNDOARGS_2 /* nothing */ -#define UNDOARGS_3 /* nothing */ -#define UNDOARGS_4 /* nothing */ -#define UNDOARGS_5 /* nothing */ -#define UNDOARGS_6 /* nothing */ - -/* Define an entry point visible from C. - - There is currently a bug in gdb which prevents us from specifying - incomplete stabs information. Fake some entries here which specify - the current source file. */ -#undef ENTRY -#define ENTRY(name) \ - .text ASM_LINE_SEP \ - .align ALIGNARG(4) ASM_LINE_SEP \ - .export C_SYMBOL_NAME(name) ASM_LINE_SEP \ - .type C_SYMBOL_NAME(name),@function ASM_LINE_SEP \ - cfi_startproc ASM_LINE_SEP \ - C_LABEL(name) ASM_LINE_SEP \ - .PROC ASM_LINE_SEP \ - .CALLINFO FRAME=64,CALLS,SAVE_RP,ENTRY_GR=3 ASM_LINE_SEP \ - .ENTRY ASM_LINE_SEP \ - /* SAVE_RP says we do */ ASM_LINE_SEP \ - stw %rp, -20(%sr0,%sp) ASM_LINE_SEP \ - .cfi_offset 2, -20 ASM_LINE_SEP \ - /*FIXME: Call mcount? (carefull with stack!) */ - -/* Some syscall wrappers do not call other functions, and - hence are classified as leaf, so add NO_CALLS for gdb */ -#define ENTRY_LEAF(name) \ - .text ASM_LINE_SEP \ - .align ALIGNARG(4) ASM_LINE_SEP \ - .export C_SYMBOL_NAME(name) ASM_LINE_SEP \ - .type C_SYMBOL_NAME(name),@function ASM_LINE_SEP \ - cfi_startproc ASM_LINE_SEP \ - C_LABEL(name) ASM_LINE_SEP \ - .PROC ASM_LINE_SEP \ - .CALLINFO FRAME=64,NO_CALLS,SAVE_RP,ENTRY_GR=3 ASM_LINE_SEP \ - .ENTRY ASM_LINE_SEP \ - /* SAVE_RP says we do */ ASM_LINE_SEP \ - stw %rp, -20(%sr0,%sp) ASM_LINE_SEP \ - .cfi_offset 2, -20 ASM_LINE_SEP \ - /*FIXME: Call mcount? (carefull with stack!) */ - -#undef END -#define END(name) \ - .EXIT ASM_LINE_SEP \ - .PROCEND ASM_LINE_SEP \ - cfi_endproc ASM_LINE_SEP \ -.size C_SYMBOL_NAME(name), .-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. */ -#define CALL_MCOUNT /* Do nothing. */ - -/* syscall wrappers consist of - #include <sysdep.h> - PSEUDO(...) - ret - PSEUDO_END(...) - - which means - ENTRY(name) - DO_CALL(...) - bv,n 0(2) -*/ - -#undef PSEUDO -#define PSEUDO(name, syscall_name, args) \ - ENTRY (name) ASM_LINE_SEP \ - /* If necc. load args from stack */ ASM_LINE_SEP \ - DOARGS_##args ASM_LINE_SEP \ - DO_CALL (syscall_name, args) ASM_LINE_SEP \ - UNDOARGS_##args ASM_LINE_SEP - -#define ret \ - /* Return value set by ERRNO code */ ASM_LINE_SEP \ - bv,n 0(2) ASM_LINE_SEP - -#undef PSEUDO_END -#define PSEUDO_END(name) \ - END (name) - -/* We don't set the errno on the return from the syscall */ -#define PSEUDO_NOERRNO(name, syscall_name, args) \ - ENTRY_LEAF (name) ASM_LINE_SEP \ - DOARGS_##args ASM_LINE_SEP \ - DO_CALL_NOERRNO (syscall_name, args) ASM_LINE_SEP \ - UNDOARGS_##args ASM_LINE_SEP - -#define ret_NOERRNO ret - -#undef PSEUDO_END_NOERRNO -#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_LEAF (name) ASM_LINE_SEP \ - DOARGS_##args ASM_LINE_SEP \ - DO_CALL_ERRVAL (syscall_name, args) ASM_LINE_SEP \ - UNDOARGS_##args 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. */ - - -/* FIXME: This comment is not true. - * All the syscall assembly macros rely on finding the appropriate - 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 - arg 2 gr25 - arg 3 gr24 - arg 4 gr23 - arg 5 gr22 - arg 6 gr21 - - The compiler calls us by the C convention: - syscall number in the DO_CALL macro - arg 1 gr26 - arg 2 gr25 - arg 3 gr24 - arg 4 gr23 - arg 5 -52(sp) - arg 6 -56(sp) - - gr22 and gr21 are caller-saves, so we can just load the arguments - there and generally be happy. */ - -/* the cmpb...no_error code below inside DO_CALL - * is intended to mimic the if (__sys_res...) - * code inside INLINE_SYSCALL - */ -#define NO_ERROR -0x1000 - -#undef DO_CALL -#define DO_CALL(syscall_name, args) \ - /* Create a frame */ ASM_LINE_SEP \ - stwm TREG, 64(%sp) ASM_LINE_SEP \ - .cfi_offset TREG, 0 ASM_LINE_SEP \ - .cfi_adjust_cfa_offset 64 ASM_LINE_SEP \ - stw %sp, -4(%sp) ASM_LINE_SEP \ - .cfi_offset 30, -4 ASM_LINE_SEP \ - stw %r19, -32(%sp) ASM_LINE_SEP \ - .cfi_offset 19, -32 ASM_LINE_SEP \ - /* Save r19 */ ASM_LINE_SEP \ - SAVE_PIC(TREG) 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 NO_ERROR,%r1 ASM_LINE_SEP \ - cmpb,>>=,n %r1,%ret0,L(pre_end) ASM_LINE_SEP \ - /* Restore r19 from TREG */ ASM_LINE_SEP \ - LOAD_PIC(TREG) /* delay */ ASM_LINE_SEP \ - SYSCALL_ERROR_HANDLER ASM_LINE_SEP \ - /* Use TREG for temp storage */ ASM_LINE_SEP \ - copy %ret0, TREG /* delay */ ASM_LINE_SEP \ - /* OPTIMIZE: Don't reload r19 */ ASM_LINE_SEP \ - /* do a -1*syscall_ret0 */ ASM_LINE_SEP \ - sub %r0, TREG, TREG ASM_LINE_SEP \ - /* Store into errno location */ ASM_LINE_SEP \ - stw TREG, 0(%sr0,%ret0) ASM_LINE_SEP \ - /* return -1 as error */ ASM_LINE_SEP \ - ldo -1(%r0), %ret0 ASM_LINE_SEP \ -L(pre_end): ASM_LINE_SEP \ - /* Restore our frame, restoring TREG */ ASM_LINE_SEP \ - ldwm -64(%sp), TREG ASM_LINE_SEP \ - .cfi_adjust_cfa_offset -64 ASM_LINE_SEP \ - /* Restore return pointer */ ASM_LINE_SEP \ - ldw -20(%sp),%rp ASM_LINE_SEP \ - .cfi_restore 2 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) \ - /* 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 - -/* 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) \ - /* 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 NO_ERROR,%r1 ASM_LINE_SEP \ - cmpb,>>=,n %r1,%ret0,0f ASM_LINE_SEP \ - sub %r0, %ret0, %ret0 ASM_LINE_SEP \ -0: ASM_LINE_SEP - - -#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 - TREG is clobbered and use that register to save/restore r19 - across the syscall. */ - -#define CALL_CLOB_REGS "%r1", "%r2", CLOB_TREG \ - "%r20", "%r29", "%r31" - -#undef INLINE_SYSCALL -#define INLINE_SYSCALL(name, nr, args...) \ -({ \ - long __sys_res = INTERNAL_SYSCALL (name, , nr, args); \ - if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (__sys_res, ))) \ - { \ - __set_errno (INTERNAL_SYSCALL_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) - -#undef INTERNAL_SYSCALL_ERROR_P -#define INTERNAL_SYSCALL_ERROR_P(val, err) \ - ((val < 0) && (val > -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; \ - { \ - LOAD_ARGS_##nr(args) \ - register unsigned long __res asm("r28"); \ - PIC_REG_DEF \ - LOAD_REGS_##nr \ - /* FIXME: HACK save/load r19 around syscall */ \ - asm volatile( \ - SAVE_ASM_PIC \ - " ble 0x100(%%sr2, %%r0)\n" \ - " ldi %1, %%r20\n" \ - LOAD_ASM_PIC \ - : "=r" (__res) \ - : "i" (SYS_ify(name)) PIC_REG_USE ASM_ARGS_##nr \ - : "memory", CALL_CLOB_REGS CLOB_ARGS_##nr \ - ); \ - __sys_res = (long)__res; \ - } \ - __sys_res; \ - }) - - -/* The _NCS variant allows non-constant syscall numbers. */ -#undef INTERNAL_SYSCALL_NCS -#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \ -({ \ - long __sys_res; \ - { \ - LOAD_ARGS_##nr(args) \ - register unsigned long __res asm("r28"); \ - PIC_REG_DEF \ - LOAD_REGS_##nr \ - /* FIXME: HACK save/load r19 around syscall */ \ - asm volatile( \ - SAVE_ASM_PIC \ - " ble 0x100(%%sr2, %%r0)\n" \ - " copy %1, %%r20\n" \ - LOAD_ASM_PIC \ - : "=r" (__res) \ - : "r" (name) PIC_REG_USE ASM_ARGS_##nr \ - : "memory", CALL_CLOB_REGS CLOB_ARGS_##nr \ - ); \ - __sys_res = (long)__res; \ - } \ - __sys_res; \ - }) - -#define LOAD_ARGS_0() -#define LOAD_REGS_0 -#define LOAD_ARGS_1(a1) \ - register unsigned long __x26 = (unsigned long)(a1); \ - LOAD_ARGS_0() -#define LOAD_REGS_1 \ - register unsigned long __r26 __asm__("r26") = __x26; \ - LOAD_REGS_0 -#define LOAD_ARGS_2(a1,a2) \ - register unsigned long __x25 = (unsigned long)(a2); \ - LOAD_ARGS_1(a1) -#define LOAD_REGS_2 \ - register unsigned long __r25 __asm__("r25") = __x25; \ - LOAD_REGS_1 -#define LOAD_ARGS_3(a1,a2,a3) \ - register unsigned long __x24 = (unsigned long)(a3); \ - LOAD_ARGS_2(a1,a2) -#define LOAD_REGS_3 \ - register unsigned long __r24 __asm__("r24") = __x24; \ - LOAD_REGS_2 -#define LOAD_ARGS_4(a1,a2,a3,a4) \ - register unsigned long __x23 = (unsigned long)(a4); \ - LOAD_ARGS_3(a1,a2,a3) -#define LOAD_REGS_4 \ - register unsigned long __r23 __asm__("r23") = __x23; \ - LOAD_REGS_3 -#define LOAD_ARGS_5(a1,a2,a3,a4,a5) \ - register unsigned long __x22 = (unsigned long)(a5); \ - LOAD_ARGS_4(a1,a2,a3,a4) -#define LOAD_REGS_5 \ - register unsigned long __r22 __asm__("r22") = __x22; \ - LOAD_REGS_4 -#define LOAD_ARGS_6(a1,a2,a3,a4,a5,a6) \ - register unsigned long __x21 = (unsigned long)(a6); \ - LOAD_ARGS_5(a1,a2,a3,a4,a5) -#define LOAD_REGS_6 \ - register unsigned long __r21 __asm__("r21") = __x21; \ - LOAD_REGS_5 - -/* Even with zero args we use r20 for the syscall number */ -#define ASM_ARGS_0 -#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__ */ - -/* Pointer mangling is not yet supported for HPPA. */ -#define PTR_MANGLE(var) (void) (var) -#define PTR_DEMANGLE(var) (void) (var) - -#endif /* _LINUX_HPPA_SYSDEP_H */ |