Subversion Repositories openrisc

/* -----------------------------------------------------------------------
   unix.S - Copyright (c) 1998, 2008 Red Hat, Inc.
            Copyright (c) 2000 Hewlett Packard Company
   
   IA64/unix Foreign Function Interface 

   Primary author: Hans Boehm, HP Labs

   Loosely modeled on Cygnus code for other platforms.

   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 THE AUTHORS OR COPYRIGHT
   HOLDERS 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>
#include "ia64_flags.h"

        .pred.safe_across_calls p1-p5,p16-p63
.text

/* int ffi_call_unix (struct ia64_args *stack, PTR64 rvalue,
                      void (*fn)(void), int flags);
 */

        .align 16
        .global ffi_call_unix
        .proc   ffi_call_unix
ffi_call_unix:
        .prologue
        /* Bit o trickiness.  We actually share a stack frame with ffi_call.
           Rely on the fact that ffi_call uses a vframe and don't bother
           tracking one here at all.  */
        .fframe 0
        .save   ar.pfs, r36 // loc0
        alloc   loc0 = ar.pfs, 4, 3, 8, 0
        .save   rp, loc1
        mov     loc1 = b0
        .body
        add     r16 = 16, in0
        mov     loc2 = gp
        mov     r8 = in1
        ;;

        /* Load up all of the argument registers.  */
        ldf.fill f8 = [in0], 32
        ldf.fill f9 = [r16], 32
        ;;
        ldf.fill f10 = [in0], 32
        ldf.fill f11 = [r16], 32
        ;;
        ldf.fill f12 = [in0], 32
        ldf.fill f13 = [r16], 32
        ;;
        ldf.fill f14 = [in0], 32
        ldf.fill f15 = [r16], 24
        ;;
        ld8     out0 = [in0], 16
        ld8     out1 = [r16], 16
        ;;
        ld8     out2 = [in0], 16
        ld8     out3 = [r16], 16
        ;;
        ld8     out4 = [in0], 16
        ld8     out5 = [r16], 16
        ;;
        ld8     out6 = [in0]
        ld8     out7 = [r16]
        ;;

        /* Deallocate the register save area from the stack frame.  */
        mov     sp = in0

        /* Call the target function.  */
        ld8     r16 = [in2], 8
        ;;
        ld8     gp = [in2]
        mov     b6 = r16
        br.call.sptk.many b0 = b6
        ;;

        /* Dispatch to handle return value.  */
        mov     gp = loc2
        zxt1    r16 = in3
        ;;
        mov     ar.pfs = loc0
        addl    r18 = @ltoffx(.Lst_table), gp
        ;;
        ld8.mov r18 = [r18], .Lst_table
        mov     b0 = loc1
        ;;
        shladd  r18 = r16, 3, r18
        ;;
        ld8     r17 = [r18]
        shr     in3 = in3, 8
        ;;
        add     r17 = r17, r18
        ;;
        mov     b6 = r17
        br      b6
        ;;

.Lst_void:
        br.ret.sptk.many b0
        ;;
.Lst_uint8:
        zxt1    r8 = r8
        ;;
        st8     [in1] = r8
        br.ret.sptk.many b0
        ;;
.Lst_sint8:
        sxt1    r8 = r8
        ;;
        st8     [in1] = r8
        br.ret.sptk.many b0
        ;;
.Lst_uint16:
        zxt2    r8 = r8
        ;;
        st8     [in1] = r8
        br.ret.sptk.many b0
        ;;
.Lst_sint16:
        sxt2    r8 = r8
        ;;
        st8     [in1] = r8
        br.ret.sptk.many b0
        ;;
.Lst_uint32:
        zxt4    r8 = r8
        ;;
        st8     [in1] = r8
        br.ret.sptk.many b0
        ;;
.Lst_sint32:
        sxt4    r8 = r8
        ;;
        st8     [in1] = r8
        br.ret.sptk.many b0
        ;;
.Lst_int64:
        st8     [in1] = r8
        br.ret.sptk.many b0
        ;;
.Lst_float:
        stfs    [in1] = f8
        br.ret.sptk.many b0
        ;;
.Lst_double:
        stfd    [in1] = f8
        br.ret.sptk.many b0
        ;;
.Lst_ldouble:
        stfe    [in1] = f8
        br.ret.sptk.many b0
        ;;

.Lst_small_struct:
        add     sp = -16, sp
        cmp.lt  p6, p0 = 8, in3
        cmp.lt  p7, p0 = 16, in3
        cmp.lt  p8, p0 = 24, in3
        ;;
        add     r16 = 8, sp
        add     r17 = 16, sp
        add     r18 = 24, sp
        ;;
        st8     [sp] = r8
(p6)    st8     [r16] = r9
        mov     out0 = in1
