libffi/src/metag/sysv.S

   1 /* -----------------------------------------------------------------------
   2    sysv.S - Copyright (c) 2013 Imagination Technologies Ltd.
   3
   4    Meta 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
  18    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
  19    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  22    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  25    DEALINGS IN THE SOFTWARE.
  26    ----------------------------------------------------------------------- */
  27
  28 #define LIBFFI_ASM
  29 #include <fficonfig.h>
  30 #include <ffi.h>
  31 #ifdef HAVE_MACHINE_ASM_H
  32 #include <machine/asm.h>
  33 #else
  34 #ifdef __USER_LABEL_PREFIX__
  35 #define CONCAT1(a, b) CONCAT2(a, b)
  36 #define CONCAT2(a, b) a ## b
  37
  38 /* Use the right prefix for global labels. */
  39 #define CNAME(x) CONCAT1 (__USER_LABEL_PREFIX__, x)
  40 #else
  41 #define CNAME(x) x
  42 #endif
  43 #define ENTRY(x) .globl CNAME(x); .type CNAME(x), %function; CNAME(x):
  44 #endif
  45
  46 #ifdef __ELF__
  47 #define LSYM(x) .x
  48 #else
  49 #define LSYM(x) x
  50 #endif
  51
  52 .macro call_reg x=
  53         .text
  54         .balign 4
  55         mov D1RtP, \x
  56         swap D1RtP, PC
  57 .endm
  58
  59 ! Save register arguments
  60 .macro SAVE_ARGS
  61         .text
  62         .balign 4
  63         setl    [A0StP++], D0Ar6, D1Ar5
  64         setl    [A0StP++], D0Ar4, D1Ar3
  65         setl    [A0StP++], D0Ar2, D1Ar1
  66 .endm
  67
  68 ! Save retrun, frame pointer and other regs
  69 .macro SAVE_REGS regs=
  70         .text
  71         .balign 4
  72         setl    [A0StP++], D0FrT, D1RtP
  73         ! Needs to be a pair of regs
  74         .ifnc "\regs",""
  75         setl    [A0StP++], \regs
  76         .endif
  77 .endm
  78
  79 ! Declare a global function
  80 .macro METAG_FUNC_START name
  81         .text
  82         .balign 4
  83         ENTRY(\name)
  84 .endm
  85
  86 ! Return registers from the stack. Reverse SAVE_REGS operation
  87 .macro RET_REGS regs=, cond=
  88         .ifnc "\regs", ""
  89         getl    \regs, [--A0StP]
  90         .endif
  91         getl    D0FrT, D1RtP, [--A0StP]
  92 .endm
  93
  94 ! Return arguments
  95 .macro RET_ARGS
  96         getl    D0Ar2, D1Ar1, [--A0StP]
  97         getl    D0Ar4, D1Ar3, [--A0StP]
  98         getl    D0Ar6, D1Ar5, [--A0StP]
  99 .endm
 100
 101
 102         ! D1Ar1:        fn
 103         ! D0Ar2:        &ecif
 104         ! D1Ar3:        cif->bytes
 105         ! D0Ar4:        fig->flags
 106         ! D1Ar5:        ecif.rvalue
 107
 108         ! This assumes we are using GNU as
 109 METAG_FUNC_START ffi_call_SYSV
 110         ! Save argument registers
 111
 112         SAVE_ARGS
 113
 114         ! new frame
 115         mov     D0FrT, A0FrP
 116         add     A0FrP, A0StP, #0
 117
 118         ! Preserve the old frame pointer
 119         SAVE_REGS "D1.5, D0.5"
 120
 121         ! Make room for new args. cifs->bytes is the total space for input
 122         ! and return arguments
 123
 124         add     A0StP, A0StP, D1Ar3
 125
 126         ! Preserve cifs->bytes & fn
 127         mov     D0.5, D1Ar3
 128         mov     D1.5, D1Ar1
 129
 130         ! Place all of the ffi_prep_args in position
 131         mov     D1Ar1, A0StP
 132
 133         ! Call ffi_prep_args(stack, &ecif)
 134 #ifdef __PIC__
 135         callr  D1RtP, CNAME(ffi_prep_args@PLT)
 136 #else
 137         callr  D1RtP, CNAME(ffi_prep_args)
 138 #endif
 139
 140         ! Restore fn pointer
 141
 142         ! The foreign stack should look like this
 143         ! XXXXX XXXXXX <--- stack pointer
 144         ! FnArgN rvalue
 145         ! FnArgN+2 FnArgN+1
 146         ! FnArgN+4 FnArgN+3
 147         ! ....
 148         !
 149
 150         ! A0StP now points to the first (or return) argument + 4
 151
 152         ! Preserve cif->bytes
 153         getl    D0Ar2, D1Ar1, [--A0StP]
 154         getl    D0Ar4, D1Ar3, [--A0StP]
 155         getl    D0Ar6, D1Ar5, [--A0StP]
 156
 157         ! Place A0StP to the first argument again
 158         add     A0StP, A0StP, #24 ! That's because we loaded 6 regs x 4 byte each
 159
 160         ! A0FrP points to the initial stack without the reserved space for the
 161         ! cifs->bytes, whilst A0StP points to the stack after the space allocation
 162
 163         ! fn was the first argument of ffi_call_SYSV.
 164         ! The stack at this point looks like this:
 165         !
 166         ! A0StP(on entry to _SYSV) ->   Arg6    Arg5     | low
 167         !                               Arg4    Arg3     |
 168         !                               Arg2    Arg1     |
 169         ! A0FrP ---->                   D0FrtP  D1RtP    |
 170         !                               D1.5    D0.5     |
 171         ! A0StP(bf prep_args) ->        FnArgn  FnArgn-1 |
 172         !                               FnArgn-2FnArgn-3 |
 173         !                               ................ | <= cifs->bytes
 174         !                               FnArg4  FnArg3   |
 175         ! A0StP (prv_A0StP+cifs->bytes) FnArg2  FnArg1   | high
 176         !
 177         ! fn was in Arg1 so it's located in in A0FrP+#-0xC
 178         !
 179
 180         ! D0Re0 contains the size of arguments stored in registers
 181         sub     A0StP, A0StP, D0Re0
 182
 183         ! Arg1 is the function pointer for the foreign call. This has been
 184         ! preserved in D1.5
 185
 186         ! Time to call (fn). Arguments should be like this:
 187         ! Arg1-Arg6 are loaded to regs
 188         ! The rest of the arguments are stored in stack pointed by A0StP
 189
 190         call_reg D1.5
 191
 192         ! Reset stack.
 193
 194         mov     A0StP, A0FrP
 195
 196         ! Load Arg1 with the pointer to storage for the return type
 197         ! This was stored in Arg5
 198
 199         getd    D1Ar1, [A0FrP+#-20]
 200
 201         ! Load D0Ar2 with the return type code. This was stored in Arg4 (flags)
 202
 203         getd    D0Ar2, [A0FrP+#-16]
 204
 205         ! We are ready to start processing the return value
 206         ! D0Re0 (and D1Re0) hold the return value
 207
 208         ! If the return value is NULL, assume no return value
 209         cmp     D1Ar1, #0
 210         beq     LSYM(Lepilogue)
 211
 212         ! return INT
 213         cmp             D0Ar2, #FFI_TYPE_INT
 214         ! Sadly, there is no setd{cc} instruction so we need to workaround that
 215         bne     .INT64
 216         setd    [D1Ar1], D0Re0
 217         b       LSYM(Lepilogue)
 218
 219         ! return INT64
 220 .INT64:
 221         cmp     D0Ar2, #FFI_TYPE_SINT64
 222         setleq  [D1Ar1], D0Re0, D1Re0
 223
 224         ! return DOUBLE
 225         cmp     D0Ar2, #FFI_TYPE_DOUBLE
 226         setl    [D1AR1++], D0Re0, D1Re0
 227
 228 LSYM(Lepilogue):
 229         ! At this point, the stack pointer points right after the argument
 230         ! saved area. We need to restore 4 regs, therefore we need to move
 231         ! 16 bytes ahead.
 232         add     A0StP, A0StP, #16
 233         RET_REGS "D1.5, D0.5"
 234         RET_ARGS
 235         getd    D0Re0, [A0StP]
 236         mov     A0FrP, D0FrT
 237         swap    D1RtP, PC
 238
 239 .ffi_call_SYSV_end:
 240        .size   CNAME(ffi_call_SYSV),.ffi_call_SYSV_end-CNAME(ffi_call_SYSV)
 241
 242
 243 /*
 244         (called by ffi_metag_trampoline)
 245         void ffi_closure_SYSV (ffi_closure*)
 246
 247         (called by ffi_closure_SYSV)
 248         unsigned int FFI_HIDDEN
 249         ffi_closure_SYSV_inner (closure,respp, args)
 250                 ffi_closure *closure;
 251                 void **respp;
 252                 void *args;
 253 */
 254
 255 METAG_FUNC_START ffi_closure_SYSV
 256         ! We assume that D1Ar1 holds the address of the
 257         ! ffi_closure struct. We will use that to fetch the
 258         ! arguments. The stack pointer points to an empty space
 259         ! and it is ready to store more data.
 260
 261         ! D1Ar1 is ready
 262         ! Allocate stack space for return value
 263         add A0StP, A0StP, #8
 264         ! Store it to D0Ar2
 265         sub D0Ar2, A0StP, #8
 266
 267         sub D1Ar3, A0FrP, #4
 268
 269         ! D1Ar3 contains the address of the original D1Ar1 argument
 270         ! We need to subtract #4 later on
 271
 272         ! Preverve D0Ar2
 273         mov D0.5, D0Ar2
 274
 275 #ifdef __PIC__
 276         callr D1RtP, CNAME(ffi_closure_SYSV_inner@PLT)
 277 #else
 278         callr D1RtP, CNAME(ffi_closure_SYSV_inner)
 279 #endif
 280
 281         ! Check the return value and store it to D0.5
 282         cmp D0Re0, #FFI_TYPE_INT
 283         beq .Lretint
 284         cmp D0Re0, #FFI_TYPE_DOUBLE
 285         beq .Lretdouble
 286 .Lclosure_epilogue:
 287         sub A0StP, A0StP, #8
 288         RET_REGS "D1.5, D0.5"
 289         RET_ARGS
 290         swap    D1RtP, PC
 291
 292 .Lretint:
 293         setd [D0.5], D0Re0
 294         b .Lclosure_epilogue
 295 .Lretdouble:
 296         setl [D0.5++], D0Re0, D1Re0
 297         b .Lclosure_epilogue
 298 .ffi_closure_SYSV_end:
 299 .size CNAME(ffi_closure_SYSV),.ffi_closure_SYSV_end-CNAME(ffi_closure_SYSV)
 300
 301
 302 ENTRY(ffi_metag_trampoline)
 303         SAVE_ARGS
 304         ! New frame
 305         mov A0FrP, A0StP
 306         SAVE_REGS "D1.5, D0.5"
 307         mov D0.5, PC
 308         ! Load D1Ar1 the value of ffi_metag_trampoline
 309         getd D1Ar1, [D0.5 + #8]
 310         ! Jump to ffi_closure_SYSV
 311         getd PC, [D0.5 + #12]