One Level Up Top Level

runtime/ffi/call_x86_64.S - ktap

  1. /*
  2. * call_x86_64.S - assembly code to call C function and handle return value
  3. *
  4. * This file is part of ktap by Jovi Zhangwei
  5. *
  6. * Copyright (C) 2012-2013 Jovi Zhangwei <jovi.zhangwei@gmail.com>.
  7. *
  8. * ktap is free software; you can redistribute it and/or modify it
  9. * under the terms and conditions of the GNU General Public License,
  10. * version 2, as published by the Free Software Foundation.
  11. *
  12. * ktap is distributed in the hope it will be useful, but WITHOUT
  13. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15. * more details.
  16. *
  17. * You should have received a copy of the GNU General Public License along with
  18. * this program; if not, write to the Free Software Foundation, Inc.,
  19. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  20. */


  23. #ifdef __x86_64

  25.     .file "call_x86_64.S"
  26.     .text

  28. /*    ffi_call_assem_x86_64(void *stack, void *temp_stack,
  29. *        void *rvalue, void *func_addr, ffi_type rftype)
  30. *    @stack: base address of register values and new stack
  31. *    @temp_stack: stack to store temporary values
  32. *    @func_addr: Function address
  33. *    @rvalue: where to put return value
  34. *    @rftype: FFI type of return value
  35. */
  36.     .align 2
  37.     .globl    ffi_call_assem_x86_64
  38.     .type    ffi_call_assem_x86_64,@function

  40. ffi_call_assem_x86_64:
  41.     movq    (%rsp), %rax    /* save return address */
  42.     /* move stuffs to temp memory region(void *temp_stack) */
  43.     movq    %rcx, (%rsi)    /* save pointer to return value */
  44.     movq    %r8, 8(%rsi)    /* save return_ffi_type */
  45.     movq    %rbp, 16(%rsi)    /* save %rbp */
  46.     movq    %rax, 24(%rsi)    /* save return address */
  47.     movq    %rsp, 32(%rsi)    /* save %rsp */
  48.     movq    %rsi, %rbp    /* point %rbp to temp memory region */

  50.     movq    %rdx, %r11    /* move function address to %r11 */

  52.     movq    %rdi, %r10    /* set %r10 point to register region */
  53.     movq    (%r10), %rdi    /* load registers */
  54.     movq    8(%r10), %rsi
  55.     movq    16(%r10), %rdx
  56.     movq    24(%r10), %rcx
  57.     movq    32(%r10), %r8
  58.     movq    40(%r10), %r9
  59.     xorq    %rax, %rax

  61.     leaq    48(%r10), %rsp

  63.     callq    *%r11

  65.     movq    32(%rbp), %rsp    /* restore %rsp */
  66.     movq    24(%rbp), %rcx    /* restore return address */
  67.     movq    %rcx, (%rsp)

  69.     movq    (%rbp), %rcx    /* get pointer to return value */
  70.     movq    8(%rbp), %r8    /* get return_ffi_type */
  71.     movq    16(%rbp), %rbp    /* restore rbp */

  73.     leaq    .Lreturn_table(%rip), %r11    /* start address of return_table */
  74.     movslq    (%r11, %r8, 8), %r11    /* fetch target address from table */
  75.     jmpq    *%r11            /* jump according to value in table */

  77.     .align 8
  78. .Lreturn_table:
  79.     .quad    .Lreturn_void        /* FFI_VOID */
  80.     .quad    .Lreturn_uint8        /* FFI_UINT8 */
  81.     .quad    .Lreturn_int8        /* FFI_INT8 */
  82.     .quad    .Lreturn_uint16        /* FFI_UINT16 */
  83.     .quad    .Lreturn_int16        /* FFI_INT16 */
  84.     .quad    .Lreturn_uint32        /* FFI_UINT32 */
  85.     .quad    .Lreturn_int32        /* FFI_INT32 */
  86.     .quad    .Lreturn_uint64        /* FFI_UINT64 */
  87.     .quad    .Lreturn_int64        /* FFI_INT64 */
  88.     .quad    .Lreturn_ptr        /* FFI_PTR */
  89.     .quad    .Lreturn_func        /* FFI_FUNC */
  90.     .quad    .Lreturn_struct        /* FFI_STRUCT */
  91.     .quad    .Lreturn_unknown    /* FFI_UNKNOWN */

  93.     .align 8
  94. .Lreturn_void:
  95. .Lreturn_func:
  96. .Lreturn_unknown:
  97.     retq
  98.     .align 8
  99. .Lreturn_uint8:
  100.     movzbq    %al, %rax
  101.     movq    %rax, (%rcx)
  102.     retq
  103.     .align 8
  104. .Lreturn_int8:
  105.     movsbq    %al, %rax
  106.     movq    %rax, (%rcx)
  107.     retq
  108.     .align 8
  109. .Lreturn_uint16:
  110.     movzwq    %ax, %rax
  111.     movq    %rax, (%rcx)
  112.     retq
  113.     .align 8
  114. .Lreturn_int16:
  115.     movswq    %ax, %rax
  116.     movq    %rax, (%rcx)
  117.     retq
  118.     .align 8
  119. .Lreturn_uint32:
  120.     movl    %eax, %eax
  121.     movq    %rax, (%rcx)
  122.     retq
  123.     .align 8
  124. .Lreturn_int32:
  125.     movslq    %eax, %rax
  126.     movq    %rax, (%rcx)
  127.     retq
  128.     .align 8
  129. .Lreturn_uint64:
  130. .Lreturn_int64:
  131. .Lreturn_ptr:
  132.     movq    %rax, (%rcx)
  133.     retq
  134. /* Struct type indicates that struct is put into at most two registers,
  135. * and 16 bytes space is always available
  136. */
  137.     .align 8
  138. .Lreturn_struct:
  139.     movq    %rax, (%rcx)
  140.     movq    %rdx, 8(%rcx)
  141.     retq

  143. #endif /* end for __x86_64 */

One Level Up Top Level