(p7)    st8     [r17] = r10
(p8)    st8     [r18] = r11
        mov     out1 = sp
        mov     out2 = in3
        br.call.sptk.many b0 = memcpy#
        ;;
        mov     ar.pfs = loc0
        mov     b0 = loc1
        mov     gp = loc2
        br.ret.sptk.many b0

.Lst_hfa_float:
        add     r16 = 4, in1
        cmp.lt  p6, p0 = 4, in3
        ;;
        stfs    [in1] = f8, 8
(p6)    stfs    [r16] = f9, 8
        cmp.lt  p7, p0 = 8, in3
        cmp.lt  p8, p0 = 12, in3
        ;;
(p7)    stfs    [in1] = f10, 8
(p8)    stfs    [r16] = f11, 8
        cmp.lt  p9, p0 = 16, in3
        cmp.lt  p10, p0 = 20, in3
        ;;
(p9)    stfs    [in1] = f12, 8
(p10)   stfs    [r16] = f13, 8
        cmp.lt  p6, p0 = 24, in3
        cmp.lt  p7, p0 = 28, in3
        ;;
(p6)    stfs    [in1] = f14
(p7)    stfs    [r16] = f15
        br.ret.sptk.many b0
        ;;

.Lst_hfa_double:
        add     r16 = 8, in1
        cmp.lt  p6, p0 = 8, in3
        ;;
        stfd    [in1] = f8, 16
(p6)    stfd    [r16] = f9, 16
        cmp.lt  p7, p0 = 16, in3
        cmp.lt  p8, p0 = 24, in3
        ;;
(p7)    stfd    [in1] = f10, 16
(p8)    stfd    [r16] = f11, 16
        cmp.lt  p9, p0 = 32, in3
        cmp.lt  p10, p0 = 40, in3
        ;;
(p9)    stfd    [in1] = f12, 16
(p10)   stfd    [r16] = f13, 16
        cmp.lt  p6, p0 = 48, in3
        cmp.lt  p7, p0 = 56, in3
        ;;
(p6)    stfd    [in1] = f14
(p7)    stfd    [r16] = f15
        br.ret.sptk.many b0
        ;;

.Lst_hfa_ldouble:
        add     r16 = 16, in1
        cmp.lt  p6, p0 = 16, in3
        ;;
        stfe    [in1] = f8, 32
(p6)    stfe    [r16] = f9, 32
        cmp.lt  p7, p0 = 32, in3
        cmp.lt  p8, p0 = 48, in3
        ;;
(p7)    stfe    [in1] = f10, 32
(p8)    stfe    [r16] = f11, 32
        cmp.lt  p9, p0 = 64, in3
        cmp.lt  p10, p0 = 80, in3
        ;;
(p9)    stfe    [in1] = f12, 32
(p10)   stfe    [r16] = f13, 32
        cmp.lt  p6, p0 = 96, in3
        cmp.lt  p7, p0 = 112, in3
        ;;
(p6)    stfe    [in1] = f14
(p7)    stfe    [r16] = f15
        br.ret.sptk.many b0
        ;;

        .endp ffi_call_unix

        .align 16
        .global ffi_closure_unix
        .proc ffi_closure_unix

#define FRAME_SIZE      (8*16 + 8*8 + 8*16)

ffi_closure_unix:
        .prologue
        .save   ar.pfs, r40 // loc0
        alloc   loc0 = ar.pfs, 8, 4, 4, 0
        .fframe FRAME_SIZE
        add     r12 = -FRAME_SIZE, r12
        .save   rp, loc1
        mov     loc1 = b0
        .save   ar.unat, loc2
        mov     loc2 = ar.unat
        .body

        /* Retrieve closure pointer and real gp.  */
#ifdef _ILP32
        addp4   out0 = 0, gp
        addp4   gp = 16, gp
#else
        mov     out0 = gp
        add     gp = 16, gp
