; -----------------------------------------------------------------------

;  sysv.S - Copyright (c) 1998 Red Hat, Inc.

;  

;  ARM Foreign Function Interface 

;

;  Permission is hereby granted, free of charge, to any person obtaining

;  a copy of this software and associated documentation files (the

;  ``Software''), to deal in the Software without restriction, including

;  without limitation the rights to use, copy, modify, merge, publish,

;  distribute, sublicense, and/or sell copies of the Software, and to

;  permit persons to whom the Software is furnished to do so, subject to

;  the following conditions:

;

;  The above copyright notice and this permission notice shall be included

;  in all copies or substantial portions of the Software.

;

;  THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS

;  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

;  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

;  IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR

;  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

;  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

;  OTHER DEALINGS IN THE SOFTWARE.

;  ----------------------------------------------------------------------- */

;#define LIBFFI_ASM     

;#include <fficonfig.h>

;#include <ffi.h>

;#ifdef HAVE_MACHINE_ASM_H

;#include <machine/asm.h>

;#else

;#ifdef __USER_LABEL_PREFIX__

;#define CONCAT1(a, b) CONCAT2(a, b)

;#define CONCAT2(a, b) a ## b

;/* Use the right prefix for global labels.  */

;#define CNAME(x) CONCAT1 (__USER_LABEL_PREFIX__, x)

;#else

;#define CNAME(x) x

;#endif

;#define ENTRY(x) .globl CNAME(x); .type CNAME(x),%function; CNAME(x):

;#endif

FFI_TYPE_VOID       EQU 0

FFI_TYPE_INT        EQU 1

FFI_TYPE_FLOAT      EQU 2

FFI_TYPE_DOUBLE     EQU 3

;FFI_TYPE_LONGDOUBLE EQU 4

FFI_TYPE_UINT8      EQU 5

FFI_TYPE_SINT8      EQU 6

FFI_TYPE_UINT16     EQU 7

FFI_TYPE_SINT16     EQU 8

FFI_TYPE_UINT32     EQU 9

FFI_TYPE_SINT32     EQU 10

FFI_TYPE_UINT64     EQU 11

FFI_TYPE_SINT64     EQU 12

FFI_TYPE_STRUCT     EQU 13

FFI_TYPE_POINTER    EQU 14

; WinCE always uses software floating point (I think)

__SOFTFP__ EQU {TRUE}

    AREA |.text|, CODE, ARM     ; .text

    ; a1:   ffi_prep_args

    ; a2:   &ecif

    ; a3:   cif->bytes

    ; a4:   fig->flags

    ; sp+0: ecif.rvalue

    ; sp+4: fn

    ; This assumes we are using gas.

;ENTRY(ffi_call_SYSV)

    EXPORT |ffi_call_SYSV|

|ffi_call_SYSV| PROC

    ; Save registers

    stmfd sp!, {a1-a4, fp, lr}

    mov   fp, sp

    ; Make room for all of the new args.

    sub   sp, fp, a3

    ; Place all of the ffi_prep_args in position

    mov   ip, a1

    mov   a1, sp

    ;     a2 already set

    ; And call

    mov   lr, pc

    mov   pc, ip

    ; move first 4 parameters in registers

    ldr   a1, [sp, #0]

    ldr   a2, [sp, #4]

    ldr   a3, [sp, #8]

    ldr   a4, [sp, #12]

    ; and adjust stack

    ldr   ip, [fp, #8]

    cmp   ip, #16

    movge ip, #16

    add   sp, sp, ip

    ; call function

    mov   lr, pc

    ldr   pc, [fp, #28]

    ; Remove the space we pushed for the args

    mov   sp, fp

    ; Load a3 with the pointer to storage for the return value

    ldr   a3, [sp, #24]

    ; Load a4 with the return type code 

    ldr   a4, [sp, #12]

    ; If the return value pointer is NULL, assume no return value.

    cmp   a3, #0

    beq   call_epilogue

; return INT

    cmp   a4, #FFI_TYPE_INT

    streq a1, [a3]

    beq   call_epilogue

; return FLOAT

    cmp     a4, #FFI_TYPE_FLOAT

    [ __SOFTFP__                    ;ifdef __SOFTFP__

    streq   a1, [a3]

    |                               ;else

    stfeqs  f0, [a3]

    ]                               ;endif

    beq     call_epilogue

; return DOUBLE or LONGDOUBLE

    cmp     a4, #FFI_TYPE_DOUBLE

    [ __SOFTFP__                    ;ifdef __SOFTFP__

    stmeqia a3, {a1, a2}

    |                               ;else

    stfeqd  f0, [a3]

    ]                               ;endif

    beq     call_epilogue

; return SINT64 or UINT64

    cmp     a4, #FFI_TYPE_SINT64

    stmeqia a3, {a1, a2}

call_epilogue

    ldmfd   sp!, {a1-a4, fp, pc}

;.ffi_call_SYSV_end:

    ;.size    CNAME(ffi_call_SYSV),.ffi_call_SYSV_end-CNAME(ffi_call_SYSV)

    ENDP

RESERVE_RETURN EQU 16

    ; This function is called by the trampoline

    ; It is NOT callable from C

    ; ip = pointer to struct ffi_closure

    IMPORT |ffi_closure_SYSV_inner|

    EXPORT |ffi_closure_SYSV|

|ffi_closure_SYSV| PROC

    ; Store the argument registers on the stack

    stmfd   sp!, {a1-a4}

    ; Push the return address onto the stack

    stmfd   sp!, {lr}

    mov     a1, ip            ; first arg = address of ffi_closure

    add     a2, sp, #4        ; second arg = sp+4 (points to saved a1)

    ; Allocate space for a non-struct return value

    sub     sp, sp, #RESERVE_RETURN

    mov     a3, sp            ; third arg = return value address

    ; static unsigned int

    ; ffi_closure_SYSV_inner (ffi_closure *closure, char *in_args, void *rvalue)

    bl      ffi_closure_SYSV_inner

    ; a1 now contains the return type code 

    ; At this point the return value is on the stack

    ; Transfer it to the correct registers if necessary

; return INT

    cmp     a1, #FFI_TYPE_INT

    ldreq   a1, [sp]

    beq     closure_epilogue

; return FLOAT

    cmp     a1, #FFI_TYPE_FLOAT

    [ __SOFTFP__                    ;ifdef __SOFTFP__

    ldreq   a1, [sp]

    |                               ;else

    stfeqs  f0, [sp]

    ]                               ;endif

    beq     closure_epilogue

; return DOUBLE or LONGDOUBLE

    cmp     a1, #FFI_TYPE_DOUBLE

    [ __SOFTFP__                    ;ifdef __SOFTFP__

    ldmeqia sp, {a1, a2}

    |                               ;else

    stfeqd  f0, [sp]

    ]                               ;endif

    beq     closure_epilogue

; return SINT64 or UINT64

    cmp     a1, #FFI_TYPE_SINT64

    ldmeqia sp, {a1, a2}

closure_epilogue

    add     sp, sp, #RESERVE_RETURN   ; remove return value buffer

    ldmfd   sp!, {ip}         ; ip = pop return address

    add     sp, sp, #16       ; remove saved argument registers {a1-a4} from the stack

    mov     pc, ip            ; return

    ENDP    ; ffi_closure_SYSV

    END