Edit

kc3-lang/libffi/src/xtensa/sysv.S

Branch :

  • Show log

    Commit

  • Author : Anthony Green
    Date : 2013-01-21 07:07:38
    Hash : 20cae32b
    Message : Xtensa support

  • src/xtensa/sysv.S
  • /* -----------------------------------------------------------------------
       sysv.S - Copyright (c) 2013 Tensilica, Inc.
       
       XTENSA 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 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>
    
    #define ENTRY(name) .text; .globl name; .type  name,@function; .align 4; name:
    #define END(name) .size name , . - name
    
    /* Assert that the table below is in sync with ffi.h.  */
    
    #if	   FFI_TYPE_UINT8 != 5          \
            || FFI_TYPE_SINT8 != 6          \
            || FFI_TYPE_UINT16 != 7         \
            || FFI_TYPE_SINT16 != 8         \
            || FFI_TYPE_UINT32 != 9         \
            || FFI_TYPE_SINT32 != 10        \
            || FFI_TYPE_UINT64 != 11
    #error "xtensa/sysv.S out of sync with ffi.h"
    #endif
    
    
    /* ffi_call_SYSV (rvalue, rbytes, flags, (*fnaddr)(), bytes, ecif)
          void *rvalue;            a2
          unsigned long rbytes;    a3
          unsigned flags;          a4
          void (*fnaddr)();        a5
          unsigned long bytes;     a6
          extended_cif* ecif)      a7
    */
    
    ENTRY(ffi_call_SYSV)
    
    	entry	a1, 32              # 32 byte frame for using call8 below
    
    	mov	a10, a7             # a10(->arg0): ecif
    	sub	a11, a1, a6         # a11(->arg1): stack pointer
    	mov	a7, a1              # fp
    	movsp	a1, a11             # set new sp = old_sp - bytes
    
    	movi	a8, ffi_prep_args
    	callx8	a8                  # ffi_prep_args(ecif, stack)
    
    	# prepare to move stack pointer back up to 6 arguments
    	# note that 'bytes' is already aligned
    
    	movi	a10, 6*4 
    	sub	a11, a6, a10
    	movgez	a6, a10, a11
    	add	a6, a1, a6
    
    	
    	# we can pass up to 6 arguments in registers
    	# for simplicity, just load 6 arguments
    	# (the stack size is at least 32 bytes, so no risk to cross boundaries)
    
    	l32i	a10, a1, 0
    	l32i	a11, a1, 4
    	l32i	a12, a1, 8
    	l32i	a13, a1, 12
    	l32i	a14, a1, 16
    	l32i	a15, a1, 20
    
    	# move stack pointer
    
    	movsp	a1, a6
    
    	callx8	a5                  # (*fn)(args...)
    
    	# Handle return value(s)
    
    	beqz	a2, .Lexit
    
    	movi	a5, FFI_TYPE_STRUCT
    	bne	a4, a5, .Lstore
    	movi	a5, 16
    	blt	a5, a3, .Lexit
    
    	s32i	a10, a2, 0
    	blti	a3, 5, .Lexit
    	addi	a3, a3, -1
    	s32i	a11, a2, 4
    	blti	a3, 8, .Lexit
    	s32i	a12, a2, 8
    	blti	a3, 12, .Lexit
    	s32i	a13, a2, 12
    
    .Lexit:	retw
    
    .Lstore:
    	addi	a4, a4, -FFI_TYPE_UINT8
    	bgei	a4, 7, .Lexit	# should never happen
    	movi	a6, store_calls
    	add	a4, a4, a4
    	addx4	a6, a4, a6	# store_table + idx * 8
    	jx	a6
    
    	.align	8
    store_calls:
    	# UINT8
    	s8i	a10, a2, 0
    	retw
    
    	# SINT8
    	.align	8
    	s8i	a10, a2, 0
    	retw
    
    	# UINT16
    	.align	8
    	s16i	a10, a2, 0
    	retw
    
    	# SINT16
    	.align	8
    	s16i	a10, a2, 0
    	retw
    
    	# UINT32
    	.align	8
    	s32i	a10, a2, 0
    	retw
    
    	# SINT32
    	.align	8
    	s32i	a10, a2, 0
    	retw
    
    	# UINT64
    	.align	8
    	s32i	a10, a2, 0
    	s32i	a11, a2, 4
    	retw
    
    END(ffi_call_SYSV)
    
    
    /*
     * void ffi_cacheflush (unsigned long start, unsigned long end)
     */
    
    #define EXTRA_ARGS_SIZE	24
    
    ENTRY(ffi_cacheflush)
    
    	entry	a1, 16
    
    1:	dhwbi	a2, 0
    	ihi	a2, 0
    	addi	a2, a2, 4
    	blt	a2, a3, 1b
    
    	retw
    
    END(ffi_cacheflush)
    
    /* ffi_trampoline is copied to the stack */
    
    ENTRY(ffi_trampoline)
    
    	entry	a1, 16 + (FFI_REGISTER_NARGS * 4) + (4 * 4)   # [ 0]
    	j	2f                                # [ 3]
    	.align	4                                 # [ 6]
    1:	.long	0                                 # [ 8]
    2:	l32r	a15, 1b                           # [12]
    	_mov 	a14, a0                           # [15]
    	callx0	a15                               # [18]
                                                      # [21]
    END(ffi_trampoline)
    
    /*
     * ffi_closure()
     *
     * a0:  closure + 21
     * a14: return address (a0)
     */
    
    ENTRY(ffi_closure_SYSV)
    
    	/* intentionally omitting entry here */
    
    	# restore return address (a0) and move pointer to closure to a10
    	addi	a10, a0, -21
    	mov	a0, a14
    
    	# allow up to 4 arguments as return values
    	addi	a11, a1, 4 * 4
    
    	# save up to 6 arguments to stack (allocated by entry below)
    	s32i	a2, a11,  0
    	s32i	a3, a11,  4
    	s32i	a4, a11,  8
    	s32i	a5, a11, 12
    	s32i	a6, a11, 16
    	s32i	a7, a11, 20
    
    	movi	a8, ffi_closure_SYSV_inner
    	mov	a12, a1
    	callx8	a8			# .._inner(*closure, **avalue, *rvalue)
    
    	# load up to four return arguments
    	l32i	a2, a1,  0
    	l32i	a3, a1,  4
    	l32i	a4, a1,  8
    	l32i	a5, a1, 12
    
    	# (sign-)extend return value
    	movi	a11, FFI_TYPE_UINT8
    	bne	a10, a11, 1f
    	extui	a2, a2, 0, 8
    	retw
    
    1:	movi	a11, FFI_TYPE_SINT8
    	bne	a10, a11, 1f
    	sext	a2, a2, 7
    	retw
    
    1:	movi	a11, FFI_TYPE_UINT16
    	bne	a10, a11, 1f
    	extui	a2, a2, 0, 16
    	retw
    
    1:	movi	a11, FFI_TYPE_SINT16
    	bne	a10, a11, 1f
    	sext	a2, a2, 15
    
    1:	retw
    
    END(ffi_closure_SYSV)