#endif
        ;;
        ld8     gp = [gp]

        /* Spill all of the possible argument registers.  */
        add     r16 = 16 + 8*16, sp
        add     r17 = 16 + 8*16 + 16, sp
        ;;
        stf.spill [r16] = f8, 32
        stf.spill [r17] = f9, 32
        mov     loc3 = gp
        ;;
        stf.spill [r16] = f10, 32
        stf.spill [r17] = f11, 32
        ;;
        stf.spill [r16] = f12, 32
        stf.spill [r17] = f13, 32
        ;;
        stf.spill [r16] = f14, 32
        stf.spill [r17] = f15, 24
        ;;
        .mem.offset 0, 0
        st8.spill [r16] = in0, 16
        .mem.offset 8, 0
        st8.spill [r17] = in1, 16
        add     out1 = 16 + 8*16, sp
        ;;
        .mem.offset 0, 0
        st8.spill [r16] = in2, 16
        .mem.offset 8, 0
        st8.spill [r17] = in3, 16
        add     out2 = 16, sp
        ;;
        .mem.offset 0, 0
        st8.spill [r16] = in4, 16
        .mem.offset 8, 0
        st8.spill [r17] = in5, 16
        mov     out3 = r8
        ;;
        .mem.offset 0, 0
        st8.spill [r16] = in6
        .mem.offset 8, 0
        st8.spill [r17] = in7

        /* Invoke ffi_closure_unix_inner for the hard work.  */
        br.call.sptk.many b0 = ffi_closure_unix_inner
        ;;

        /* Dispatch to handle return value.  */
        mov     gp = loc3
        zxt1    r16 = r8
        ;;
        addl    r18 = @ltoffx(.Lld_table), gp
        mov     ar.pfs = loc0
        ;;
        ld8.mov r18 = [r18], .Lld_table
        mov     b0 = loc1
        ;;
        shladd  r18 = r16, 3, r18
        mov     ar.unat = loc2
        ;;
        ld8     r17 = [r18]
        shr     r8 = r8, 8
        ;;
        add     r17 = r17, r18
        add     r16 = 16, sp
        ;;
        mov     b6 = r17
        br      b6
        ;;
        .label_state 1

.Lld_void:
        .restore sp
        add     sp = FRAME_SIZE, sp
        br.ret.sptk.many b0
        ;;
.Lld_int:
        .body
        .copy_state 1
        ld8     r8 = [r16]
        .restore sp
        add     sp = FRAME_SIZE, sp
        br.ret.sptk.many b0
        ;;
.Lld_float:
        .body
        .copy_state 1
        ldfs    f8 = [r16]
        .restore sp
        add     sp = FRAME_SIZE, sp
        br.ret.sptk.many b0
        ;;
.Lld_double:
        .body
        .copy_state 1
        ldfd    f8 = [r16]
        .restore sp
        add     sp = FRAME_SIZE, sp
        br.ret.sptk.many b0
        ;;
.Lld_ldouble:
        .body
        .copy_state 1
        ldfe    f8 = [r16]
        .restore sp
        add     sp = FRAME_SIZE, sp
        br.ret.sptk.many b0
        ;;

.Lld_small_struct:
        .body
        .copy_state 1
        add     r17 = 8, r16
        cmp.lt  p6, p0 = 8, r8
        cmp.lt  p7, p0 = 16, r8
        cmp.lt  p8, p0 = 24, r8
        ;;
        ld8     r8 = [r16], 16
(p6)    ld8     r9 = [r17], 16
        ;;
(p7)    ld8     r10 = [r16]
(p8)    ld8     r11 = [r17]
        .restore sp
        add     sp = FRAME_SIZE, sp
        br.ret.sptk.many b0
        ;;

.Lld_hfa_float:
        .body
        .copy_state 1
        add     r17 = 4, r16
        cmp.lt  p6, p0 = 4, r8
        ;;
        ldfs    f8 = [r16], 8
(p6)    ldfs    f9 = [r17], 8
        cmp.lt  p7, p0 = 8, r8
        cmp.lt  p8, p0 = 12, r8
        ;;
(p7)    ldfs    f10 = [r16], 8
(p8)    ldfs    f11 = [r17], 8
        cmp.lt  p9, p0 = 16, r8
        cmp.lt  p10, p0 = 20, r8
        ;;
(p9)    ldfs    f12 = [r16], 8
(p10)   ldfs    f13 = [r17], 8
        cmp.lt  p6, p0 = 24, r8
        cmp.lt  p7, p0 = 28, r8
        ;;
(p6)    ldfs    f14 = [r16]
(p7)    ldfs    f15 = [r17]
        .restore sp
        add     sp = FRAME_SIZE, sp
        br.ret.sptk.many b0
        ;;

.Lld_hfa_double:
        .body
        .copy_state 1
        add     r17 = 8, r16
        cmp.lt  p6, p0 = 8, r8
        ;;
        ldfd    f8 = [r16], 16
(p6)    ldfd    f9 = [r17], 16
        cmp.lt  p7, p0 = 16, r8
        cmp.lt  p8, p0 = 24, r8
        ;;
(p7)    ldfd    f10 = [r16], 16
(p8)    ldfd    f11 = [r17], 16
        cmp.lt  p9, p0 = 32, r8
        cmp.lt  p10, p0 = 40, r8
        ;;
(p9)    ldfd    f12 = [r16], 16
(p10)   ldfd    f13 = [r17], 16
        cmp.lt  p6, p0 = 48, r8
        cmp.lt  p7, p0 = 56, r8
        ;;
(p6)    ldfd    f14 = [r16]
(p7)    ldfd    f15 = [r17]
        .restore sp
        add     sp = FRAME_SIZE, sp
        br.ret.sptk.many b0
        ;;

