libffi/src/alpha/osf.S

   1 /* -----------------------------------------------------------------------
   2    osf.S - Copyright (c) 1998, 2001, 2007 Red Hat
   3
   4    Alpha/OSF Foreign Function Interface
   5
   6    Permission is hereby granted, free of charge, to any person obtaining
   7    a copy of this software and associated documentation files (the
   8    ``Software''), to deal in the Software without restriction, including
   9    without limitation the rights to use, copy, modify, merge, publish,
  10    distribute, sublicense, and/or sell copies of the Software, and to
  11    permit persons to whom the Software is furnished to do so, subject to
  12    the following conditions:
  13
  14    The above copyright notice and this permission notice shall be included
  15    in all copies or substantial portions of the Software.
  16
  17    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20    IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23    OTHER DEALINGS IN THE SOFTWARE.
  24    ----------------------------------------------------------------------- */
  25
  26 #define LIBFFI_ASM
  27 #include <fficonfig.h>
  28 #include <ffi.h>
  29
  30         .arch ev6
  31         .text
  32
  33 /* ffi_call_osf (void *args, unsigned long bytes, unsigned flags,
  34                  void *raddr, void (*fnaddr)());
  35
  36    Bit o trickiness here -- ARGS+BYTES is the base of the stack frame
  37    for this function.  This has been allocated by ffi_call.  We also
  38    deallocate some of the stack that has been alloca'd.  */
  39
  40         .align  3
  41         .globl  ffi_call_osf
  42         .ent    ffi_call_osf
  43         FFI_HIDDEN(ffi_call_osf)
  44
  45 ffi_call_osf:
  46         .frame  $15, 32, $26, 0
  47         .mask   0x4008000, -32
  48 $LFB1:
  49         addq    $16,$17,$1
  50         mov     $16, $30
  51         stq     $26, 0($1)
  52         stq     $15, 8($1)
  53         stq     $18, 16($1)
  54         mov     $1, $15
  55 $LCFI1:
  56         .prologue 0
  57
  58         stq     $19, 24($1)
  59         mov     $20, $27
  60
  61         # Load up all of the (potential) argument registers.
  62         ldq     $16, 0($30)
  63         ldt     $f16, 0($30)
  64         ldt     $f17, 8($30)
  65         ldq     $17, 8($30)
  66         ldt     $f18, 16($30)
  67         ldq     $18, 16($30)
  68         ldt     $f19, 24($30)
  69         ldq     $19, 24($30)
  70         ldt     $f20, 32($30)
  71         ldq     $20, 32($30)
  72         ldt     $f21, 40($30)
  73         ldq     $21, 40($30)
  74
  75         # Deallocate the register argument area.
  76         lda     $30, 48($30)
  77
  78         jsr     $26, ($27), 0
  79         ldgp    $29, 0($26)
  80
  81         # If the return value pointer is NULL, assume no return value.
  82         ldq     $19, 24($15)
  83         ldq     $18, 16($15)
  84         ldq     $26, 0($15)
  85 $LCFI2:
  86         beq     $19, $noretval
  87
  88         # Store the return value out in the proper type.
  89         cmpeq   $18, FFI_TYPE_INT, $1
  90         bne     $1, $retint
  91         cmpeq   $18, FFI_TYPE_FLOAT, $2
  92         bne     $2, $retfloat
  93         cmpeq   $18, FFI_TYPE_DOUBLE, $3
  94         bne     $3, $retdouble
  95
  96         .align  3
  97 $noretval:
  98         ldq     $15, 8($15)
  99         ret
 100
 101         .align  4
 102 $retint:
 103         stq     $0, 0($19)
 104         nop
 105         ldq     $15, 8($15)
 106         ret
 107
 108         .align  4
 109 $retfloat:
 110         sts     $f0, 0($19)
 111         nop
 112         ldq     $15, 8($15)
 113         ret
 114
 115         .align  4
 116 $retdouble:
 117         stt     $f0, 0($19)
 118         nop
 119         ldq     $15, 8($15)
 120         ret
 121 $LFE1:
 122
 123         .end    ffi_call_osf
 124
 125 /* ffi_closure_osf(...)
 126
 127    Receives the closure argument in $1.   */
 128
 129         .align  3
 130         .globl  ffi_closure_osf
 131         .ent    ffi_closure_osf
 132         FFI_HIDDEN(ffi_closure_osf)
 133
 134 ffi_closure_osf:
 135         .frame  $30, 16*8, $26, 0
 136         .mask   0x4000000, -16*8
 137 $LFB2:
 138         ldgp    $29, 0($27)
 139         subq    $30, 16*8, $30
 140 $LCFI5:
 141         stq     $26, 0($30)
 142 $LCFI6:
 143         .prologue 1
 144
 145         # Store all of the potential argument registers in va_list format.
 146         stt     $f16, 4*8($30)
 147         stt     $f17, 5*8($30)
 148         stt     $f18, 6*8($30)
 149         stt     $f19, 7*8($30)
 150         stt     $f20, 8*8($30)
 151         stt     $f21, 9*8($30)
 152         stq     $16, 10*8($30)
 153         stq     $17, 11*8($30)
 154         stq     $18, 12*8($30)
 155         stq     $19, 13*8($30)
 156         stq     $20, 14*8($30)
 157         stq     $21, 15*8($30)
 158
 159         # Call ffi_closure_osf_inner to do the bulk of the work.
 160         mov     $1, $16
 161         lda     $17, 2*8($30)
 162         lda     $18, 10*8($30)
 163         jsr     $26, ffi_closure_osf_inner
 164         ldgp    $29, 0($26)
 165         ldq     $26, 0($30)
 166
 167         # Load up the return value in the proper type.
 168         lda     $1, $load_table
 169         s4addq  $0, $1, $1
 170         ldl     $1, 0($1)
 171         addq    $1, $29, $1
 172         jmp     $31, ($1), $load_32
 173
 174         .align 4
 175 $load_none:
 176         addq    $30, 16*8, $30
 177         ret
 178
 179         .align 4
 180 $load_float:
 181         lds     $f0, 16($30)
 182         nop
 183         addq    $30, 16*8, $30
 184         ret
 185
 186         .align 4
 187 $load_double:
 188         ldt     $f0, 16($30)
 189         nop
 190         addq    $30, 16*8, $30
 191         ret
 192
 193         .align 4
 194 $load_u8:
 195 #ifdef __alpha_bwx__
 196         ldbu    $0, 16($30)
 197         nop
 198 #else
 199         ldq     $0, 16($30)
 200         and     $0, 255, $0
 201 #endif
 202         addq    $30, 16*8, $30
 203         ret
 204
 205         .align 4
 206 $load_s8:
 207 #ifdef __alpha_bwx__
 208         ldbu    $0, 16($30)
 209         sextb   $0, $0
 210 #else
 211         ldq     $0, 16($30)
 212         sll     $0, 56, $0
 213         sra     $0, 56, $0
 214 #endif
 215         addq    $30, 16*8, $30
 216         ret
 217
 218         .align 4
 219 $load_u16:
 220 #ifdef __alpha_bwx__
 221         ldwu    $0, 16($30)
 222         nop
 223 #else
 224         ldq     $0, 16($30)
 225         zapnot  $0, 3, $0
 226 #endif
 227         addq    $30, 16*8, $30
 228         ret
 229
 230         .align 4
 231 $load_s16:
 232 #ifdef __alpha_bwx__
 233         ldwu    $0, 16($30)
 234         sextw   $0, $0
 235 #else
 236         ldq     $0, 16($30)
 237         sll     $0, 48, $0
 238         sra     $0, 48, $0
 239 #endif
 240         addq    $30, 16*8, $30
 241         ret
 242
 243         .align 4
 244 $load_32:
 245         ldl     $0, 16($30)
 246         nop
 247         addq    $30, 16*8, $30
 248         ret
 249
 250         .align 4
 251 $load_64:
 252         ldq     $0, 16($30)
 253         nop
 254         addq    $30, 16*8, $30
 255         ret
 256 $LFE2:
 257
 258         .end    ffi_closure_osf
 259
 260 #ifdef __ELF__
 261 .section .rodata
 262 #else
 263 .rdata
 264 #endif
 265 $load_table:
 266         .gprel32 $load_none     # FFI_TYPE_VOID
 267         .gprel32 $load_32       # FFI_TYPE_INT
 268         .gprel32 $load_float    # FFI_TYPE_FLOAT
 269         .gprel32 $load_double   # FFI_TYPE_DOUBLE
 270         .gprel32 $load_none     # FFI_TYPE_LONGDOUBLE
 271         .gprel32 $load_u8       # FFI_TYPE_UINT8
 272         .gprel32 $load_s8       # FFI_TYPE_SINT8
 273         .gprel32 $load_u16      # FFI_TYPE_UINT16
 274         .gprel32 $load_s16      # FFI_TYPE_SINT16
 275         .gprel32 $load_32       # FFI_TYPE_UINT32
 276         .gprel32 $load_32       # FFI_TYPE_SINT32
 277         .gprel32 $load_64       # FFI_TYPE_UINT64
 278         .gprel32 $load_64       # FFI_TYPE_SINT64
 279         .gprel32 $load_none     # FFI_TYPE_STRUCT
 280         .gprel32 $load_64       # FFI_TYPE_POINTER
 281
 282 /* Assert that the table above is in sync with ffi.h.  */
 283
 284 #if        FFI_TYPE_FLOAT != 2          \
 285         || FFI_TYPE_DOUBLE != 3         \
 286         || FFI_TYPE_UINT8 != 5          \
 287         || FFI_TYPE_SINT8 != 6          \
 288         || FFI_TYPE_UINT16 != 7         \
 289         || FFI_TYPE_SINT16 != 8         \
 290         || FFI_TYPE_UINT32 != 9         \
 291         || FFI_TYPE_SINT32 != 10        \
 292         || FFI_TYPE_UINT64 != 11        \
 293         || FFI_TYPE_SINT64 != 12        \
 294         || FFI_TYPE_STRUCT != 13        \
 295         || FFI_TYPE_POINTER != 14       \
 296         || FFI_TYPE_LAST != 14
 297 #error "osf.S out of sync with ffi.h"
 298 #endif
 299
 300 #ifdef __ELF__
 301         .section        .eh_frame,EH_FRAME_FLAGS,@progbits
 302 __FRAME_BEGIN__:
 303         .4byte  $LECIE1-$LSCIE1 # Length of Common Information Entry
 304 $LSCIE1:
 305         .4byte  0x0             # CIE Identifier Tag
 306         .byte   0x1             # CIE Version
 307         .ascii "zR\0"           # CIE Augmentation
 308         .byte   0x1             # uleb128 0x1; CIE Code Alignment Factor
 309         .byte   0x78            # sleb128 -8; CIE Data Alignment Factor
 310         .byte   26              # CIE RA Column
 311         .byte   0x1             # uleb128 0x1; Augmentation size
 312         .byte   0x1b            # FDE Encoding (pcrel sdata4)
 313         .byte   0xc             # DW_CFA_def_cfa
 314         .byte   30              # uleb128 column 30
 315         .byte   0               # uleb128 offset 0
 316         .align 3
 317 $LECIE1:
 318 $LSFDE1:
 319         .4byte  $LEFDE1-$LASFDE1                # FDE Length
 320 $LASFDE1:
 321         .4byte  $LASFDE1-__FRAME_BEGIN__        # FDE CIE offset
 322         .4byte  $LFB1-.         # FDE initial location
 323         .4byte  $LFE1-$LFB1     # FDE address range
 324         .byte   0x0             # uleb128 0x0; Augmentation size
 325
 326         .byte   0x4             # DW_CFA_advance_loc4
 327         .4byte  $LCFI1-$LFB1
 328         .byte   0x9a            # DW_CFA_offset, column 26
 329         .byte   4               # uleb128 4*-8
 330         .byte   0x8f            # DW_CFA_offset, column 15
 331         .byte   0x3             # uleb128 3*-8
 332         .byte   0xc             # DW_CFA_def_cfa
 333         .byte   15              # uleb128 column 15
 334         .byte   32              # uleb128 offset 32
 335
 336         .byte   0x4             # DW_CFA_advance_loc4
 337         .4byte  $LCFI2-$LCFI1
 338         .byte   0xda            # DW_CFA_restore, column 26
 339         .align 3
 340 $LEFDE1:
 341
 342 $LSFDE3:
 343         .4byte  $LEFDE3-$LASFDE3                # FDE Length
 344 $LASFDE3:
 345         .4byte  $LASFDE3-__FRAME_BEGIN__        # FDE CIE offset
 346         .4byte  $LFB2-.         # FDE initial location
 347         .4byte  $LFE2-$LFB2     # FDE address range
 348         .byte   0x0             # uleb128 0x0; Augmentation size
 349
 350         .byte   0x4             # DW_CFA_advance_loc4
 351         .4byte  $LCFI5-$LFB2
 352         .byte   0xe             # DW_CFA_def_cfa_offset
 353         .byte   0x80,0x1        # uleb128 128
 354
 355         .byte   0x4             # DW_CFA_advance_loc4
 356         .4byte  $LCFI6-$LCFI5
 357         .byte   0x9a            # DW_CFA_offset, column 26
 358         .byte   16              # uleb128 offset 16*-8
 359         .align 3
 360 $LEFDE3:
 361 #endif