text: /* -----------------------------------------------------------------------
     tile.S - Copyright (c) 2011 Tilera Corp.
  
     Tilera TILEPro and TILE-Gx 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>
  
  /* Number of bytes in a register. */
  #define REG_SIZE FFI_SIZEOF_ARG
  
  /* Number of bytes in stack linkage area for backtracing.
  
     A note about the ABI: on entry to a procedure, sp points to a stack
     slot where it must spill the return address if it's not a leaf.
     REG_SIZE bytes beyond that is a slot owned by the caller which
     contains the sp value that the caller had when it was originally
     entered (i.e. the caller's frame pointer). */
  #define LINKAGE_SIZE (2 * REG_SIZE)
  
  /* The first 10 registers are used to pass arguments and return values. */
  #define NUM_ARG_REGS 10
  
  #ifdef __tilegx__
  #define SW st
  #define LW ld
  #define BGZT bgtzt
  #else
  #define SW sw
  #define LW lw
  #define BGZT bgzt
  #endif
  
  
  /* void ffi_call_tile (int_reg_t reg_args[NUM_ARG_REGS],
                         const int_reg_t *stack_args,
                         unsigned long stack_args_bytes,
                         void (*fnaddr)(void));
  
          On entry, REG_ARGS contain the outgoing register values,
          and STACK_ARGS contains STACK_ARG_BYTES of additional values
          to be passed on the stack. If STACK_ARG_BYTES is zero, then
          STACK_ARGS is ignored.
  
          When the invoked function returns, the values of r0-r9 are
          blindly stored back into REG_ARGS for the caller to examine. */
  
          .section .text.ffi_call_tile, "ax", @progbits
          .align  8
          .globl  ffi_call_tile
          FFI_HIDDEN(ffi_call_tile)
  ffi_call_tile:
  
  /* Incoming arguments. */
  #define REG_ARGS                r0
  #define INCOMING_STACK_ARGS     r1
  #define STACK_ARG_BYTES         r2
  #define ORIG_FNADDR             r3
  
  /* Temporary values. */
  #define FRAME_SIZE              r10
  #define TMP                     r11
  #define TMP2                    r12
  #define OUTGOING_STACK_ARGS     r13
  #define REG_ADDR_PTR            r14
  #define RETURN_REG_ADDR         r15
  #define FNADDR                  r16
  
          .cfi_startproc
          {
           /* Save return address. */
           SW     sp, lr
           .cfi_offset lr, 0
           /* Prepare to spill incoming r52. */
           addi   TMP, sp, -REG_SIZE
           /* Increase frame size to have room to spill r52 and REG_ARGS.
              The +7 is to round up mod 8. */
           addi   FRAME_SIZE, STACK_ARG_BYTES, \
                  REG_SIZE + REG_SIZE + LINKAGE_SIZE + 7
          }
          {
           /* Round stack frame size to a multiple of 8 to satisfy ABI. */
           andi   FRAME_SIZE, FRAME_SIZE, -8
           /* Compute where to spill REG_ARGS value. */
           addi   TMP2, sp, -(REG_SIZE * 2)
          }
          {
           /* Spill incoming r52. */
           SW     TMP, r52
           .cfi_offset r52, -REG_SIZE
           /* Set up our frame pointer. */
           move   r52, sp
           .cfi_def_cfa_register r52
           /* Push stack frame. */
           sub    sp, sp, FRAME_SIZE
          }
          {
           /* Prepare to set up stack linkage. */
           addi   TMP, sp, REG_SIZE
           /* Prepare to memcpy stack args. */
           addi   OUTGOING_STACK_ARGS, sp, LINKAGE_SIZE
           /* Save REG_ARGS which we will need after we call the subroutine. */
           SW     TMP2, REG_ARGS
          }
          {
           /* Set up linkage info to hold incoming stack pointer. */
           SW     TMP, r52
          }
          {
           /* Skip stack args memcpy if we don't have any stack args (common). */
           blezt  STACK_ARG_BYTES, .Ldone_stack_args_memcpy
          }
  
  .Lmemcpy_stack_args:
          {
           /* Load incoming argument from stack_args. */
           LW     TMP, INCOMING_STACK_ARGS
           addi   INCOMING_STACK_ARGS, INCOMING_STACK_ARGS, REG_SIZE
          }
          {
           /* Store stack argument into outgoing stack argument area. */
           SW     OUTGOING_STACK_ARGS, TMP
           addi   OUTGOING_STACK_ARGS, OUTGOING_STACK_ARGS, REG_SIZE
           addi   STACK_ARG_BYTES, STACK_ARG_BYTES, -REG_SIZE
          }
          {
           BGZT   STACK_ARG_BYTES, .Lmemcpy_stack_args
          }
  .Ldone_stack_args_memcpy:
  
          {
           /* Copy aside ORIG_FNADDR so we can overwrite its register. */
           move   FNADDR, ORIG_FNADDR
           /* Prepare to load argument registers. */
           addi   REG_ADDR_PTR, r0, REG_SIZE
           /* Load outgoing r0. */
           LW     r0, r0
          }
  
          /* Load up argument registers from the REG_ARGS array. */
  #define LOAD_REG(REG, PTR) \
          { \
           LW     REG, PTR ; \
           addi   PTR, PTR, REG_SIZE \
          }
  
          LOAD_REG(r1, REG_ADDR_PTR)
          LOAD_REG(r2, REG_ADDR_PTR)
          LOAD_REG(r3, REG_ADDR_PTR)
          LOAD_REG(r4, REG_ADDR_PTR)
          LOAD_REG(r5, REG_ADDR_PTR)
          LOAD_REG(r6, REG_ADDR_PTR)
          LOAD_REG(r7, REG_ADDR_PTR)
          LOAD_REG(r8, REG_ADDR_PTR)
          LOAD_REG(r9, REG_ADDR_PTR)
  
          {
           /* Call the subroutine. */
           jalr   FNADDR
          }
  
          {
           /* Restore original lr. */
           LW     lr, r52
           /* Prepare to recover ARGS, which we spilled earlier. */
           addi   TMP, r52, -(2 * REG_SIZE)
          }
          {
           /* Restore ARGS, so we can fill it in with the return regs r0-r9. */
           LW     RETURN_REG_ADDR, TMP
           /* Prepare to restore original r52. */
           addi   TMP, r52, -REG_SIZE
          }
  
          {
           /* Pop stack frame. */
           move   sp, r52
           /* Restore original r52. */
           LW     r52, TMP
          }
  
  #define STORE_REG(REG, PTR) \
          { \
           SW     PTR, REG ; \
           addi   PTR, PTR, REG_SIZE \
          }
  
          /* Return all register values by reference. */
          STORE_REG(r0, RETURN_REG_ADDR)
          STORE_REG(r1, RETURN_REG_ADDR)
          STORE_REG(r2, RETURN_REG_ADDR)
          STORE_REG(r3, RETURN_REG_ADDR)
          STORE_REG(r4, RETURN_REG_ADDR)
          STORE_REG(r5, RETURN_REG_ADDR)
          STORE_REG(r6, RETURN_REG_ADDR)
          STORE_REG(r7, RETURN_REG_ADDR)
          STORE_REG(r8, RETURN_REG_ADDR)
          STORE_REG(r9, RETURN_REG_ADDR)
  
          {
           jrp    lr
          }
  
          .cfi_endproc
          .size ffi_call_tile, .-ffi_call_tile
  
  /* ffi_closure_tile(...)
  
     On entry, lr points to the closure plus 8 bytes, and r10
     contains the actual return address.
  
     This function simply dumps all register parameters into a stack array
     and passes the closure, the registers array, and the stack arguments
     to C code that does all of the actual closure processing. */
  
          .section .text.ffi_closure_tile, "ax", @progbits
          .align  8
          .globl  ffi_closure_tile
          FFI_HIDDEN(ffi_closure_tile)
  
          .cfi_startproc
  /* Room to spill all NUM_ARG_REGS incoming registers, plus frame linkage. */
  #define CLOSURE_FRAME_SIZE (((NUM_ARG_REGS * REG_SIZE * 2 + LINKAGE_SIZE) + 7) & -8)
  ffi_closure_tile:
          {
  #ifdef __tilegx__
           st     sp, lr
           .cfi_offset lr, 0
  #else
           /* Save return address (in r10 due to closure stub wrapper). */
           SW     sp, r10
           .cfi_return_column r10
           .cfi_offset r10, 0
  #endif
           /* Compute address for stack frame linkage. */
           addli   r10, sp, -(CLOSURE_FRAME_SIZE - REG_SIZE)
          }
          {
           /* Save incoming stack pointer in linkage area. */
           SW     r10, sp
           .cfi_offset sp, -(CLOSURE_FRAME_SIZE - REG_SIZE)
           /* Push a new stack frame. */
           addli   sp, sp, -CLOSURE_FRAME_SIZE
           .cfi_adjust_cfa_offset CLOSURE_FRAME_SIZE
          }
  
          {
           /* Create pointer to where to start spilling registers. */
           addi   r10, sp, LINKAGE_SIZE
          }
  
          /* Spill all the incoming registers. */
          STORE_REG(r0, r10)
          STORE_REG(r1, r10)
          STORE_REG(r2, r10)
          STORE_REG(r3, r10)
          STORE_REG(r4, r10)
          STORE_REG(r5, r10)
          STORE_REG(r6, r10)
          STORE_REG(r7, r10)
          STORE_REG(r8, r10)
          {
           /* Save r9. */
           SW     r10, r9
  #ifdef __tilegx__
           /* Pointer to closure is passed in r11. */
           move  r0, r11
  #else
           /* Compute pointer to the closure object. Because the closure
              starts with a "jal ffi_closure_tile", we can just take the
              value of lr (a phony return address pointing into the closure)
              and subtract 8. */
           addi   r0, lr, -8
  #endif
           /* Compute a pointer to the register arguments we just spilled. */
           addi   r1, sp, LINKAGE_SIZE
          }
          {
           /* Compute a pointer to the extra stack arguments (if any). */
           addli   r2, sp, CLOSURE_FRAME_SIZE + LINKAGE_SIZE
           /* Call C code to deal with all of the grotty details. */
           jal    ffi_closure_tile_inner
          }
          {
           addli   r10, sp, CLOSURE_FRAME_SIZE
          }
          {
           /* Restore the return address. */
           LW     lr, r10
           /* Compute pointer to registers array. */
           addli   r10, sp, LINKAGE_SIZE + (NUM_ARG_REGS * REG_SIZE)
          }
          /* Return all the register values, which C code may have set. */
          LOAD_REG(r0, r10)
          LOAD_REG(r1, r10)
          LOAD_REG(r2, r10)
          LOAD_REG(r3, r10)
          LOAD_REG(r4, r10)
          LOAD_REG(r5, r10)
          LOAD_REG(r6, r10)
          LOAD_REG(r7, r10)
          LOAD_REG(r8, r10)
          LOAD_REG(r9, r10)
          {
           /* Pop the frame. */
           addli   sp, sp, CLOSURE_FRAME_SIZE
           jrp    lr
          }
  
          .cfi_endproc
          .size   ffi_closure_tile, . - ffi_closure_tile
  
  
  /* What follows are code template instructions that get copied to the
     closure trampoline by ffi_prep_closure_loc.  The zeroed operands
     get replaced by their proper values at runtime. */
  
          .section .text.ffi_template_tramp_tile, "ax", @progbits
          .align  8
          .globl  ffi_template_tramp_tile
          FFI_HIDDEN(ffi_template_tramp_tile)
  ffi_template_tramp_tile:
  #ifdef __tilegx__
          {
            moveli r11, 0 /* backpatched to address of containing closure. */
            moveli r10, 0 /* backpatched to ffi_closure_tile. */
          }
          /* Note: the following bundle gets generated multiple times
             depending on the pointer value (esp. useful for -m32 mode). */
          { shl16insli r11, r11, 0 ; shl16insli r10, r10, 0 }
          { info 2+8 /* for backtracer: -> pc in lr, frame size 0 */ ; jr r10 }
  #else
          /* 'jal .' yields a PC-relative offset of zero so we can OR in the
             right offset at runtime. */
          { move r10, lr ; jal . /* ffi_closure_tile */ }
  #endif
  
          .size   ffi_template_tramp_tile, . - ffi_template_tramp_tile
  