.Lld_hfa_ldouble:
        .body
        .copy_state 1
        add     r17 = 16, r16
        cmp.lt  p6, p0 = 16, r8
        ;;
        ldfe    f8 = [r16], 32
(p6)    ldfe    f9 = [r17], 32
        cmp.lt  p7, p0 = 32, r8
        cmp.lt  p8, p0 = 48, r8
        ;;
(p7)    ldfe    f10 = [r16], 32
(p8)    ldfe    f11 = [r17], 32
        cmp.lt  p9, p0 = 64, r8
        cmp.lt  p10, p0 = 80, r8
        ;;
(p9)    ldfe    f12 = [r16], 32
(p10)   ldfe    f13 = [r17], 32
        cmp.lt  p6, p0 = 96, r8
        cmp.lt  p7, p0 = 112, r8
        ;;
(p6)    ldfe    f14 = [r16]
(p7)    ldfe    f15 = [r17]
        .restore sp
        add     sp = FRAME_SIZE, sp
        br.ret.sptk.many b0
        ;;

        .endp   ffi_closure_unix

        .section .rodata
        .align  8
.Lst_table:
        data8   @pcrel(.Lst_void)               // FFI_TYPE_VOID
        data8   @pcrel(.Lst_sint32)             // FFI_TYPE_INT
        data8   @pcrel(.Lst_float)              // FFI_TYPE_FLOAT
        data8   @pcrel(.Lst_double)             // FFI_TYPE_DOUBLE
        data8   @pcrel(.Lst_ldouble)            // FFI_TYPE_LONGDOUBLE
        data8   @pcrel(.Lst_uint8)              // FFI_TYPE_UINT8
        data8   @pcrel(.Lst_sint8)              // FFI_TYPE_SINT8
        data8   @pcrel(.Lst_uint16)             // FFI_TYPE_UINT16
        data8   @pcrel(.Lst_sint16)             // FFI_TYPE_SINT16
        data8   @pcrel(.Lst_uint32)             // FFI_TYPE_UINT32
        data8   @pcrel(.Lst_sint32)             // FFI_TYPE_SINT32
        data8   @pcrel(.Lst_int64)              // FFI_TYPE_UINT64
        data8   @pcrel(.Lst_int64)              // FFI_TYPE_SINT64
        data8   @pcrel(.Lst_void)               // FFI_TYPE_STRUCT
        data8   @pcrel(.Lst_int64)              // FFI_TYPE_POINTER
        data8   @pcrel(.Lst_small_struct)       // FFI_IA64_TYPE_SMALL_STRUCT
        data8   @pcrel(.Lst_hfa_float)          // FFI_IA64_TYPE_HFA_FLOAT
        data8   @pcrel(.Lst_hfa_double)         // FFI_IA64_TYPE_HFA_DOUBLE
        data8   @pcrel(.Lst_hfa_ldouble)        // FFI_IA64_TYPE_HFA_LDOUBLE

.Lld_table:
        data8   @pcrel(.Lld_void)               // FFI_TYPE_VOID
        data8   @pcrel(.Lld_int)                // FFI_TYPE_INT
        data8   @pcrel(.Lld_float)              // FFI_TYPE_FLOAT
        data8   @pcrel(.Lld_double)             // FFI_TYPE_DOUBLE
        data8   @pcrel(.Lld_ldouble)            // FFI_TYPE_LONGDOUBLE
        data8   @pcrel(.Lld_int)                // FFI_TYPE_UINT8
        data8   @pcrel(.Lld_int)                // FFI_TYPE_SINT8
        data8   @pcrel(.Lld_int)                // FFI_TYPE_UINT16
        data8   @pcrel(.Lld_int)                // FFI_TYPE_SINT16
        data8   @pcrel(.Lld_int)                // FFI_TYPE_UINT32
        data8   @pcrel(.Lld_int)                // FFI_TYPE_SINT32
        data8   @pcrel(.Lld_int)                // FFI_TYPE_UINT64
        data8   @pcrel(.Lld_int)                // FFI_TYPE_SINT64
        data8   @pcrel(.Lld_void)               // FFI_TYPE_STRUCT
        data8   @pcrel(.Lld_int)                // FFI_TYPE_POINTER
        data8   @pcrel(.Lld_small_struct)       // FFI_IA64_TYPE_SMALL_STRUCT
        data8   @pcrel(.Lld_hfa_float)          // FFI_IA64_TYPE_HFA_FLOAT
        data8   @pcrel(.Lld_hfa_double)         // FFI_IA64_TYPE_HFA_DOUBLE
        data8   @pcrel(.Lld_hfa_ldouble)        // FFI_IA64_TYPE_HFA_LDOUBLE

#if defined __ELF__ && defined __linux__
        .section        .note.GNU-stack,"",@progbits
#endif