One Level Up Top Level

src/lj_ccallback.c - luajit-2.0-src

Functions defined

Macros defined

Source code

  1. /*
  2. ** FFI C callback handling.
  3. ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
  4. */

  6. #include "lj_obj.h"

  8. #if LJ_HASFFI

  10. #include "lj_gc.h"
  11. #include "lj_err.h"
  12. #include "lj_tab.h"
  13. #include "lj_state.h"
  14. #include "lj_frame.h"
  15. #include "lj_ctype.h"
  16. #include "lj_cconv.h"
  17. #include "lj_ccall.h"
  18. #include "lj_ccallback.h"
  19. #include "lj_target.h"
  20. #include "lj_mcode.h"
  21. #include "lj_trace.h"
  22. #include "lj_vm.h"

  24. /* -- Target-specific handling of callback slots -------------------------- */

  26. ‌#define CALLBACK_MCODE_SIZE        (LJ_PAGESIZE * LJ_NUM_CBPAGE)

  28. #if LJ_OS_NOJIT

  30. /* Callbacks disabled. */
  31. ‌#define CALLBACK_SLOT2OFS(slot)        (0*(slot))
  32. ‌#define CALLBACK_OFS2SLOT(ofs)        (0*(ofs))
  33. ‌#define CALLBACK_MAX_SLOT        0

  35. #elif LJ_TARGET_X86ORX64

  37. ‌#define CALLBACK_MCODE_HEAD        (LJ_64 ? 8 : 0)
  38. ‌#define CALLBACK_MCODE_GROUP        (-2+1+2+5+(LJ_64 ? 6 : 5))

  40. ‌#define CALLBACK_SLOT2OFS(slot) \
  41.   (CALLBACK_MCODE_HEAD + CALLBACK_MCODE_GROUP*((slot)/32) + 4*(slot))

  43. ‌static MSize CALLBACK_OFS2SLOT(MSize ofs)
  44. {
  45.   MSize group;
  46.   ofs -= CALLBACK_MCODE_HEAD;
  47.   group = ofs / (32*4 + CALLBACK_MCODE_GROUP);
  48.   return (ofs % (32*4 + CALLBACK_MCODE_GROUP))/4 + group*32;
  49. }

  51. ‌#define CALLBACK_MAX_SLOT \
  52.   (((CALLBACK_MCODE_SIZE-CALLBACK_MCODE_HEAD)/(CALLBACK_MCODE_GROUP+4*32))*32)

  54. #elif LJ_TARGET_ARM

  56. ‌#define CALLBACK_MCODE_HEAD                32

  58. #elif LJ_TARGET_ARM64

  60. ‌#define CALLBACK_MCODE_HEAD                32

  62. #elif LJ_TARGET_PPC

  64. ‌#define CALLBACK_MCODE_HEAD                24

  66. #elif LJ_TARGET_MIPS

  68. ‌#define CALLBACK_MCODE_HEAD                24

  70. #else

  72. /* Missing support for this architecture. */
  73. ‌#define CALLBACK_SLOT2OFS(slot)        (0*(slot))
  74. ‌#define CALLBACK_OFS2SLOT(ofs)        (0*(ofs))
  75. ‌#define CALLBACK_MAX_SLOT        0

  77. #endif

  79. #ifndef CALLBACK_SLOT2OFS
  80. ‌#define CALLBACK_SLOT2OFS(slot)                (CALLBACK_MCODE_HEAD + 8*(slot))
  81. ‌#define CALLBACK_OFS2SLOT(ofs)                (((ofs)-CALLBACK_MCODE_HEAD)/8)
  82. ‌#define CALLBACK_MAX_SLOT                (CALLBACK_OFS2SLOT(CALLBACK_MCODE_SIZE))
  83. #endif

  85. /* Convert callback slot number to callback function pointer. */
  86. ‌static void *callback_slot2ptr(CTState *cts, MSize slot)
  87. {
  88.   return (uint8_t *)cts->cb.mcode + CALLBACK_SLOT2OFS(slot);
  89. }

  91. /* Convert callback function pointer to slot number. */
  92. ‌MSize lj_ccallback_ptr2slot(CTState *cts, void *p)
  93. {
  94.   uintptr_t ofs = (uintptr_t)((uint8_t *)p -(uint8_t *)cts->cb.mcode);
  95.   if (ofs < CALLBACK_MCODE_SIZE) {
  96.     MSize slot = CALLBACK_OFS2SLOT((MSize)ofs);
  97.     if (CALLBACK_SLOT2OFS(slot) == (MSize)ofs)
  98.       return slot;
  99.   }
  100.   return ~0u;  /* Not a known callback function pointer. */
  101. }

  103. /* Initialize machine code for callback function pointers. */
  104. #if LJ_OS_NOJIT
  105. /* Disabled callback support. */
  106. ‌#define callback_mcode_init(g, p)        UNUSED(p)
  107. #elif LJ_TARGET_X86ORX64
  108. ‌static void callback_mcode_init(global_State *g, uint8_t *page)
  109. {
  110.   uint8_t *p = page;
  111.   uint8_t *target = (uint8_t *)(void *)lj_vm_ffi_callback;
  112.   MSize slot;
  113. #if LJ_64
  114.   *(void **)p = target; p += 8;
  115. #endif
  116.   for (slot = 0; slot < CALLBACK_MAX_SLOT; slot++) {
  117.     /* mov al, slot; jmp group */
  118.     *p++ = XI_MOVrib | RID_EAX; *p++ = (uint8_t)slot;
  119.     if ((slot & 31) == 31 || slot == CALLBACK_MAX_SLOT-1) {
  120.       /* push ebp/rbp; mov ah, slot>>8; mov ebp, &g. */
  121.       *p++ = XI_PUSH + RID_EBP;
  122.       *p++ = XI_MOVrib | (RID_EAX+4); *p++ = (uint8_t)(slot >> 8);
  123.       *p++ = XI_MOVri | RID_EBP;
  124.       *(int32_t *)p = i32ptr(g); p += 4;
  125. #if LJ_64
  126.       /* jmp [rip-pageofs] where lj_vm_ffi_callback is stored. */
  127.       *p++ = XI_GROUP5; *p++ = XM_OFS0 + (XOg_JMP<<3) + RID_EBP;
  128.       *(int32_t *)p = (int32_t)(page-(p+4)); p += 4;
  129. #else
  130.       /* jmp lj_vm_ffi_callback. */
  131.       *p++ = XI_JMP; *(int32_t *)p = target-(p+4); p += 4;
  132. #endif
  133.     } else {
  134.       *p++ = XI_JMPs; *p++ = (uint8_t)((2+2)*(31-(slot&31)) - 2);
  135.     }
  136.   }
  137.   lua_assert(p - page <= CALLBACK_MCODE_SIZE);
  138. }
  139. #elif LJ_TARGET_ARM
  140. ‌static void callback_mcode_init(global_State *g, uint32_t *page)
  141. {
  142.   uint32_t *p = page;
  143.   void *target = (void *)lj_vm_ffi_callback;
  144.   MSize slot;
  145.   /* This must match with the saveregs macro in buildvm_arm.dasc. */
  146.   *p++ = ARMI_SUB|ARMF_D(RID_R12)|ARMF_N(RID_R12)|ARMF_M(RID_PC);
  147.   *p++ = ARMI_PUSH|ARMF_N(RID_SP)|RSET_RANGE(RID_R4,RID_R11+1)|RID2RSET(RID_LR);
  148.   *p++ = ARMI_SUB|ARMI_K12|ARMF_D(RID_R12)|ARMF_N(RID_R12)|CALLBACK_MCODE_HEAD;
  149.   *p++ = ARMI_STR|ARMI_LS_P|ARMI_LS_W|ARMF_D(RID_R12)|ARMF_N(RID_SP)|(CFRAME_SIZE-4*9);
  150.   *p++ = ARMI_LDR|ARMI_LS_P|ARMI_LS_U|ARMF_D(RID_R12)|ARMF_N(RID_PC);
  151.   *p++ = ARMI_LDR|ARMI_LS_P|ARMI_LS_U|ARMF_D(RID_PC)|ARMF_N(RID_PC);
  152.   *p++ = u32ptr(g);
  153.   *p++ = u32ptr(target);
  154.   for (slot = 0; slot < CALLBACK_MAX_SLOT; slot++) {
  155.     *p++ = ARMI_MOV|ARMF_D(RID_R12)|ARMF_M(RID_PC);
  156.     *p = ARMI_B | ((page-p-2) & 0x00ffffffu);
  157.     p++;
  158.   }
  159.   lua_assert(p - page <= CALLBACK_MCODE_SIZE);
  160. }
  161. #elif LJ_TARGET_ARM64
  162. ‌static void callback_mcode_init(global_State *g, uint32_t *page)
  163. {
  164.   uint32_t *p = page;
  165.   void *target = (void *)lj_vm_ffi_callback;
  166.   MSize slot;
  167.   *p++ = A64I_LDRLx | A64F_D(RID_X11) | A64F_S19(4);
  168.   *p++ = A64I_LDRLx | A64F_D(RID_X10) | A64F_S19(5);
  169.   *p++ = A64I_BR | A64F_N(RID_X11);
  170.   *p++ = A64I_NOP;
  171.   ((void **)p)[0] = target;
  172.   ((void **)p)[1] = g;
  173.   p += 4;
  174.   for (slot = 0; slot < CALLBACK_MAX_SLOT; slot++) {
  175.     *p++ = A64I_MOVZw | A64F_D(RID_X9) | A64F_U16(slot);
  176.     *p = A64I_B | A64F_S26((page-p) & 0x03ffffffu);
  177.     p++;
  178.   }
  179.   lua_assert(p - page <= CALLBACK_MCODE_SIZE);
  180. }
  181. #elif LJ_TARGET_PPC
  182. ‌static void callback_mcode_init(global_State *g, uint32_t *page)
  183. {
  184.   uint32_t *p = page;
  185.   void *target = (void *)lj_vm_ffi_callback;
  186.   MSize slot;
  187.   *p++ = PPCI_LIS | PPCF_T(RID_TMP) | (u32ptr(target) >> 16);
  188.   *p++ = PPCI_LIS | PPCF_T(RID_R12) | (u32ptr(g) >> 16);
  189.   *p++ = PPCI_ORI | PPCF_A(RID_TMP)|PPCF_T(RID_TMP) | (u32ptr(target) & 0xffff);
  190.   *p++ = PPCI_ORI | PPCF_A(RID_R12)|PPCF_T(RID_R12) | (u32ptr(g) & 0xffff);
  191.   *p++ = PPCI_MTCTR | PPCF_T(RID_TMP);
  192.   *p++ = PPCI_BCTR;
  193.   for (slot = 0; slot < CALLBACK_MAX_SLOT; slot++) {
  194.     *p++ = PPCI_LI | PPCF_T(RID_R11) | slot;
  195.     *p = PPCI_B | (((page-p) & 0x00ffffffu) << 2);
  196.     p++;
  197.   }
  198.   lua_assert(p - page <= CALLBACK_MCODE_SIZE);
  199. }
  200. #elif LJ_TARGET_MIPS
  201. ‌static void callback_mcode_init(global_State *g, uint32_t *page)
  202. {
  203.   uint32_t *p = page;
  204.   void *target = (void *)lj_vm_ffi_callback;
  205.   MSize slot;
  206.   *p++ = MIPSI_SW | MIPSF_T(RID_R1)|MIPSF_S(RID_SP) | 0;
  207.   *p++ = MIPSI_LUI | MIPSF_T(RID_R3) | (u32ptr(target) >> 16);
  208.   *p++ = MIPSI_LUI | MIPSF_T(RID_R2) | (u32ptr(g) >> 16);
  209.   *p++ = MIPSI_ORI | MIPSF_T(RID_R3)|MIPSF_S(RID_R3) |(u32ptr(target)&0xffff);
  210.   *p++ = MIPSI_JR | MIPSF_S(RID_R3);
  211.   *p++ = MIPSI_ORI | MIPSF_T(RID_R2)|MIPSF_S(RID_R2) | (u32ptr(g)&0xffff);
  212.   for (slot = 0; slot < CALLBACK_MAX_SLOT; slot++) {
  213.     *p = MIPSI_B | ((page-p-1) & 0x0000ffffu);
  214.     p++;
  215.     *p++ = MIPSI_LI | MIPSF_T(RID_R1) | slot;
  216.   }
  217.   lua_assert(p - page <= CALLBACK_MCODE_SIZE);
  218. }
  219. #else
  220. /* Missing support for this architecture. */
  221. ‌#define callback_mcode_init(g, p)        UNUSED(p)
  222. #endif

  224. /* -- Machine code management --------------------------------------------- */

  226. #if LJ_TARGET_WINDOWS

  228. ‌#define WIN32_LEAN_AND_MEAN
  229. #include <windows.h>

  231. #elif LJ_TARGET_POSIX

  233. #include <sys/mman.h>
  234. #ifndef MAP_ANONYMOUS
  235. ‌#define MAP_ANONYMOUS   MAP_ANON
  236. #endif

  238. #endif

  240. /* Allocate and initialize area for callback function pointers. */
  241. ‌static void callback_mcode_new(CTState *cts)
  242. {
  243.   size_t sz = (size_t)CALLBACK_MCODE_SIZE;
  244.   void *p;
  245.   if (CALLBACK_MAX_SLOT == 0)
  246.     lj_err_caller(cts->L, LJ_ERR_FFI_CBACKOV);
  247. #if LJ_TARGET_WINDOWS
  248.   p = VirtualAlloc(NULL, sz, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
  249.   if (!p)
  250.     lj_err_caller(cts->L, LJ_ERR_FFI_CBACKOV);
  251. #elif LJ_TARGET_POSIX
  252.   p = mmap(NULL, sz, (PROT_READ|PROT_WRITE), MAP_PRIVATE|MAP_ANONYMOUS,
  253.            -1, 0);
  254.   if (p == MAP_FAILED)
  255.     lj_err_caller(cts->L, LJ_ERR_FFI_CBACKOV);
  256. #else
  257.   /* Fallback allocator. Fails if memory is not executable by default. */
  258.   p = lj_mem_new(cts->L, sz);
  259. #endif
  260.   cts->cb.mcode = p;
  261.   callback_mcode_init(cts->g, p);
  262.   lj_mcode_sync(p, (char *)p + sz);
  263. #if LJ_TARGET_WINDOWS
  264.   {
  265.     DWORD oprot;
  266.     VirtualProtect(p, sz, PAGE_EXECUTE_READ, &oprot);
  267.   }
  268. #elif LJ_TARGET_POSIX
  269.   mprotect(p, sz, (PROT_READ|PROT_EXEC));
  270. #endif
  271. }

  273. /* Free area for callback function pointers. */
  274. ‌void lj_ccallback_mcode_free(CTState *cts)
  275. {
  276.   size_t sz = (size_t)CALLBACK_MCODE_SIZE;
  277.   void *p = cts->cb.mcode;
  278.   if (p == NULL) return;
  279. #if LJ_TARGET_WINDOWS
  280.   VirtualFree(p, 0, MEM_RELEASE);
  281.   UNUSED(sz);
  282. #elif LJ_TARGET_POSIX
  283.   munmap(p, sz);
  284. #else
  285.   lj_mem_free(cts->g, p, sz);
  286. #endif
  287. }

  289. /* -- C callback entry ---------------------------------------------------- */

  291. /* Target-specific handling of register arguments. Similar to lj_ccall.c. */
  292. #if LJ_TARGET_X86

  294. ‌#define CALLBACK_HANDLE_REGARG \
  295.   if (!isfp) {  /* Only non-FP values may be passed in registers. */ \
  296.     if (n > 1) {  /* Anything > 32 bit is passed on the stack. */ \
  297.       if (!LJ_ABI_WIN) ngpr = maxgpr;  /* Prevent reordering. */ \
  298.     } else if (ngpr + 1 <= maxgpr) { \
  299.       sp = &cts->cb.gpr[ngpr]; \
  300.       ngpr += n; \
  301.       goto done; \
  302.     } \
  303.   }

  305. #elif LJ_TARGET_X64 && LJ_ABI_WIN

  307. /* Windows/x64 argument registers are strictly positional (use ngpr). */
  308. ‌#define CALLBACK_HANDLE_REGARG \
  309.   if (isfp) { \
  310.     if (ngpr < maxgpr) { sp = &cts->cb.fpr[ngpr++]; UNUSED(nfpr); goto done; } \
  311.   } else { \
  312.     if (ngpr < maxgpr) { sp = &cts->cb.gpr[ngpr++]; goto done; } \
  313.   }

  315. #elif LJ_TARGET_X64

  317. ‌#define CALLBACK_HANDLE_REGARG \
  318.   if (isfp) { \
  319.     if (nfpr + n <= CCALL_NARG_FPR) { \
  320.       sp = &cts->cb.fpr[nfpr]; \
  321.       nfpr += n; \
  322.       goto done; \
  323.     } \
  324.   } else { \
  325.     if (ngpr + n <= maxgpr) { \
  326.       sp = &cts->cb.gpr[ngpr]; \
  327.       ngpr += n; \
  328.       goto done; \
  329.     } \
  330.   }

  332. #elif LJ_TARGET_ARM

  334. #if LJ_ABI_SOFTFP

  336. ‌#define CALLBACK_HANDLE_REGARG_FP1        UNUSED(isfp);
  337. ‌#define CALLBACK_HANDLE_REGARG_FP2

  339. #else

  341. ‌#define CALLBACK_HANDLE_REGARG_FP1 \
  342.   if (isfp) { \
  343.     if (n == 1) { \
  344.       if (fprodd) { \
  345.         sp = &cts->cb.fpr[fprodd-1]; \
  346.         fprodd = 0; \
  347.         goto done; \
  348.       } else if (nfpr + 1 <= CCALL_NARG_FPR) { \
  349.         sp = &cts->cb.fpr[nfpr++]; \
  350.         fprodd = nfpr; \
  351.         goto done; \
  352.       } \
  353.     } else { \
  354.       if (nfpr + 1 <= CCALL_NARG_FPR) { \
  355.         sp = &cts->cb.fpr[nfpr++]; \
  356.         goto done; \
  357.       } \
  358.     } \
  359.     fprodd = 0;  /* No reordering after the first FP value is on stack. */ \
  360.   } else {

  362. ‌#define CALLBACK_HANDLE_REGARG_FP2        }

  364. #endif

  366. ‌#define CALLBACK_HANDLE_REGARG \
  367.   CALLBACK_HANDLE_REGARG_FP1 \
  368.   if (n > 1) ngpr = (ngpr + 1u) & ~1u;  /* Align to regpair. */ \
  369.   if (ngpr + n <= maxgpr) { \
  370.     sp = &cts->cb.gpr[ngpr]; \
  371.     ngpr += n; \
  372.     goto done; \
  373.   } CALLBACK_HANDLE_REGARG_FP2

  375. #elif LJ_TARGET_ARM64

  377. ‌#define CALLBACK_HANDLE_REGARG \
  378.   if (isfp) { \
  379.     if (nfpr + n <= CCALL_NARG_FPR) { \
  380.       sp = &cts->cb.fpr[nfpr]; \
  381.       nfpr += n; \
  382.       goto done; \
  383.     } else { \
  384.       nfpr = CCALL_NARG_FPR;  /* Prevent reordering. */ \
  385.     } \
  386.   } else { \
  387.     if (!LJ_TARGET_IOS && n > 1) \
  388.       ngpr = (ngpr + 1u) & ~1u;  /* Align to regpair. */ \
  389.     if (ngpr + n <= maxgpr) { \
  390.       sp = &cts->cb.gpr[ngpr]; \
  391.       ngpr += n; \
  392.       goto done; \
  393.     } else { \
  394.       ngpr = CCALL_NARG_GPR;  /* Prevent reordering. */ \
  395.     } \
  396.   }

  398. #elif LJ_TARGET_PPC

  400. ‌#define CALLBACK_HANDLE_REGARG \
  401.   if (isfp) { \
  402.     if (nfpr + 1 <= CCALL_NARG_FPR) { \
  403.       sp = &cts->cb.fpr[nfpr++]; \
  404.       cta = ctype_get(cts, CTID_DOUBLE);  /* FPRs always hold doubles. */ \
  405.       goto done; \
  406.     } \
  407.   } else {  /* Try to pass argument in GPRs. */ \
  408.     if (n > 1) { \
  409.       lua_assert(ctype_isinteger(cta->info) && n == 2);  /* int64_t. */ \
  410.       ngpr = (ngpr + 1u) & ~1u;  /* Align int64_t to regpair. */ \
  411.     } \
  412.     if (ngpr + n <= maxgpr) { \
  413.       sp = &cts->cb.gpr[ngpr]; \
  414.       ngpr += n; \
  415.       goto done; \
  416.     } \
  417.   }

  419. ‌#define CALLBACK_HANDLE_RET \
  420.   if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
  421.     *(double *)dp = *(float *)dp;  /* FPRs always hold doubles. */

  423. #elif LJ_TARGET_MIPS

  425. ‌#define CALLBACK_HANDLE_REGARG \
  426.   if (isfp && nfpr < CCALL_NARG_FPR) {  /* Try to pass argument in FPRs. */ \
  427.     sp = (void *)((uint8_t *)&cts->cb.fpr[nfpr] + ((LJ_BE && n==1) ? 4 : 0)); \
  428.     nfpr++; ngpr += n; \
  429.     goto done; \
  430.   } else {  /* Try to pass argument in GPRs. */ \
  431.     nfpr = CCALL_NARG_FPR; \
  432.     if (n > 1) ngpr = (ngpr + 1u) & ~1u;  /* Align to regpair. */ \
  433.     if (ngpr + n <= maxgpr) { \
  434.       sp = &cts->cb.gpr[ngpr]; \
  435.       ngpr += n; \
  436.       goto done; \
  437.     } \
  438.   }

  440. ‌#define CALLBACK_HANDLE_RET \
  441.   if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
  442.     ((float *)dp)[1] = *(float *)dp;

  444. #else
  445. #error "Missing calling convention definitions for this architecture"
  446. #endif

  448. /* Convert and push callback arguments to Lua stack. */
  449. ‌static void callback_conv_args(CTState *cts, lua_State *L)
  450. {
  451.   TValue *o = L->top;
  452.   intptr_t *stack = cts->cb.stack;
  453.   MSize slot = cts->cb.slot;
  454.   CTypeID id = 0, rid, fid;
  455.   int gcsteps = 0;
  456.   CType *ct;
  457.   GCfunc *fn;
  458.   int fntp;
  459.   MSize ngpr = 0, nsp = 0, maxgpr = CCALL_NARG_GPR;
  460. #if CCALL_NARG_FPR
  461.   MSize nfpr = 0;
  462. #if LJ_TARGET_ARM
  463.   MSize fprodd = 0;
  464. #endif
  465. #endif

  467.   if (slot < cts->cb.sizeid && (id = cts->cb.cbid[slot]) != 0) {
  468.     ct = ctype_get(cts, id);
  469.     rid = ctype_cid(ct->info);  /* Return type. x86: +(spadj<<16). */
  470.     fn = funcV(lj_tab_getint(cts->miscmap, (int32_t)slot));
  471.     fntp = LJ_TFUNC;
  472.   } else {  /* Must set up frame first, before throwing the error. */
  473.     ct = NULL;
  474.     rid = 0;
  475.     fn = (GCfunc *)L;
  476.     fntp = LJ_TTHREAD;
  477.   }
  478.   /* Continuation returns from callback. */
  479.   if (LJ_FR2) {
  480.     (o++)->u64 = LJ_CONT_FFI_CALLBACK;
  481.     (o++)->u64 = rid;
  482.     o++;
  483.   } else {
  484.     o->u32.lo = LJ_CONT_FFI_CALLBACK;
  485.     o->u32.hi = rid;
  486.     o++;
  487.   }
  488.   setframe_gc(o, obj2gco(fn), fntp);
  489.   setframe_ftsz(o, ((char *)(o+1) - (char *)L->base) + FRAME_CONT);
  490.   L->top = L->base = ++o;
  491.   if (!ct)
  492.     lj_err_caller(cts->L, LJ_ERR_FFI_BADCBACK);
  493.   if (isluafunc(fn))
  494.     setcframe_pc(L->cframe, proto_bc(funcproto(fn))+1);
  495.   lj_state_checkstack(L, LUA_MINSTACK);  /* May throw. */
  496.   o = L->base;  /* Might have been reallocated. */

  498. #if LJ_TARGET_X86
  499.   /* x86 has several different calling conventions. */
  500.   switch (ctype_cconv(ct->info)) {
  501.   case CTCC_FASTCALL: maxgpr = 2; break;
  502.   case CTCC_THISCALL: maxgpr = 1; break;
  503.   default: maxgpr = 0; break;
  504.   }
  505. #endif

  507.   fid = ct->sib;
  508.   while (fid) {
  509.     CType *ctf = ctype_get(cts, fid);
  510.     if (!ctype_isattrib(ctf->info)) {
  511.       CType *cta;
  512.       void *sp;
  513.       CTSize sz;
  514.       int isfp;
  515.       MSize n;
  516.       lua_assert(ctype_isfield(ctf->info));
  517.       cta = ctype_rawchild(cts, ctf);
  518.       isfp = ctype_isfp(cta->info);
  519.       sz = (cta->size + CTSIZE_PTR-1) & ~(CTSIZE_PTR-1);
  520.       n = sz / CTSIZE_PTR;  /* Number of GPRs or stack slots needed. */

  522.       CALLBACK_HANDLE_REGARG  /* Handle register arguments. */

  524.       /* Otherwise pass argument on stack. */
  525.       if (CCALL_ALIGN_STACKARG && LJ_32 && sz == 8)
  526.         nsp = (nsp + 1) & ~1u;  /* Align 64 bit argument on stack. */
  527.       sp = &stack[nsp];
  528.       nsp += n;

  530.     done:
  531.       if (LJ_BE && cta->size < CTSIZE_PTR)
  532.         sp = (void *)((uint8_t *)sp + CTSIZE_PTR-cta->size);
  533.       gcsteps += lj_cconv_tv_ct(cts, cta, 0, o++, sp);
  534.     }
  535.     fid = ctf->sib;
  536.   }
  537.   L->top = o;
  538. #if LJ_TARGET_X86
  539.   /* Store stack adjustment for returns from non-cdecl callbacks. */
  540.   if (ctype_cconv(ct->info) != CTCC_CDECL) {
  541. #if LJ_FR2
  542.     (L->base-3)->u64 |= (nsp << (16+2));
  543. #else
  544.     (L->base-2)->u32.hi |= (nsp << (16+2));
  545. #endif
  546.   }
  547. #endif
  548.   while (gcsteps-- > 0)
  549.     lj_gc_check(L);
  550. }

  552. /* Convert Lua object to callback result. */
  553. ‌static void callback_conv_result(CTState *cts, lua_State *L, TValue *o)
  554. {
  555. #if LJ_FR2
  556.   CType *ctr = ctype_raw(cts, (uint16_t)(L->base-3)->u64);
  557. #else
  558.   CType *ctr = ctype_raw(cts, (uint16_t)(L->base-2)->u32.hi);
  559. #endif
  560. #if LJ_TARGET_X86
  561.   cts->cb.gpr[2] = 0;
  562. #endif
  563.   if (!ctype_isvoid(ctr->info)) {
  564.     uint8_t *dp = (uint8_t *)&cts->cb.gpr[0];
  565. #if CCALL_NUM_FPR
  566.     if (ctype_isfp(ctr->info))
  567.       dp = (uint8_t *)&cts->cb.fpr[0];
  568. #endif
  569.     lj_cconv_ct_tv(cts, ctr, dp, o, 0);
  570. #ifdef CALLBACK_HANDLE_RET
  571.     CALLBACK_HANDLE_RET
  572. #endif
  573.     /* Extend returned integers to (at least) 32 bits. */
  574.     if (ctype_isinteger_or_bool(ctr->info) && ctr->size < 4) {
  575.       if (ctr->info & CTF_UNSIGNED)
  576.         *(uint32_t *)dp = ctr->size == 1 ? (uint32_t)*(uint8_t *)dp :
  577.                                            (uint32_t)*(uint16_t *)dp;
  578.       else
  579.         *(int32_t *)dp = ctr->size == 1 ? (int32_t)*(int8_t *)dp :
  580.                                           (int32_t)*(int16_t *)dp;
  581.     }
  582. #if LJ_TARGET_X86
  583.     if (ctype_isfp(ctr->info))
  584.       cts->cb.gpr[2] = ctr->size == sizeof(float) ? 1 : 2;
  585. #endif
  586.   }
  587. }

  589. /* Enter callback. */
  590. ‌lua_State * LJ_FASTCALL lj_ccallback_enter(CTState *cts, void *cf)
  591. {
  592.   lua_State *L = cts->L;
  593.   global_State *g = cts->g;
  594.   lua_assert(L != NULL);
  595.   if (tvref(g->jit_base)) {
  596.     setstrV(L, L->top++, lj_err_str(L, LJ_ERR_FFI_BADCBACK));
  597.     if (g->panic) g->panic(L);
  598.     exit(EXIT_FAILURE);
  599.   }
  600.   lj_trace_abort(g);  /* Never record across callback. */
  601.   /* Setup C frame. */
  602.   cframe_prev(cf) = L->cframe;
  603.   setcframe_L(cf, L);
  604.   cframe_errfunc(cf) = -1;
  605.   cframe_nres(cf) = 0;
  606.   L->cframe = cf;
  607.   callback_conv_args(cts, L);
  608.   return L;  /* Now call the function on this stack. */
  609. }

  611. /* Leave callback. */
  612. ‌void LJ_FASTCALL lj_ccallback_leave(CTState *cts, TValue *o)
  613. {
  614.   lua_State *L = cts->L;
  615.   GCfunc *fn;
  616.   TValue *obase = L->base;
  617.   L->base = L->top;  /* Keep continuation frame for throwing errors. */
  618.   if (o >= L->base) {
  619.     /* PC of RET* is lost. Point to last line for result conv. errors. */
  620.     fn = curr_func(L);
  621.     if (isluafunc(fn)) {
  622.       GCproto *pt = funcproto(fn);
  623.       setcframe_pc(L->cframe, proto_bc(pt)+pt->sizebc+1);
  624.     }
  625.   }
  626.   callback_conv_result(cts, L, o);
  627.   /* Finally drop C frame and continuation frame. */
  628.   L->top -= 2+2*LJ_FR2;
  629.   L->base = obase;
  630.   L->cframe = cframe_prev(L->cframe);
  631.   cts->cb.slot = 0;  /* Blacklist C function that called the callback. */
  632. }

  634. /* -- C callback management ----------------------------------------------- */

  636. /* Get an unused slot in the callback slot table. */
  637. ‌static MSize callback_slot_new(CTState *cts, CType *ct)
  638. {
  639.   CTypeID id = ctype_typeid(cts, ct);
  640.   CTypeID1 *cbid = cts->cb.cbid;
  641.   MSize top;
  642.   for (top = cts->cb.topid; top < cts->cb.sizeid; top++)
  643.     if (LJ_LIKELY(cbid[top] == 0))
  644.       goto found;
  645. #if CALLBACK_MAX_SLOT
  646.   if (top >= CALLBACK_MAX_SLOT)
  647. #endif
  648.     lj_err_caller(cts->L, LJ_ERR_FFI_CBACKOV);
  649.   if (!cts->cb.mcode)
  650.     callback_mcode_new(cts);
  651.   lj_mem_growvec(cts->L, cbid, cts->cb.sizeid, CALLBACK_MAX_SLOT, CTypeID1);
  652.   cts->cb.cbid = cbid;
  653.   memset(cbid+top, 0, (cts->cb.sizeid-top)*sizeof(CTypeID1));
  654. found:
  655.   cbid[top] = id;
  656.   cts->cb.topid = top+1;
  657.   return top;
  658. }

  660. /* Check for function pointer and supported argument/result types. */
  661. ‌static CType *callback_checkfunc(CTState *cts, CType *ct)
  662. {
  663.   int narg = 0;
  664.   if (!ctype_isptr(ct->info) || (LJ_64 && ct->size != CTSIZE_PTR))
  665.     return NULL;
  666.   ct = ctype_rawchild(cts, ct);
  667.   if (ctype_isfunc(ct->info)) {
  668.     CType *ctr = ctype_rawchild(cts, ct);
  669.     CTypeID fid = ct->sib;
  670.     if (!(ctype_isvoid(ctr->info) || ctype_isenum(ctr->info) ||
  671.           ctype_isptr(ctr->info) || (ctype_isnum(ctr->info) && ctr->size <= 8)))
  672.       return NULL;
  673.     if ((ct->info & CTF_VARARG))
  674.       return NULL;
  675.     while (fid) {
  676.       CType *ctf = ctype_get(cts, fid);
  677.       if (!ctype_isattrib(ctf->info)) {
  678.         CType *cta;
  679.         lua_assert(ctype_isfield(ctf->info));
  680.         cta = ctype_rawchild(cts, ctf);
  681.         if (!(ctype_isenum(cta->info) || ctype_isptr(cta->info) ||
  682.               (ctype_isnum(cta->info) && cta->size <= 8)) ||
  683.             ++narg >= LUA_MINSTACK-3)
  684.           return NULL;
  685.       }
  686.       fid = ctf->sib;
  687.     }
  688.     return ct;
  689.   }
  690.   return NULL;
  691. }

  693. /* Create a new callback and return the callback function pointer. */
  694. ‌void *lj_ccallback_new(CTState *cts, CType *ct, GCfunc *fn)
  695. {
  696.   ct = callback_checkfunc(cts, ct);
  697.   if (ct) {
  698.     MSize slot = callback_slot_new(cts, ct);
  699.     GCtab *t = cts->miscmap;
  700.     setfuncV(cts->L, lj_tab_setint(cts->L, t, (int32_t)slot), fn);
  701.     lj_gc_anybarriert(cts->L, t);
  702.     return callback_slot2ptr(cts, slot);
  703.   }
  704.   return NULL;  /* Bad conversion. */
  705. }

  707. #endif

One Level Up Top Level