Back to index

glibc  2.9
sysdep.h
Go to the documentation of this file.
00001 /* Assembler macros for PA-RISC.
00002    Copyright (C) 1999, 2001, 2002, 2003, 2007 
00003    Free Software Foundation, Inc.
00004    This file is part of the GNU C Library.
00005    Contributed by Ulrich Drepper, <drepper@cygnus.com>, August 1999.
00006    Linux/PA-RISC changes by Philipp Rumpf, <prumpf@tux.org>, March 2000.
00007 
00008    The GNU C Library is free software; you can redistribute it and/or
00009    modify it under the terms of the GNU Lesser General Public
00010    License as published by the Free Software Foundation; either
00011    version 2.1 of the License, or (at your option) any later version.
00012 
00013    The GNU C Library is distributed in the hope that it will be useful,
00014    but WITHOUT ANY WARRANTY; without even the implied warranty of
00015    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016    Lesser General Public License for more details.
00017 
00018    You should have received a copy of the GNU Lesser General Public
00019    License along with the GNU C Library; if not, write to the Free
00020    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
00021    02111-1307 USA.  */
00022 
00023 #include <asm/unistd.h>
00024 #include <sysdeps/generic/sysdep.h>
00025 #include <sys/syscall.h>
00026 
00027 #undef ASM_LINE_SEP
00028 #define ASM_LINE_SEP ! 
00029 
00030 #undef SYS_ify
00031 #define SYS_ify(syscall_name)      (__NR_##syscall_name)
00032 
00033 /* WARNING: TREG must be a callee saves register so 
00034    that it doesn't have to be restored after a call 
00035    to another function */
00036 #ifdef PIC
00037 # define TREG %r3
00038 # define SAVE_PIC(SREG) copy %r19, SREG ASM_LINE_SEP
00039 # define LOAD_PIC(LREG) copy LREG, %r19 ASM_LINE_SEP
00040 /* Inline assembly defines */
00041 # define TREG_ASM "%r4" /* Cant clobber r3, it holds framemarker */
00042 # define SAVE_ASM_PIC       "       copy %%r19, %" TREG_ASM "\n"
00043 # define LOAD_ASM_PIC       "       copy %" TREG_ASM ", %%r19\n"
00044 # define CLOB_TREG   TREG_ASM ,
00045 # define PIC_REG_DEF register unsigned long __r19 asm("r19");
00046 # define PIC_REG_USE , "r" (__r19)
00047 #else
00048 # define TREG %r3
00049 # define SAVE_PIC(SREG) nop ASM_LINE_SEP
00050 # define LOAD_PIC(LREG) nop ASM_LINE_SEP
00051 /* Inline assembly defines */
00052 # define TREG_ASM 
00053 # define SAVE_ASM_PIC       "nop \n"
00054 # define LOAD_ASM_PIC       "nop \n"
00055 # define CLOB_TREG
00056 # define PIC_REG_DEF
00057 # define PIC_REG_USE
00058 #endif
00059 
00060 #ifdef __ASSEMBLER__
00061 
00062 /* Syntactic details of assembler.  */
00063 
00064 #define ALIGNARG(log2) log2
00065 
00066 /* For Linux we can use the system call table in the header file
00067        /usr/include/asm/unistd.h
00068    of the kernel.  But these symbols do not follow the SYS_* syntax
00069    so we have to redefine the `SYS_ify' macro here.  */
00070 #undef SYS_ify
00071 #define SYS_ify(syscall_name)      __NR_##syscall_name
00072 
00073 /* ELF-like local names start with `.L'.  */
00074 #undef L
00075 #define L(name)      .L##name
00076 
00077 /* Linux uses a negative return value to indicate syscall errors,
00078    unlike most Unices, which use the condition codes' carry flag.
00079 
00080    Since version 2.1 the return value of a system call might be
00081    negative even if the call succeeded.  E.g., the `lseek' system call
00082    might return a large offset.  Therefore we must not anymore test
00083    for < 0, but test for a real error by making sure the value in %eax
00084    is a real error number.  Linus said he will make sure the no syscall
00085    returns a value in -1 .. -4095 as a valid result so we can safely
00086    test with -4095.  */
00087 
00088 /* We don't want the label for the error handle to be global when we define
00089    it here.  */
00090 /*#ifdef PIC
00091 # define SYSCALL_ERROR_LABEL 0f
00092 #else
00093 # define SYSCALL_ERROR_LABEL syscall_error
00094 #endif*/
00095 
00096 /* Argument manipulation from the stack for preparing to
00097    make a syscall */
00098 
00099 #define DOARGS_0 /* nothing */
00100 #define DOARGS_1 /* nothing */
00101 #define DOARGS_2 /* nothing */
00102 #define DOARGS_3 /* nothing */
00103 #define DOARGS_4 /* nothing */
00104 #define DOARGS_5 ldw -52(%sp), %r22              ASM_LINE_SEP
00105 #define DOARGS_6 DOARGS_5 ldw -56(%sp), %r21     ASM_LINE_SEP
00106 
00107 #define UNDOARGS_0 /* nothing */
00108 #define UNDOARGS_1 /* nothing */
00109 #define UNDOARGS_2 /* nothing */
00110 #define UNDOARGS_3 /* nothing */
00111 #define UNDOARGS_4 /* nothing */
00112 #define UNDOARGS_5 /* nothing */
00113 #define UNDOARGS_6 /* nothing */
00114 
00115 /* Define an entry point visible from C.
00116 
00117    There is currently a bug in gdb which prevents us from specifying
00118    incomplete stabs information.  Fake some entries here which specify
00119    the current source file.  */
00120 #define       ENTRY(name)                                             \
00121        .text                                     ASM_LINE_SEP  \
00122        .align ALIGNARG(4)                        ASM_LINE_SEP  \
00123        .export C_SYMBOL_NAME(name)               ASM_LINE_SEP  \
00124        .type  C_SYMBOL_NAME(name),@function             ASM_LINE_SEP  \
00125        C_LABEL(name)                             ASM_LINE_SEP  \
00126        .PROC                                     ASM_LINE_SEP  \
00127        .CALLINFO FRAME=64,CALLS,SAVE_RP,ENTRY_GR=3      ASM_LINE_SEP  \
00128        .ENTRY                                    ASM_LINE_SEP  \
00129        /* SAVE_RP says we do */                  ASM_LINE_SEP  \
00130        stw %rp, -20(%sr0,%sp)                           ASM_LINE_SEP  \
00131        /*FIXME: Call mcount? (carefull with stack!) */
00132 
00133 /* Some syscall wrappers do not call other functions, and
00134    hence are classified as leaf, so add NO_CALLS for gdb */
00135 #define       ENTRY_LEAF(name)                                        \
00136        .text                                     ASM_LINE_SEP  \
00137        .align ALIGNARG(4)                        ASM_LINE_SEP  \
00138        .export C_SYMBOL_NAME(name)               ASM_LINE_SEP  \
00139        .type  C_SYMBOL_NAME(name),@function             ASM_LINE_SEP  \
00140        C_LABEL(name)                             ASM_LINE_SEP  \
00141        .PROC                                     ASM_LINE_SEP  \
00142        .CALLINFO FRAME=64,NO_CALLS,SAVE_RP,ENTRY_GR=3   ASM_LINE_SEP  \
00143        .ENTRY                                    ASM_LINE_SEP  \
00144        /* SAVE_RP says we do */                  ASM_LINE_SEP  \
00145        stw %rp, -20(%sr0,%sp)                           ASM_LINE_SEP  \
00146        /*FIXME: Call mcount? (carefull with stack!) */
00147 
00148 #undef END
00149 #define END(name)                                              \
00150        .EXIT                                     ASM_LINE_SEP  \
00151        .PROCEND                                  ASM_LINE_SEP  \
00152 .size  C_SYMBOL_NAME(name), .-C_SYMBOL_NAME(name)       ASM_LINE_SEP
00153 
00154 /* If compiled for profiling, call `mcount' at the start 
00155    of each function. No, don't bother.  gcc will put the 
00156    call in for us.  */
00157 #define CALL_MCOUNT         /* Do nothing.  */
00158 
00159 /* syscall wrappers consist of
00160        #include <sysdep.h>
00161        PSEUDO(...)
00162        ret
00163        PSEUDO_END(...)
00164 
00165    which means
00166        ENTRY(name)
00167        DO_CALL(...)
00168        nop
00169        bv 0(2)
00170        nop
00171 */
00172 
00173 #define       PSEUDO(name, syscall_name, args)                 \
00174   ENTRY (name)                                   ASM_LINE_SEP  \
00175   /* If necc. load args from stack */            ASM_LINE_SEP  \
00176   DOARGS_##args                                  ASM_LINE_SEP  \
00177   DO_CALL (syscall_name, args)                   ASM_LINE_SEP  \
00178   UNDOARGS_##args                         ASM_LINE_SEP  \
00179   nop                                     ASM_LINE_SEP
00180 
00181 #define ret \
00182   /* Return value set by ERRNO code */           ASM_LINE_SEP  \
00183   bv,n 0(2)                               ASM_LINE_SEP
00184 
00185 #undef PSEUDO_END
00186 #define       PSEUDO_END(name)                                 \
00187   END (name)
00188 
00189 /* We don't set the errno on the return from the syscall */
00190 #define       PSEUDO_NOERRNO(name, syscall_name, args)         \
00191   ENTRY_LEAF (name)                       ASM_LINE_SEP  \
00192   DOARGS_##args                                  ASM_LINE_SEP  \
00193   DO_CALL_NOERRNO (syscall_name, args)           ASM_LINE_SEP  \
00194   UNDOARGS_##args                         ASM_LINE_SEP  \
00195   nop                                     ASM_LINE_SEP
00196 
00197 #define ret_NOERRNO ret
00198 
00199 #undef PSEUDO_END_NOERRNO
00200 #define       PSEUDO_END_NOERRNO(name)                         \
00201   END (name)
00202 
00203 /* This has to return the error value */
00204 #undef  PSEUDO_ERRVAL
00205 #define PSEUDO_ERRVAL(name, syscall_name, args)                \
00206   ENTRY_LEAF (name)                       ASM_LINE_SEP  \
00207   DOARGS_##args                                  ASM_LINE_SEP  \
00208   DO_CALL_ERRVAL (syscall_name, args)            ASM_LINE_SEP  \
00209   UNDOARGS_##args                         ASM_LINE_SEP  \
00210   nop                                     ASM_LINE_SEP
00211 
00212 #define ret_ERRVAL ret
00213 
00214 #undef PSEUDO_END_ERRVAL
00215 #define PSEUDO_END_ERRVAL(name)                                \
00216        END(name)
00217 
00218 #undef JUMPTARGET
00219 #define JUMPTARGET(name)    name
00220 #define SYSCALL_PIC_SETUP   /* Nothing.  */
00221 
00222 
00223 /* FIXME: This comment is not true.
00224  * All the syscall assembly macros rely on finding the approriate
00225    SYSCALL_ERROR_LABEL or rather HANDLER. */
00226 
00227 /* int * __errno_location(void) so you have to store your value
00228    into the return address! */
00229 #define DEFAULT_SYSCALL_ERROR_HANDLER                   \
00230        .import __errno_location,code      ASM_LINE_SEP  \
00231        /* branch to errno handler */      ASM_LINE_SEP  \
00232        bl __errno_location,%rp            ASM_LINE_SEP
00233 
00234 /* Here are the myriad of configuration options that the above can
00235    work for... what we've done is provide the framework for future
00236    changes if required to each section */
00237 
00238 #ifdef PIC
00239 # if RTLD_PRIVATE_ERRNO
00240 #  define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER
00241 # else /* !RTLD_PRIVATE_ERRNO */
00242 #  if defined _LIBC_REENTRANT
00243 #   define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER
00244 #  else /* !_LIBC_REENTRANT */
00245 #   define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER
00246 #  endif /* _LIBC_REENTRANT */
00247 # endif /* RTLD_PRIVATE_ERRNO */
00248 #else
00249 # ifndef _LIBC_REENTRANT
00250 #  define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER
00251 # else
00252 #  define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER
00253 # endif
00254 #endif
00255 
00256 
00257 /* Linux takes system call arguments in registers:
00258        syscall number       gr20
00259        arg 1         gr26
00260        arg 2         gr25
00261        arg 3         gr24
00262        arg 4         gr23
00263        arg 5         gr22
00264        arg 6         gr21
00265 
00266    The compiler calls us by the C convention:
00267        syscall number       in the DO_CALL macro
00268        arg 1         gr26
00269        arg 2         gr25
00270        arg 3         gr24
00271        arg 4         gr23
00272        arg 5         -52(sp)
00273        arg 6         -56(sp)
00274 
00275    gr22 and gr21 are caller-saves, so we can just load the arguments
00276    there and generally be happy. */
00277 
00278 /* the cmpb...no_error code below inside DO_CALL
00279  * is intended to mimic the if (__sys_res...)
00280  * code inside INLINE_SYSCALL
00281  */
00282 #define NO_ERROR -0x1000
00283 
00284 #undef DO_CALL
00285 #define DO_CALL(syscall_name, args)                            \
00286        /* Create a frame */               ASM_LINE_SEP  \
00287        stwm TREG, 64(%sp)                 ASM_LINE_SEP  \
00288        stw %sp, -4(%sp)                   ASM_LINE_SEP  \
00289        stw %r19, -32(%sp)                 ASM_LINE_SEP  \
00290        /* Save r19 */                            ASM_LINE_SEP  \
00291        SAVE_PIC(TREG)                            ASM_LINE_SEP  \
00292        /* Do syscall, delay loads # */           ASM_LINE_SEP  \
00293        ble  0x100(%sr2,%r0)               ASM_LINE_SEP  \
00294        ldi SYS_ify (syscall_name), %r20   ASM_LINE_SEP  \
00295        ldi NO_ERROR,%r1                   ASM_LINE_SEP  \
00296        cmpb,>>=,n %r1,%ret0,L(pre_end)           ASM_LINE_SEP  \
00297        /* Restore r19 from TREG */        ASM_LINE_SEP  \
00298        LOAD_PIC(TREG) /* delay */         ASM_LINE_SEP  \
00299        SYSCALL_ERROR_HANDLER                     ASM_LINE_SEP  \
00300        /* Use TREG for temp storage */           ASM_LINE_SEP  \
00301        copy %ret0, TREG /* delay */              ASM_LINE_SEP  \
00302        /* OPTIMIZE: Don't reload r19 */   ASM_LINE_SEP  \
00303        /* do a -1*syscall_ret0 */         ASM_LINE_SEP  \
00304        sub %r0, TREG, TREG                ASM_LINE_SEP  \
00305        /* Store into errno location */           ASM_LINE_SEP  \
00306        stw TREG, 0(%sr0,%ret0)                   ASM_LINE_SEP  \
00307        /* return -1 as error */           ASM_LINE_SEP  \
00308        ldo -1(%r0), %ret0                 ASM_LINE_SEP  \
00309 L(pre_end):                               ASM_LINE_SEP  \
00310        /* Restore our frame, restoring TREG */   ASM_LINE_SEP  \
00311        ldwm -64(%sp), TREG                ASM_LINE_SEP  \
00312        /* Restore return pointer */              ASM_LINE_SEP  \
00313        ldw -20(%sp),%rp                   ASM_LINE_SEP
00314 
00315 /* We do nothing with the return, except hand it back to someone else */
00316 #undef  DO_CALL_NOERRNO
00317 #define DO_CALL_NOERRNO(syscall_name, args)                    \
00318        /* No need to store r19 */         ASM_LINE_SEP  \
00319        ble  0x100(%sr2,%r0)                    ASM_LINE_SEP    \
00320        ldi SYS_ify (syscall_name), %r20        ASM_LINE_SEP    \
00321        /* Caller will restore r19 */             ASM_LINE_SEP
00322 
00323 /* Here, we return the ERRVAL in assembly, note we don't call the
00324    error handler function, but we do 'negate' the return _IF_
00325    it's an error. Not sure if this is the right semantic. */
00326 
00327 #undef DO_CALL_ERRVAL
00328 #define DO_CALL_ERRVAL(syscall_name, args)                     \
00329        /* No need to store r19 */         ASM_LINE_SEP  \
00330        ble  0x100(%sr2,%r0)               ASM_LINE_SEP  \
00331        ldi SYS_ify (syscall_name), %r20   ASM_LINE_SEP  \
00332        /* Caller will restore r19 */             ASM_LINE_SEP  \
00333        ldi NO_ERROR,%r1                   ASM_LINE_SEP  \
00334        cmpb,>>=,n %r1,%ret0,0f                   ASM_LINE_SEP  \
00335        sub %r0, %ret0, %ret0                     ASM_LINE_SEP  \
00336 0:                                        ASM_LINE_SEP
00337 
00338 
00339 #else
00340 
00341 /* GCC has to be warned that a syscall may clobber all the ABI
00342    registers listed as "caller-saves", see page 8, Table 2
00343    in section 2.2.6 of the PA-RISC RUN-TIME architecture
00344    document. However! r28 is the result and will conflict with
00345    the clobber list so it is left out. Also the input arguments
00346    registers r20 -> r26 will conflict with the list so they
00347    are treated specially. Although r19 is clobbered by the syscall
00348    we cannot say this because it would violate ABI, thus we say
00349    TREG is clobbered and use that register to save/restore r19
00350    across the syscall. */
00351 
00352 #define CALL_CLOB_REGS      "%r1", "%r2", CLOB_TREG \
00353                      "%r20", "%r29", "%r31"
00354 
00355 #undef INLINE_SYSCALL
00356 #define INLINE_SYSCALL(name, nr, args...)                      \
00357 ({                                                             \
00358        long __sys_res;                                                \
00359        {                                                       \
00360               register unsigned long __res asm("r28");         \
00361               PIC_REG_DEF                                      \
00362               LOAD_ARGS_##nr(args)                             \
00363               /* FIXME: HACK save/load r19 around syscall */          \
00364               asm volatile(                                    \
00365                      SAVE_ASM_PIC                              \
00366                      "      ble  0x100(%%sr2, %%r0)\n"         \
00367                      "      ldi %1, %%r20\n"                   \
00368                      LOAD_ASM_PIC                              \
00369                      : "=r" (__res)                                   \
00370                      : "i" (SYS_ify(name)) PIC_REG_USE ASM_ARGS_##nr  \
00371                      : "memory", CALL_CLOB_REGS CLOB_ARGS_##nr \
00372               );                                               \
00373               __sys_res = (long)__res;                         \
00374        }                                                       \
00375        if ( (unsigned long)__sys_res >= (unsigned long)-4095 ){       \
00376               __set_errno(-__sys_res);                         \
00377               __sys_res = -1;                                         \
00378        }                                                       \
00379        __sys_res;                                              \
00380 })
00381 
00382 /* INTERNAL_SYSCALL_DECL - Allows us to setup some function static
00383    value to use within the context of the syscall
00384    INTERNAL_SYSCALL_ERROR_P - Returns 0 if it wasn't an error, 1 otherwise
00385    You are allowed to use the syscall result (val) and the DECL error 
00386    variable to determine what went wrong.
00387    INTERLAL_SYSCALL_ERRNO - Munges the val/err pair into the error number.
00388    In our case we just flip the sign. */
00389 
00390 #undef INTERNAL_SYSCALL_DECL
00391 #define INTERNAL_SYSCALL_DECL(err) 
00392 
00393 #undef INTERNAL_SYSCALL_ERROR_P
00394 #define INTERNAL_SYSCALL_ERROR_P(val, err) \
00395        ((val < 0) && (val > -4095))
00396 
00397 #undef INTERNAL_SYSCALL_ERRNO
00398 #define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
00399 
00400 /* Similar to INLINE_SYSCALL but we don't set errno */
00401 #undef INTERNAL_SYSCALL
00402 #define INTERNAL_SYSCALL(name, err, nr, args...)                      \
00403 ({                                                             \
00404        long __sys_res;                                                \
00405        {                                                       \
00406               register unsigned long __res asm("r28");         \
00407               PIC_REG_DEF                                      \
00408               LOAD_ARGS_##nr(args)                             \
00409               /* FIXME: HACK save/load r19 around syscall */          \
00410               asm volatile(                                    \
00411                      SAVE_ASM_PIC                              \
00412                      "      ble  0x100(%%sr2, %%r0)\n"         \
00413                      "      ldi %1, %%r20\n"                   \
00414                      LOAD_ASM_PIC                              \
00415                      : "=r" (__res)                                   \
00416                      : "i" (SYS_ify(name)) PIC_REG_USE ASM_ARGS_##nr  \
00417                      : "memory", CALL_CLOB_REGS CLOB_ARGS_##nr \
00418               );                                               \
00419               __sys_res = (long)__res;                         \
00420        }                                                       \
00421        __sys_res;                                              \
00422  })
00423 
00424 
00425 /* The _NCS variant allows non-constant syscall numbers.  */
00426 #undef INTERNAL_SYSCALL_NCS
00427 #define INTERNAL_SYSCALL_NCS(name, err, nr, args...)                  \
00428 ({                                                             \
00429        long __sys_res;                                                \
00430        {                                                       \
00431               register unsigned long __res asm("r28");         \
00432               PIC_REG_DEF                                      \
00433               LOAD_ARGS_##nr(args)                             \
00434               /* FIXME: HACK save/load r19 around syscall */          \
00435               asm volatile(                                    \
00436                      SAVE_ASM_PIC                              \
00437                      "      ble  0x100(%%sr2, %%r0)\n"         \
00438                      "      copy %1, %%r20\n"                  \
00439                      LOAD_ASM_PIC                              \
00440                      : "=r" (__res)                                   \
00441                      : "r" (name) PIC_REG_USE ASM_ARGS_##nr           \
00442                      : "memory", CALL_CLOB_REGS CLOB_ARGS_##nr \
00443               );                                               \
00444               __sys_res = (long)__res;                         \
00445        }                                                       \
00446        __sys_res;                                              \
00447  })
00448 
00449 
00450 
00451 #define LOAD_ARGS_0()
00452 #define LOAD_ARGS_1(r26)                                       \
00453   register unsigned long __r26 __asm__("r26") = (unsigned long)(r26); \
00454   LOAD_ARGS_0()
00455 #define LOAD_ARGS_2(r26,r25)                                          \
00456   register unsigned long __r25 __asm__("r25") = (unsigned long)(r25); \
00457   LOAD_ARGS_1(r26)
00458 #define LOAD_ARGS_3(r26,r25,r24)                               \
00459   register unsigned long __r24 __asm__("r24") = (unsigned long)(r24); \
00460   LOAD_ARGS_2(r26,r25)
00461 #define LOAD_ARGS_4(r26,r25,r24,r23)                                  \
00462   register unsigned long __r23 __asm__("r23") = (unsigned long)(r23); \
00463   LOAD_ARGS_3(r26,r25,r24)
00464 #define LOAD_ARGS_5(r26,r25,r24,r23,r22)                       \
00465   register unsigned long __r22 __asm__("r22") = (unsigned long)(r22); \
00466   LOAD_ARGS_4(r26,r25,r24,r23)
00467 #define LOAD_ARGS_6(r26,r25,r24,r23,r22,r21)                          \
00468   register unsigned long __r21 __asm__("r21") = (unsigned long)(r21); \
00469   LOAD_ARGS_5(r26,r25,r24,r23,r22)
00470 
00471 /* Even with zero args we use r20 for the syscall number */
00472 #define ASM_ARGS_0
00473 #define ASM_ARGS_1 ASM_ARGS_0, "r" (__r26)
00474 #define ASM_ARGS_2 ASM_ARGS_1, "r" (__r25)
00475 #define ASM_ARGS_3 ASM_ARGS_2, "r" (__r24)
00476 #define ASM_ARGS_4 ASM_ARGS_3, "r" (__r23)
00477 #define ASM_ARGS_5 ASM_ARGS_4, "r" (__r22)
00478 #define ASM_ARGS_6 ASM_ARGS_5, "r" (__r21)
00479 
00480 /* The registers not listed as inputs but clobbered */
00481 #define CLOB_ARGS_6
00482 #define CLOB_ARGS_5 CLOB_ARGS_6, "%r21"
00483 #define CLOB_ARGS_4 CLOB_ARGS_5, "%r22"
00484 #define CLOB_ARGS_3 CLOB_ARGS_4, "%r23"
00485 #define CLOB_ARGS_2 CLOB_ARGS_3, "%r24"
00486 #define CLOB_ARGS_1 CLOB_ARGS_2, "%r25"
00487 #define CLOB_ARGS_0 CLOB_ARGS_1, "%r26"
00488 
00489 #endif /* __ASSEMBLER__ */
00490 
00491 /* Pointer mangling is not yet supported for HPPA.  */
00492 #define PTR_MANGLE(var) (void) (var)
00493 #define PTR_DEMANGLE(var) (void) (var)
00494