One Level Up Top Level

src/lj_ffrecord.c - luajit-2.0-src

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. ** Fast function call recorder.
  3. ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
  4. */

  6. ‌#define lj_ffrecord_c
  7. ‌#define LUA_CORE

  9. #include "lj_obj.h"

  11. #if LJ_HASJIT

  13. #include "lj_err.h"
  14. #include "lj_str.h"
  15. #include "lj_tab.h"
  16. #include "lj_frame.h"
  17. #include "lj_bc.h"
  18. #include "lj_ff.h"
  19. #include "lj_ir.h"
  20. #include "lj_jit.h"
  21. #include "lj_ircall.h"
  22. #include "lj_iropt.h"
  23. #include "lj_trace.h"
  24. #include "lj_record.h"
  25. #include "lj_ffrecord.h"
  26. #include "lj_crecord.h"
  27. #include "lj_dispatch.h"
  28. #include "lj_vm.h"
  29. #include "lj_strscan.h"
  30. #include "lj_strfmt.h"

  32. /* Some local macros to save typing. Undef'd at the end. */
  33. ‌#define IR(ref)                        (&J->cur.ir[(ref)])

  35. /* Pass IR on to next optimization in chain (FOLD). */
  36. ‌#define emitir(ot, a, b)        (lj_ir_set(J, (ot), (a), (b)), lj_opt_fold(J))

  38. /* -- Fast function recording handlers ------------------------------------ */

  40. /* Conventions for fast function call handlers:
  41. **
  42. ** The argument slots start at J->base[0]. All of them are guaranteed to be
  43. ** valid and type-specialized references. J->base[J->maxslot] is set to 0
  44. ** as a sentinel. The runtime argument values start at rd->argv[0].
  45. **
  46. ** In general fast functions should check for presence of all of their
  47. ** arguments and for the correct argument types. Some simplifications
  48. ** are allowed if the interpreter throws instead. But even if recording
  49. ** is aborted, the generated IR must be consistent (no zero-refs).
  50. **
  51. ** The number of results in rd->nres is set to 1. Handlers that return
  52. ** a different number of results need to override it. A negative value
  53. ** prevents return processing (e.g. for pending calls).
  54. **
  55. ** Results need to be stored starting at J->base[0]. Return processing
  56. ** moves them to the right slots later.
  57. **
  58. ** The per-ffid auxiliary data is the value of the 2nd part of the
  59. ** LJLIB_REC() annotation. This allows handling similar functionality
  60. ** in a common handler.
  61. */

  63. /* Type of handler to record a fast function. */
  64. ‌typedef void (LJ_FASTCALL *RecordFunc)(jit_State *J, RecordFFData *rd);

  66. /* Get runtime value of int argument. */
  67. ‌static int32_t argv2int(jit_State *J, TValue *o)
  68. {
  69.   if (!lj_strscan_numberobj(o))
  70.     lj_trace_err(J, LJ_TRERR_BADTYPE);
  71.   return tvisint(o) ? intV(o) : lj_num2int(numV(o));
  72. }

  74. /* Get runtime value of string argument. */
  75. ‌static GCstr *argv2str(jit_State *J, TValue *o)
  76. {
  77.   if (LJ_LIKELY(tvisstr(o))) {
  78.     return strV(o);
  79.   } else {
  80.     GCstr *s;
  81.     if (!tvisnumber(o))
  82.       lj_trace_err(J, LJ_TRERR_BADTYPE);
  83.     s = lj_strfmt_number(J->L, o);
  84.     setstrV(J->L, o, s);
  85.     return s;
  86.   }
  87. }

  89. /* Return number of results wanted by caller. */
  90. ‌static ptrdiff_t results_wanted(jit_State *J)
  91. {
  92.   TValue *frame = J->L->base-1;
  93.   if (frame_islua(frame))
  94.     return (ptrdiff_t)bc_b(frame_pc(frame)[-1]) - 1;
  95.   else
  96.     return -1;
  97. }

  99. /* Trace stitching: add continuation below frame to start a new trace. */
  100. ‌static void recff_stitch(jit_State *J)
  101. {
  102.   ASMFunction cont = lj_cont_stitch;
  103.   TraceNo traceno = J->cur.traceno;
  104.   lua_State *L = J->L;
  105.   TValue *base = L->base;
  106.   const BCIns *pc = frame_pc(base-1);
  107.   TValue *pframe = frame_prevl(base-1);
  108.   TRef trcont;

  110.   lua_assert(!LJ_FR2);  /* TODO_FR2: handle frame shift. */
  111.   /* Move func + args up in Lua stack and insert continuation. */
  112.   memmove(&base[1], &base[-1], sizeof(TValue)*(J->maxslot+1));
  113.   setframe_ftsz(base+1, ((char *)(base+1) - (char *)pframe) + FRAME_CONT);
  114.   setcont(base, cont);
  115.   setframe_pc(base, pc);
  116.   if (LJ_DUALNUM) setintV(base-1, traceno); else base[-1].u64 = traceno;
  117.   L->base += 2;
  118.   L->top += 2;

  120.   /* Ditto for the IR. */
  121.   memmove(&J->base[1], &J->base[-1], sizeof(TRef)*(J->maxslot+1));
  122. #if LJ_64
  123.   trcont = lj_ir_kptr(J, (void *)((int64_t)cont-(int64_t)lj_vm_asm_begin));
  124. #else
  125.   trcont = lj_ir_kptr(J, (void *)cont);
  126. #endif
  127.   J->base[0] = trcont | TREF_CONT;
  128.   J->base[-1] = LJ_DUALNUM ? lj_ir_kint(J,traceno) : lj_ir_knum_u64(J,traceno);
  129.   J->base += 2;
  130.   J->baseslot += 2;
  131.   J->framedepth++;

  133.   lj_record_stop(J, LJ_TRLINK_STITCH, 0);

  135.   /* Undo Lua stack changes. */
  136.   memmove(&base[-1], &base[1], sizeof(TValue)*(J->maxslot+1));
  137.   setframe_pc(base-1, pc);
  138.   L->base -= 2;
  139.   L->top -= 2;
  140. }

  142. /* Fallback handler for fast functions that are not recorded (yet). */
  143. ‌static void LJ_FASTCALL recff_nyi(jit_State *J, RecordFFData *rd)
  144. {
  145.   if (J->cur.nins < (IRRef)J->param[JIT_P_minstitch] + REF_BASE) {
  146.     lj_trace_err_info(J, LJ_TRERR_TRACEUV);
  147.   } else {
  148.     /* Can only stitch from Lua call. */
  149.     if (J->framedepth && frame_islua(J->L->base-1)) {
  150.       BCOp op = bc_op(*frame_pc(J->L->base-1));
  151.       /* Stitched trace cannot start with *M op with variable # of args. */
  152.       if (!(op == BC_CALLM || op == BC_CALLMT ||
  153.             op == BC_RETM || op == BC_TSETM)) {
  154.         switch (J->fn->c.ffid) {
  155.         case FF_error:
  156.         case FF_debug_sethook:
  157.         case FF_jit_flush:
  158.           break;  /* Don't stitch across special builtins. */
  159.         default:
  160.           recff_stitch(J);  /* Use trace stitching. */
  161.           rd->nres = -1;
  162.           return;
  163.         }
  164.       }
  165.     }
  166.     /* Otherwise stop trace and return to interpreter. */
  167.     lj_record_stop(J, LJ_TRLINK_RETURN, 0);
  168.     rd->nres = -1;
  169.   }
  170. }

  172. /* Fallback handler for unsupported variants of fast functions. */
  173. ‌#define recff_nyiu        recff_nyi

  175. /* Must stop the trace for classic C functions with arbitrary side-effects. */
  176. ‌#define recff_c                recff_nyi

  178. /* Emit BUFHDR for the global temporary buffer. */
  179. ‌static TRef recff_bufhdr(jit_State *J)
  180. {
  181.   return emitir(IRT(IR_BUFHDR, IRT_P32),
  182.                 lj_ir_kptr(J, &J2G(J)->tmpbuf), IRBUFHDR_RESET);
  183. }

  185. /* -- Base library fast functions ----------------------------------------- */

  187. ‌static void LJ_FASTCALL recff_assert(jit_State *J, RecordFFData *rd)
  188. {
  189.   /* Arguments already specialized. The interpreter throws for nil/false. */
  190.   rd->nres = J->maxslot;  /* Pass through all arguments. */
  191. }

  193. ‌static void LJ_FASTCALL recff_type(jit_State *J, RecordFFData *rd)
  194. {
  195.   /* Arguments already specialized. Result is a constant string. Neat, huh? */
  196.   uint32_t t;
  197.   if (tvisnumber(&rd->argv[0]))
  198.     t = ~LJ_TNUMX;
  199.   else if (LJ_64 && !LJ_GC64 && tvislightud(&rd->argv[0]))
  200.     t = ~LJ_TLIGHTUD;
  201.   else
  202.     t = ~itype(&rd->argv[0]);
  203.   J->base[0] = lj_ir_kstr(J, strV(&J->fn->c.upvalue[t]));
  204.   UNUSED(rd);
  205. }

  207. ‌static void LJ_FASTCALL recff_getmetatable(jit_State *J, RecordFFData *rd)
  208. {
  209.   TRef tr = J->base[0];
  210.   if (tr) {
  211.     RecordIndex ix;
  212.     ix.tab = tr;
  213.     copyTV(J->L, &ix.tabv, &rd->argv[0]);
  214.     if (lj_record_mm_lookup(J, &ix, MM_metatable))
  215.       J->base[0] = ix.mobj;
  216.     else
  217.       J->base[0] = ix.mt;
  218.   }  /* else: Interpreter will throw. */
  219. }

  221. ‌static void LJ_FASTCALL recff_setmetatable(jit_State *J, RecordFFData *rd)
  222. {
  223.   TRef tr = J->base[0];
  224.   TRef mt = J->base[1];
  225.   if (tref_istab(tr) && (tref_istab(mt) || (mt && tref_isnil(mt)))) {
  226.     TRef fref, mtref;
  227.     RecordIndex ix;
  228.     ix.tab = tr;
  229.     copyTV(J->L, &ix.tabv, &rd->argv[0]);
  230.     lj_record_mm_lookup(J, &ix, MM_metatable); /* Guard for no __metatable. */
  231.     fref = emitir(IRT(IR_FREF, IRT_P32), tr, IRFL_TAB_META);
  232.     mtref = tref_isnil(mt) ? lj_ir_knull(J, IRT_TAB) : mt;
  233.     emitir(IRT(IR_FSTORE, IRT_TAB), fref, mtref);
  234.     if (!tref_isnil(mt))
  235.       emitir(IRT(IR_TBAR, IRT_TAB), tr, 0);
  236.     J->base[0] = tr;
  237.     J->needsnap = 1;
  238.   }  /* else: Interpreter will throw. */
  239. }

  241. ‌static void LJ_FASTCALL recff_rawget(jit_State *J, RecordFFData *rd)
  242. {
  243.   RecordIndex ix;
  244.   ix.tab = J->base[0]; ix.key = J->base[1];
  245.   if (tref_istab(ix.tab) && ix.key) {
  246.     ix.val = 0; ix.idxchain = 0;
  247.     settabV(J->L, &ix.tabv, tabV(&rd->argv[0]));
  248.     copyTV(J->L, &ix.keyv, &rd->argv[1]);
  249.     J->base[0] = lj_record_idx(J, &ix);
  250.   }  /* else: Interpreter will throw. */
  251. }

  253. ‌static void LJ_FASTCALL recff_rawset(jit_State *J, RecordFFData *rd)
  254. {
  255.   RecordIndex ix;
  256.   ix.tab = J->base[0]; ix.key = J->base[1]; ix.val = J->base[2];
  257.   if (tref_istab(ix.tab) && ix.key && ix.val) {
  258.     ix.idxchain = 0;
  259.     settabV(J->L, &ix.tabv, tabV(&rd->argv[0]));
  260.     copyTV(J->L, &ix.keyv, &rd->argv[1]);
  261.     copyTV(J->L, &ix.valv, &rd->argv[2]);
  262.     lj_record_idx(J, &ix);
  263.     /* Pass through table at J->base[0] as result. */
  264.   }  /* else: Interpreter will throw. */
  265. }

  267. ‌static void LJ_FASTCALL recff_rawequal(jit_State *J, RecordFFData *rd)
  268. {
  269.   TRef tra = J->base[0];
  270.   TRef trb = J->base[1];
  271.   if (tra && trb) {
  272.     int diff = lj_record_objcmp(J, tra, trb, &rd->argv[0], &rd->argv[1]);
  273.     J->base[0] = diff ? TREF_FALSE : TREF_TRUE;
  274.   }  /* else: Interpreter will throw. */
  275. }

  277. #if LJ_52
  278. ‌static void LJ_FASTCALL recff_rawlen(jit_State *J, RecordFFData *rd)
  279. {
  280.   TRef tr = J->base[0];
  281.   if (tref_isstr(tr))
  282.     J->base[0] = emitir(IRTI(IR_FLOAD), tr, IRFL_STR_LEN);
  283.   else if (tref_istab(tr))
  284.     J->base[0] = lj_ir_call(J, IRCALL_lj_tab_len, tr);
  285.   /* else: Interpreter will throw. */
  286.   UNUSED(rd);
  287. }
  288. #endif

  290. /* Determine mode of select() call. */
  291. ‌int32_t lj_ffrecord_select_mode(jit_State *J, TRef tr, TValue *tv)
  292. {
  293.   if (tref_isstr(tr) && *strVdata(tv) == '#') {  /* select('#', ...) */
  294.     if (strV(tv)->len == 1) {
  295.       emitir(IRTG(IR_EQ, IRT_STR), tr, lj_ir_kstr(J, strV(tv)));
  296.     } else {
  297.       TRef trptr = emitir(IRT(IR_STRREF, IRT_P32), tr, lj_ir_kint(J, 0));
  298.       TRef trchar = emitir(IRT(IR_XLOAD, IRT_U8), trptr, IRXLOAD_READONLY);
  299.       emitir(IRTG(IR_EQ, IRT_INT), trchar, lj_ir_kint(J, '#'));
  300.     }
  301.     return 0;
  302.   } else {  /* select(n, ...) */
  303.     int32_t start = argv2int(J, tv);
  304.     if (start == 0) lj_trace_err(J, LJ_TRERR_BADTYPE);  /* A bit misleading. */
  305.     return start;
  306.   }
  307. }

  309. ‌static void LJ_FASTCALL recff_select(jit_State *J, RecordFFData *rd)
  310. {
  311.   TRef tr = J->base[0];
  312.   if (tr) {
  313.     ptrdiff_t start = lj_ffrecord_select_mode(J, tr, &rd->argv[0]);
  314.     if (start == 0) {  /* select('#', ...) */
  315.       J->base[0] = lj_ir_kint(J, J->maxslot - 1);
  316.     } else if (tref_isk(tr)) {  /* select(k, ...) */
  317.       ptrdiff_t n = (ptrdiff_t)J->maxslot;
  318.       if (start < 0) start += n;
  319.       else if (start > n) start = n;
  320.       rd->nres = n - start;
  321.       if (start >= 1) {
  322.         ptrdiff_t i;
  323.         for (i = 0; i < n - start; i++)
  324.           J->base[i] = J->base[start+i];
  325.       }  /* else: Interpreter will throw. */
  326.     } else {
  327.       recff_nyiu(J, rd);
  328.       return;
  329.     }
  330.   }  /* else: Interpreter will throw. */
  331. }

  333. ‌static void LJ_FASTCALL recff_tonumber(jit_State *J, RecordFFData *rd)
  334. {
  335.   TRef tr = J->base[0];
  336.   TRef base = J->base[1];
  337.   if (tr && !tref_isnil(base)) {
  338.     base = lj_opt_narrow_toint(J, base);
  339.     if (!tref_isk(base) || IR(tref_ref(base))->i != 10) {
  340.       recff_nyiu(J, rd);
  341.       return;
  342.     }
  343.   }
  344.   if (tref_isnumber_str(tr)) {
  345.     if (tref_isstr(tr)) {
  346.       TValue tmp;
  347.       if (!lj_strscan_num(strV(&rd->argv[0]), &tmp)) {
  348.         recff_nyiu(J, rd);  /* Would need an inverted STRTO for this case. */
  349.         return;
  350.       }
  351.       tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
  352.     }
  353. #if LJ_HASFFI
  354.   } else if (tref_iscdata(tr)) {
  355.     lj_crecord_tonumber(J, rd);
  356.     return;
  357. #endif
  358.   } else {
  359.     tr = TREF_NIL;
  360.   }
  361.   J->base[0] = tr;
  362.   UNUSED(rd);
  363. }

  365. ‌static TValue *recff_metacall_cp(lua_State *L, lua_CFunction dummy, void *ud)
  366. {
  367.   jit_State *J = (jit_State *)ud;
  368.   lj_record_tailcall(J, 0, 1);
  369.   UNUSED(L); UNUSED(dummy);
  370.   return NULL;
  371. }

  373. ‌static int recff_metacall(jit_State *J, RecordFFData *rd, MMS mm)
  374. {
  375.   RecordIndex ix;
  376.   ix.tab = J->base[0];
  377.   copyTV(J->L, &ix.tabv, &rd->argv[0]);
  378.   if (lj_record_mm_lookup(J, &ix, mm)) {  /* Has metamethod? */
  379.     int errcode;
  380.     TValue argv0;
  381.     /* Temporarily insert metamethod below object. */
  382.     J->base[1] = J->base[0];
  383.     J->base[0] = ix.mobj;
  384.     copyTV(J->L, &argv0, &rd->argv[0]);
  385.     copyTV(J->L, &rd->argv[1], &rd->argv[0]);
  386.     copyTV(J->L, &rd->argv[0], &ix.mobjv);
  387.     /* Need to protect lj_record_tailcall because it may throw. */
  388.     errcode = lj_vm_cpcall(J->L, NULL, J, recff_metacall_cp);
  389.     /* Always undo Lua stack changes to avoid confusing the interpreter. */
  390.     copyTV(J->L, &rd->argv[0], &argv0);
  391.     if (errcode)
  392.       lj_err_throw(J->L, errcode);  /* Propagate errors. */
  393.     rd->nres = -1;  /* Pending call. */
  394.     return 1;  /* Tailcalled to metamethod. */
  395.   }
  396.   return 0;
  397. }

  399. ‌static void LJ_FASTCALL recff_tostring(jit_State *J, RecordFFData *rd)
  400. {
  401.   TRef tr = J->base[0];
  402.   if (tref_isstr(tr)) {
  403.     /* Ignore __tostring in the string base metatable. */
  404.     /* Pass on result in J->base[0]. */
  405.   } else if (tr && !recff_metacall(J, rd, MM_tostring)) {
  406.     if (tref_isnumber(tr)) {
  407.       J->base[0] = emitir(IRT(IR_TOSTR, IRT_STR), tr,
  408.                           tref_isnum(tr) ? IRTOSTR_NUM : IRTOSTR_INT);
  409.     } else if (tref_ispri(tr)) {
  410.       J->base[0] = lj_ir_kstr(J, lj_strfmt_obj(J->L, &rd->argv[0]));
  411.     } else {
  412.       recff_nyiu(J, rd);
  413.       return;
  414.     }
  415.   }
  416. }

  418. ‌static void LJ_FASTCALL recff_ipairs_aux(jit_State *J, RecordFFData *rd)
  419. {
  420.   RecordIndex ix;
  421.   ix.tab = J->base[0];
  422.   if (tref_istab(ix.tab)) {
  423.     if (!tvisnumber(&rd->argv[1]))  /* No support for string coercion. */
  424.       lj_trace_err(J, LJ_TRERR_BADTYPE);
  425.     setintV(&ix.keyv, numberVint(&rd->argv[1])+1);
  426.     settabV(J->L, &ix.tabv, tabV(&rd->argv[0]));
  427.     ix.val = 0; ix.idxchain = 0;
  428.     ix.key = lj_opt_narrow_toint(J, J->base[1]);
  429.     J->base[0] = ix.key = emitir(IRTI(IR_ADD), ix.key, lj_ir_kint(J, 1));
  430.     J->base[1] = lj_record_idx(J, &ix);
  431.     rd->nres = tref_isnil(J->base[1]) ? 0 : 2;
  432.   }  /* else: Interpreter will throw. */
  433. }

  435. ‌static void LJ_FASTCALL recff_xpairs(jit_State *J, RecordFFData *rd)
  436. {
  437.   if (!(LJ_52 && recff_metacall(J, rd, MM_ipairs))) {
  438.     TRef tab = J->base[0];
  439.     if (tref_istab(tab)) {
  440.       J->base[0] = lj_ir_kfunc(J, funcV(&J->fn->c.upvalue[0]));
  441.       J->base[1] = tab;
  442.       J->base[2] = rd->data ? lj_ir_kint(J, 0) : TREF_NIL;
  443.       rd->nres = 3;
  444.     }  /* else: Interpreter will throw. */
  445.   }
  446. }

  448. ‌static void LJ_FASTCALL recff_pcall(jit_State *J, RecordFFData *rd)
  449. {
  450.   if (J->maxslot >= 1) {
  451.     lj_record_call(J, 0, J->maxslot - 1);
  452.     rd->nres = -1;  /* Pending call. */
  453.   }  /* else: Interpreter will throw. */
  454. }

  456. ‌static TValue *recff_xpcall_cp(lua_State *L, lua_CFunction dummy, void *ud)
  457. {
  458.   jit_State *J = (jit_State *)ud;
  459.   lj_record_call(J, 1, J->maxslot - 2);
  460.   UNUSED(L); UNUSED(dummy);
  461.   return NULL;
  462. }

  464. ‌static void LJ_FASTCALL recff_xpcall(jit_State *J, RecordFFData *rd)
  465. {
  466.   if (J->maxslot >= 2) {
  467.     TValue argv0, argv1;
  468.     TRef tmp;
  469.     int errcode;
  470.     lua_assert(!LJ_FR2);  /* TODO_FR2: handle different frame setup. */
  471.     /* Swap function and traceback. */
  472.     tmp = J->base[0]; J->base[0] = J->base[1]; J->base[1] = tmp;
  473.     copyTV(J->L, &argv0, &rd->argv[0]);
  474.     copyTV(J->L, &argv1, &rd->argv[1]);
  475.     copyTV(J->L, &rd->argv[0], &argv1);
  476.     copyTV(J->L, &rd->argv[1], &argv0);
  477.     /* Need to protect lj_record_call because it may throw. */
  478.     errcode = lj_vm_cpcall(J->L, NULL, J, recff_xpcall_cp);
  479.     /* Always undo Lua stack swap to avoid confusing the interpreter. */
  480.     copyTV(J->L, &rd->argv[0], &argv0);
  481.     copyTV(J->L, &rd->argv[1], &argv1);
  482.     if (errcode)
  483.       lj_err_throw(J->L, errcode);  /* Propagate errors. */
  484.     rd->nres = -1;  /* Pending call. */
  485.   }  /* else: Interpreter will throw. */
  486. }

  488. ‌static void LJ_FASTCALL recff_getfenv(jit_State *J, RecordFFData *rd)
  489. {
  490.   TRef tr = J->base[0];
  491.   /* Only support getfenv(0) for now. */
  492.   if (tref_isint(tr) && tref_isk(tr) && IR(tref_ref(tr))->i == 0) {
  493.     TRef trl = emitir(IRT(IR_LREF, IRT_THREAD), 0, 0);
  494.     J->base[0] = emitir(IRT(IR_FLOAD, IRT_TAB), trl, IRFL_THREAD_ENV);
  495.     return;
  496.   }
  497.   recff_nyiu(J, rd);
  498. }

  500. /* -- Math library fast functions ----------------------------------------- */

  502. ‌static void LJ_FASTCALL recff_math_abs(jit_State *J, RecordFFData *rd)
  503. {
  504.   TRef tr = lj_ir_tonum(J, J->base[0]);
  505.   J->base[0] = emitir(IRTN(IR_ABS), tr, lj_ir_knum_abs(J));
  506.   UNUSED(rd);
  507. }

  509. /* Record rounding functions math.floor and math.ceil. */
  510. ‌static void LJ_FASTCALL recff_math_round(jit_State *J, RecordFFData *rd)
  511. {
  512.   TRef tr = J->base[0];
  513.   if (!tref_isinteger(tr)) {  /* Pass through integers unmodified. */
  514.     tr = emitir(IRTN(IR_FPMATH), lj_ir_tonum(J, tr), rd->data);
  515.     /* Result is integral (or NaN/Inf), but may not fit an int32_t. */
  516.     if (LJ_DUALNUM) {  /* Try to narrow using a guarded conversion to int. */
  517.       lua_Number n = lj_vm_foldfpm(numberVnum(&rd->argv[0]), rd->data);
  518.       if (n == (lua_Number)lj_num2int(n))
  519.         tr = emitir(IRTGI(IR_CONV), tr, IRCONV_INT_NUM|IRCONV_CHECK);
  520.     }
  521.     J->base[0] = tr;
  522.   }
  523. }

  525. /* Record unary math.* functions, mapped to IR_FPMATH opcode. */
  526. ‌static void LJ_FASTCALL recff_math_unary(jit_State *J, RecordFFData *rd)
  527. {
  528.   J->base[0] = emitir(IRTN(IR_FPMATH), lj_ir_tonum(J, J->base[0]), rd->data);
  529. }

  531. /* Record math.log. */
  532. ‌static void LJ_FASTCALL recff_math_log(jit_State *J, RecordFFData *rd)
  533. {
  534.   TRef tr = lj_ir_tonum(J, J->base[0]);
  535.   if (J->base[1]) {
  536. #ifdef LUAJIT_NO_LOG2
  537.     uint32_t fpm = IRFPM_LOG;
  538. #else
  539.     uint32_t fpm = IRFPM_LOG2;
  540. #endif
  541.     TRef trb = lj_ir_tonum(J, J->base[1]);
  542.     tr = emitir(IRTN(IR_FPMATH), tr, fpm);
  543.     trb = emitir(IRTN(IR_FPMATH), trb, fpm);
  544.     trb = emitir(IRTN(IR_DIV), lj_ir_knum_one(J), trb);
  545.     tr = emitir(IRTN(IR_MUL), tr, trb);
  546.   } else {
  547.     tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_LOG);
  548.   }
  549.   J->base[0] = tr;
  550.   UNUSED(rd);
  551. }

  553. /* Record math.atan2. */
  554. ‌static void LJ_FASTCALL recff_math_atan2(jit_State *J, RecordFFData *rd)
  555. {
  556.   TRef tr = lj_ir_tonum(J, J->base[0]);
  557.   TRef tr2 = lj_ir_tonum(J, J->base[1]);
  558.   J->base[0] = emitir(IRTN(IR_ATAN2), tr, tr2);
  559.   UNUSED(rd);
  560. }

  562. /* Record math.ldexp. */
  563. ‌static void LJ_FASTCALL recff_math_ldexp(jit_State *J, RecordFFData *rd)
  564. {
  565.   TRef tr = lj_ir_tonum(J, J->base[0]);
  566. #if LJ_TARGET_X86ORX64
  567.   TRef tr2 = lj_ir_tonum(J, J->base[1]);
  568. #else
  569.   TRef tr2 = lj_opt_narrow_toint(J, J->base[1]);
  570. #endif
  571.   J->base[0] = emitir(IRTN(IR_LDEXP), tr, tr2);
  572.   UNUSED(rd);
  573. }

  575. /* Record math.asin, math.acos, math.atan. */
  576. ‌static void LJ_FASTCALL recff_math_atrig(jit_State *J, RecordFFData *rd)
  577. {
  578.   TRef y = lj_ir_tonum(J, J->base[0]);
  579.   TRef x = lj_ir_knum_one(J);
  580.   uint32_t ffid = rd->data;
  581.   if (ffid != FF_math_atan) {
  582.     TRef tmp = emitir(IRTN(IR_MUL), y, y);
  583.     tmp = emitir(IRTN(IR_SUB), x, tmp);
  584.     tmp = emitir(IRTN(IR_FPMATH), tmp, IRFPM_SQRT);
  585.     if (ffid == FF_math_asin) { x = tmp; } else { x = y; y = tmp; }
  586.   }
  587.   J->base[0] = emitir(IRTN(IR_ATAN2), y, x);
  588. }

  590. ‌static void LJ_FASTCALL recff_math_htrig(jit_State *J, RecordFFData *rd)
  591. {
  592.   TRef tr = lj_ir_tonum(J, J->base[0]);
  593.   J->base[0] = emitir(IRTN(IR_CALLN), tr, rd->data);
  594. }

  596. ‌static void LJ_FASTCALL recff_math_modf(jit_State *J, RecordFFData *rd)
  597. {
  598.   TRef tr = J->base[0];
  599.   if (tref_isinteger(tr)) {
  600.     J->base[0] = tr;
  601.     J->base[1] = lj_ir_kint(J, 0);
  602.   } else {
  603.     TRef trt;
  604.     tr = lj_ir_tonum(J, tr);
  605.     trt = emitir(IRTN(IR_FPMATH), tr, IRFPM_TRUNC);
  606.     J->base[0] = trt;
  607.     J->base[1] = emitir(IRTN(IR_SUB), tr, trt);
  608.   }
  609.   rd->nres = 2;
  610. }

  612. ‌static void LJ_FASTCALL recff_math_pow(jit_State *J, RecordFFData *rd)
  613. {
  614.   TRef tr = lj_ir_tonum(J, J->base[0]);
  615.   if (!tref_isnumber_str(J->base[1]))
  616.     lj_trace_err(J, LJ_TRERR_BADTYPE);
  617.   J->base[0] = lj_opt_narrow_pow(J, tr, J->base[1], &rd->argv[1]);
  618.   UNUSED(rd);
  619. }

  621. ‌static void LJ_FASTCALL recff_math_minmax(jit_State *J, RecordFFData *rd)
  622. {
  623.   TRef tr = lj_ir_tonumber(J, J->base[0]);
  624.   uint32_t op = rd->data;
  625.   BCReg i;
  626.   for (i = 1; J->base[i] != 0; i++) {
  627.     TRef tr2 = lj_ir_tonumber(J, J->base[i]);
  628.     IRType t = IRT_INT;
  629.     if (!(tref_isinteger(tr) && tref_isinteger(tr2))) {
  630.       if (tref_isinteger(tr)) tr = emitir(IRTN(IR_CONV), tr, IRCONV_NUM_INT);
  631.       if (tref_isinteger(tr2)) tr2 = emitir(IRTN(IR_CONV), tr2, IRCONV_NUM_INT);
  632.       t = IRT_NUM;
  633.     }
  634.     tr = emitir(IRT(op, t), tr, tr2);
  635.   }
  636.   J->base[0] = tr;
  637. }

  639. ‌static void LJ_FASTCALL recff_math_random(jit_State *J, RecordFFData *rd)
  640. {
  641.   GCudata *ud = udataV(&J->fn->c.upvalue[0]);
  642.   TRef tr, one;
  643.   lj_ir_kgc(J, obj2gco(ud), IRT_UDATA);  /* Prevent collection. */
  644.   tr = lj_ir_call(J, IRCALL_lj_math_random_step, lj_ir_kptr(J, uddata(ud)));
  645.   one = lj_ir_knum_one(J);
  646.   tr = emitir(IRTN(IR_SUB), tr, one);
  647.   if (J->base[0]) {
  648.     TRef tr1 = lj_ir_tonum(J, J->base[0]);
  649.     if (J->base[1]) {  /* d = floor(d*(r2-r1+1.0)) + r1 */
  650.       TRef tr2 = lj_ir_tonum(J, J->base[1]);
  651.       tr2 = emitir(IRTN(IR_SUB), tr2, tr1);
  652.       tr2 = emitir(IRTN(IR_ADD), tr2, one);
  653.       tr = emitir(IRTN(IR_MUL), tr, tr2);
  654.       tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_FLOOR);
  655.       tr = emitir(IRTN(IR_ADD), tr, tr1);
  656.     } else {  /* d = floor(d*r1) + 1.0 */
  657.       tr = emitir(IRTN(IR_MUL), tr, tr1);
  658.       tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_FLOOR);
  659.       tr = emitir(IRTN(IR_ADD), tr, one);
  660.     }
  661.   }
  662.   J->base[0] = tr;
  663.   UNUSED(rd);
  664. }

  666. /* -- Bit library fast functions ------------------------------------------ */

  668. /* Record bit.tobit. */
  669. ‌static void LJ_FASTCALL recff_bit_tobit(jit_State *J, RecordFFData *rd)
  670. {
  671.   TRef tr = J->base[0];
  672. #if LJ_HASFFI
  673.   if (tref_iscdata(tr)) { recff_bit64_tobit(J, rd); return; }
  674. #endif
  675.   J->base[0] = lj_opt_narrow_tobit(J, tr);
  676.   UNUSED(rd);
  677. }

  679. /* Record unary bit.bnot, bit.bswap. */
  680. ‌static void LJ_FASTCALL recff_bit_unary(jit_State *J, RecordFFData *rd)
  681. {
  682. #if LJ_HASFFI
  683.   if (recff_bit64_unary(J, rd))
  684.     return;
  685. #endif
  686.   J->base[0] = emitir(IRTI(rd->data), lj_opt_narrow_tobit(J, J->base[0]), 0);
  687. }

  689. /* Record N-ary bit.band, bit.bor, bit.bxor. */
  690. ‌static void LJ_FASTCALL recff_bit_nary(jit_State *J, RecordFFData *rd)
  691. {
  692. #if LJ_HASFFI
  693.   if (recff_bit64_nary(J, rd))
  694.     return;
  695. #endif
  696.   {
  697.     TRef tr = lj_opt_narrow_tobit(J, J->base[0]);
  698.     uint32_t ot = IRTI(rd->data);
  699.     BCReg i;
  700.     for (i = 1; J->base[i] != 0; i++)
  701.       tr = emitir(ot, tr, lj_opt_narrow_tobit(J, J->base[i]));
  702.     J->base[0] = tr;
  703.   }
  704. }

  706. /* Record bit shifts. */
  707. ‌static void LJ_FASTCALL recff_bit_shift(jit_State *J, RecordFFData *rd)
  708. {
  709. #if LJ_HASFFI
  710.   if (recff_bit64_shift(J, rd))
  711.     return;
  712. #endif
  713.   {
  714.     TRef tr = lj_opt_narrow_tobit(J, J->base[0]);
  715.     TRef tsh = lj_opt_narrow_tobit(J, J->base[1]);
  716.     IROp op = (IROp)rd->data;
  717.     if (!(op < IR_BROL ? LJ_TARGET_MASKSHIFT : LJ_TARGET_MASKROT) &&
  718.         !tref_isk(tsh))
  719.       tsh = emitir(IRTI(IR_BAND), tsh, lj_ir_kint(J, 31));
  720. #ifdef LJ_TARGET_UNIFYROT
  721.     if (op == (LJ_TARGET_UNIFYROT == 1 ? IR_BROR : IR_BROL)) {
  722.       op = LJ_TARGET_UNIFYROT == 1 ? IR_BROL : IR_BROR;
  723.       tsh = emitir(IRTI(IR_NEG), tsh, tsh);
  724.     }
  725. #endif
  726.     J->base[0] = emitir(IRTI(op), tr, tsh);
  727.   }
  728. }

  730. ‌static void LJ_FASTCALL recff_bit_tohex(jit_State *J, RecordFFData *rd)
  731. {
  732. #if LJ_HASFFI
  733.   TRef hdr = recff_bufhdr(J);
  734.   TRef tr = recff_bit64_tohex(J, rd, hdr);
  735.   J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
  736. #else
  737.   recff_nyiu(J, rd);  /* Don't bother working around this NYI. */
  738. #endif
  739. }

  741. /* -- String library fast functions --------------------------------------- */

  743. /* Specialize to relative starting position for string. */
  744. ‌static TRef recff_string_start(jit_State *J, GCstr *s, int32_t *st, TRef tr,
  745.                                TRef trlen, TRef tr0)
  746. {
  747.   int32_t start = *st;
  748.   if (start < 0) {
  749.     emitir(IRTGI(IR_LT), tr, tr0);
  750.     tr = emitir(IRTI(IR_ADD), trlen, tr);
  751.     start = start + (int32_t)s->len;
  752.     emitir(start < 0 ? IRTGI(IR_LT) : IRTGI(IR_GE), tr, tr0);
  753.     if (start < 0) {
  754.       tr = tr0;
  755.       start = 0;
  756.     }
  757.   } else if (start == 0) {
  758.     emitir(IRTGI(IR_EQ), tr, tr0);
  759.     tr = tr0;
  760.   } else {
  761.     tr = emitir(IRTI(IR_ADD), tr, lj_ir_kint(J, -1));
  762.     emitir(IRTGI(IR_GE), tr, tr0);
  763.     start--;
  764.   }
  765.   *st = start;
  766.   return tr;
  767. }

  769. /* Handle string.byte (rd->data = 0) and string.sub (rd->data = 1). */
  770. ‌static void LJ_FASTCALL recff_string_range(jit_State *J, RecordFFData *rd)
  771. {
  772.   TRef trstr = lj_ir_tostr(J, J->base[0]);
  773.   TRef trlen = emitir(IRTI(IR_FLOAD), trstr, IRFL_STR_LEN);
  774.   TRef tr0 = lj_ir_kint(J, 0);
  775.   TRef trstart, trend;
  776.   GCstr *str = argv2str(J, &rd->argv[0]);
  777.   int32_t start, end;
  778.   if (rd->data) {  /* string.sub(str, start [,end]) */
  779.     start = argv2int(J, &rd->argv[1]);
  780.     trstart = lj_opt_narrow_toint(J, J->base[1]);
  781.     trend = J->base[2];
  782.     if (tref_isnil(trend)) {
  783.       trend = lj_ir_kint(J, -1);
  784.       end = -1;
  785.     } else {
  786.       trend = lj_opt_narrow_toint(J, trend);
  787.       end = argv2int(J, &rd->argv[2]);
  788.     }
  789.   } else {  /* string.byte(str, [,start [,end]]) */
  790.     if (tref_isnil(J->base[1])) {
  791.       start = 1;
  792.       trstart = lj_ir_kint(J, 1);
  793.     } else {
  794.       start = argv2int(J, &rd->argv[1]);
  795.       trstart = lj_opt_narrow_toint(J, J->base[1]);
  796.     }
  797.     if (J->base[1] && !tref_isnil(J->base[2])) {
  798.       trend = lj_opt_narrow_toint(J, J->base[2]);
  799.       end = argv2int(J, &rd->argv[2]);
  800.     } else {
  801.       trend = trstart;
  802.       end = start;
  803.     }
  804.   }
  805.   if (end < 0) {
  806.     emitir(IRTGI(IR_LT), trend, tr0);
  807.     trend = emitir(IRTI(IR_ADD), emitir(IRTI(IR_ADD), trlen, trend),
  808.                    lj_ir_kint(J, 1));
  809.     end = end+(int32_t)str->len+1;
  810.   } else if ((MSize)end <= str->len) {
  811.     emitir(IRTGI(IR_ULE), trend, trlen);
  812.   } else {
  813.     emitir(IRTGI(IR_UGT), trend, trlen);
  814.     end = (int32_t)str->len;
  815.     trend = trlen;
  816.   }
  817.   trstart = recff_string_start(J, str, &start, trstart, trlen, tr0);
  818.   if (rd->data) {  /* Return string.sub result. */
  819.     if (end - start >= 0) {
  820.       /* Also handle empty range here, to avoid extra traces. */
  821.       TRef trptr, trslen = emitir(IRTI(IR_SUB), trend, trstart);
  822.       emitir(IRTGI(IR_GE), trslen, tr0);
  823.       trptr = emitir(IRT(IR_STRREF, IRT_P32), trstr, trstart);
  824.       J->base[0] = emitir(IRT(IR_SNEW, IRT_STR), trptr, trslen);
  825.     } else {  /* Range underflow: return empty string. */
  826.       emitir(IRTGI(IR_LT), trend, trstart);
  827.       J->base[0] = lj_ir_kstr(J, &J2G(J)->strempty);
  828.     }
  829.   } else {  /* Return string.byte result(s). */
  830.     ptrdiff_t i, len = end - start;
  831.     if (len > 0) {
  832.       TRef trslen = emitir(IRTI(IR_SUB), trend, trstart);
  833.       emitir(IRTGI(IR_EQ), trslen, lj_ir_kint(J, (int32_t)len));
  834.       if (J->baseslot + len > LJ_MAX_JSLOTS)
  835.         lj_trace_err_info(J, LJ_TRERR_STACKOV);
  836.       rd->nres = len;
  837.       for (i = 0; i < len; i++) {
  838.         TRef tmp = emitir(IRTI(IR_ADD), trstart, lj_ir_kint(J, (int32_t)i));
  839.         tmp = emitir(IRT(IR_STRREF, IRT_P32), trstr, tmp);
  840.         J->base[i] = emitir(IRT(IR_XLOAD, IRT_U8), tmp, IRXLOAD_READONLY);
  841.       }
  842.     } else {  /* Empty range or range underflow: return no results. */
  843.       emitir(IRTGI(IR_LE), trend, trstart);
  844.       rd->nres = 0;
  845.     }
  846.   }
  847. }

  849. ‌static void LJ_FASTCALL recff_string_char(jit_State *J, RecordFFData *rd)
  850. {
  851.   TRef k255 = lj_ir_kint(J, 255);
  852.   BCReg i;
  853.   for (i = 0; J->base[i] != 0; i++) {  /* Convert char values to strings. */
  854.     TRef tr = lj_opt_narrow_toint(J, J->base[i]);
  855.     emitir(IRTGI(IR_ULE), tr, k255);
  856.     J->base[i] = emitir(IRT(IR_TOSTR, IRT_STR), tr, IRTOSTR_CHAR);
  857.   }
  858.   if (i > 1) {  /* Concatenate the strings, if there's more than one. */
  859.     TRef hdr = recff_bufhdr(J), tr = hdr;
  860.     for (i = 0; J->base[i] != 0; i++)
  861.       tr = emitir(IRT(IR_BUFPUT, IRT_P32), tr, J->base[i]);
  862.     J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
  863.   }
  864.   UNUSED(rd);
  865. }

  867. ‌static void LJ_FASTCALL recff_string_rep(jit_State *J, RecordFFData *rd)
  868. {
  869.   TRef str = lj_ir_tostr(J, J->base[0]);
  870.   TRef rep = lj_opt_narrow_toint(J, J->base[1]);
  871.   TRef hdr, tr, str2 = 0;
  872.   if (!tref_isnil(J->base[2])) {
  873.     TRef sep = lj_ir_tostr(J, J->base[2]);
  874.     int32_t vrep = argv2int(J, &rd->argv[1]);
  875.     emitir(IRTGI(vrep > 1 ? IR_GT : IR_LE), rep, lj_ir_kint(J, 1));
  876.     if (vrep > 1) {
  877.       TRef hdr2 = recff_bufhdr(J);
  878.       TRef tr2 = emitir(IRT(IR_BUFPUT, IRT_P32), hdr2, sep);
  879.       tr2 = emitir(IRT(IR_BUFPUT, IRT_P32), tr2, str);
  880.       str2 = emitir(IRT(IR_BUFSTR, IRT_STR), tr2, hdr2);
  881.     }
  882.   }
  883.   tr = hdr = recff_bufhdr(J);
  884.   if (str2) {
  885.     tr = emitir(IRT(IR_BUFPUT, IRT_P32), tr, str);
  886.     str = str2;
  887.     rep = emitir(IRTI(IR_ADD), rep, lj_ir_kint(J, -1));
  888.   }
  889.   tr = lj_ir_call(J, IRCALL_lj_buf_putstr_rep, tr, str, rep);
  890.   J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
  891. }

  893. ‌static void LJ_FASTCALL recff_string_op(jit_State *J, RecordFFData *rd)
  894. {
  895.   TRef str = lj_ir_tostr(J, J->base[0]);
  896.   TRef hdr = recff_bufhdr(J);
  897.   TRef tr = lj_ir_call(J, rd->data, hdr, str);
  898.   J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
  899. }

  901. ‌static void LJ_FASTCALL recff_string_find(jit_State *J, RecordFFData *rd)
  902. {
  903.   TRef trstr = lj_ir_tostr(J, J->base[0]);
  904.   TRef trpat = lj_ir_tostr(J, J->base[1]);
  905.   TRef trlen = emitir(IRTI(IR_FLOAD), trstr, IRFL_STR_LEN);
  906.   TRef tr0 = lj_ir_kint(J, 0);
  907.   TRef trstart;
  908.   GCstr *str = argv2str(J, &rd->argv[0]);
  909.   GCstr *pat = argv2str(J, &rd->argv[1]);
  910.   int32_t start;
  911.   J->needsnap = 1;
  912.   if (tref_isnil(J->base[2])) {
  913.     trstart = lj_ir_kint(J, 1);
  914.     start = 1;
  915.   } else {
  916.     trstart = lj_opt_narrow_toint(J, J->base[2]);
  917.     start = argv2int(J, &rd->argv[2]);
  918.   }
  919.   trstart = recff_string_start(J, str, &start, trstart, trlen, tr0);
  920.   if ((MSize)start <= str->len) {
  921.     emitir(IRTGI(IR_ULE), trstart, trlen);
  922.   } else {
  923.     emitir(IRTGI(IR_UGT), trstart, trlen);
  924. #if LJ_52
  925.     J->base[0] = TREF_NIL;
  926.     return;
  927. #else
  928.     trstart = trlen;
  929.     start = str->len;
  930. #endif
  931.   }
  932.   /* Fixed arg or no pattern matching chars? (Specialized to pattern string.) */
  933.   if ((J->base[2] && tref_istruecond(J->base[3])) ||
  934.       (emitir(IRTG(IR_EQ, IRT_STR), trpat, lj_ir_kstr(J, pat)),
  935.        !lj_str_haspattern(pat))) {  /* Search for fixed string. */
  936.     TRef trsptr = emitir(IRT(IR_STRREF, IRT_P32), trstr, trstart);
  937.     TRef trpptr = emitir(IRT(IR_STRREF, IRT_P32), trpat, tr0);
  938.     TRef trslen = emitir(IRTI(IR_SUB), trlen, trstart);
  939.     TRef trplen = emitir(IRTI(IR_FLOAD), trpat, IRFL_STR_LEN);
  940.     TRef tr = lj_ir_call(J, IRCALL_lj_str_find, trsptr, trpptr, trslen, trplen);
  941.     TRef trp0 = lj_ir_kkptr(J, NULL);
  942.     if (lj_str_find(strdata(str)+(MSize)start, strdata(pat),
  943.                     str->len-(MSize)start, pat->len)) {
  944.       TRef pos;
  945.       emitir(IRTG(IR_NE, IRT_P32), tr, trp0);
  946.       pos = emitir(IRTI(IR_SUB), tr, emitir(IRT(IR_STRREF, IRT_P32), trstr, tr0));
  947.       J->base[0] = emitir(IRTI(IR_ADD), pos, lj_ir_kint(J, 1));
  948.       J->base[1] = emitir(IRTI(IR_ADD), pos, trplen);
  949.       rd->nres = 2;
  950.     } else {
  951.       emitir(IRTG(IR_EQ, IRT_P32), tr, trp0);
  952.       J->base[0] = TREF_NIL;
  953.     }
  954.   } else {  /* Search for pattern. */
  955.     recff_nyiu(J, rd);
  956.     return;
  957.   }
  958. }

  960. ‌static void LJ_FASTCALL recff_string_format(jit_State *J, RecordFFData *rd)
  961. {
  962.   TRef trfmt = lj_ir_tostr(J, J->base[0]);
  963.   GCstr *fmt = argv2str(J, &rd->argv[0]);
  964.   int arg = 1;
  965.   TRef hdr, tr;
  966.   FormatState fs;
  967.   SFormat sf;
  968.   /* Specialize to the format string. */
  969.   emitir(IRTG(IR_EQ, IRT_STR), trfmt, lj_ir_kstr(J, fmt));
  970.   tr = hdr = recff_bufhdr(J);
  971.   lj_strfmt_init(&fs, strdata(fmt), fmt->len);
  972.   while ((sf = lj_strfmt_parse(&fs)) != STRFMT_EOF) {  /* Parse format. */
  973.     TRef tra = sf == STRFMT_LIT ? 0 : J->base[arg++];
  974.     TRef trsf = lj_ir_kint(J, (int32_t)sf);
  975.     IRCallID id;
  976.     switch (STRFMT_TYPE(sf)) {
  977.     case STRFMT_LIT:
  978.       tr = emitir(IRT(IR_BUFPUT, IRT_P32), tr,
  979.                   lj_ir_kstr(J, lj_str_new(J->L, fs.str, fs.len)));
  980.       break;
  981.     case STRFMT_INT:
  982.       id = IRCALL_lj_strfmt_putfnum_int;
  983.     handle_int:
  984.       if (!tref_isinteger(tra))
  985.         goto handle_num;
  986.       if (sf == STRFMT_INT) { /* Shortcut for plain %d. */
  987.         tr = emitir(IRT(IR_BUFPUT, IRT_P32), tr,
  988.                     emitir(IRT(IR_TOSTR, IRT_STR), tra, IRTOSTR_INT));
  989.       } else {
  990. #if LJ_HASFFI
  991.         tra = emitir(IRT(IR_CONV, IRT_U64), tra,
  992.                      (IRT_INT|(IRT_U64<<5)|IRCONV_SEXT));
  993.         tr = lj_ir_call(J, IRCALL_lj_strfmt_putfxint, tr, trsf, tra);
  994.         lj_needsplit(J);
  995. #else
  996.         recff_nyiu(J, rd);  /* Don't bother working around this NYI. */
  997.         return;
  998. #endif
  999.       }
  1000.       break;
  1001.     case STRFMT_UINT:
  1002.       id = IRCALL_lj_strfmt_putfnum_uint;
  1003.       goto handle_int;
  1004.     case STRFMT_NUM:
  1005.       id = IRCALL_lj_strfmt_putfnum;
  1006.     handle_num:
  1007.       tra = lj_ir_tonum(J, tra);
  1008.       tr = lj_ir_call(J, id, tr, trsf, tra);
  1009.       if (LJ_SOFTFP) lj_needsplit(J);
  1010.       break;
  1011.     case STRFMT_STR:
  1012.       if (!tref_isstr(tra)) {
  1013.         recff_nyiu(J, rd);  /* NYI: __tostring and non-string types for %s. */
  1014.         return;
  1015.       }
  1016.       if (sf == STRFMT_STR)  /* Shortcut for plain %s. */
  1017.         tr = emitir(IRT(IR_BUFPUT, IRT_P32), tr, tra);
  1018.       else if ((sf & STRFMT_T_QUOTED))
  1019.         tr = lj_ir_call(J, IRCALL_lj_strfmt_putquoted, tr, tra);
  1020.       else
  1021.         tr = lj_ir_call(J, IRCALL_lj_strfmt_putfstr, tr, trsf, tra);
  1022.       break;
  1023.     case STRFMT_CHAR:
  1024.       tra = lj_opt_narrow_toint(J, tra);
  1025.       if (sf == STRFMT_CHAR)  /* Shortcut for plain %c. */
  1026.         tr = emitir(IRT(IR_BUFPUT, IRT_P32), tr,
  1027.                     emitir(IRT(IR_TOSTR, IRT_STR), tra, IRTOSTR_CHAR));
  1028.       else
  1029.         tr = lj_ir_call(J, IRCALL_lj_strfmt_putfchar, tr, trsf, tra);
  1030.       break;
  1031.     case STRFMT_PTR:  /* NYI */
  1032.     case STRFMT_ERR:
  1033.     default:
  1034.       recff_nyiu(J, rd);
  1035.       return;
  1036.     }
  1037.   }
  1038.   J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
  1039. }

  1041. /* -- Table library fast functions ---------------------------------------- */

  1043. ‌static void LJ_FASTCALL recff_table_insert(jit_State *J, RecordFFData *rd)
  1044. {
  1045.   RecordIndex ix;
  1046.   ix.tab = J->base[0];
  1047.   ix.val = J->base[1];
  1048.   rd->nres = 0;
  1049.   if (tref_istab(ix.tab) && ix.val) {
  1050.     if (!J->base[2]) {  /* Simple push: t[#t+1] = v */
  1051.       TRef trlen = lj_ir_call(J, IRCALL_lj_tab_len, ix.tab);
  1052.       GCtab *t = tabV(&rd->argv[0]);
  1053.       ix.key = emitir(IRTI(IR_ADD), trlen, lj_ir_kint(J, 1));
  1054.       settabV(J->L, &ix.tabv, t);
  1055.       setintV(&ix.keyv, lj_tab_len(t) + 1);
  1056.       ix.idxchain = 0;
  1057.       lj_record_idx(J, &ix);  /* Set new value. */
  1058.     } else {  /* Complex case: insert in the middle. */
  1059.       recff_nyiu(J, rd);
  1060.       return;
  1061.     }
  1062.   }  /* else: Interpreter will throw. */
  1063. }

  1065. ‌static void LJ_FASTCALL recff_table_concat(jit_State *J, RecordFFData *rd)
  1066. {
  1067.   TRef tab = J->base[0];
  1068.   if (tref_istab(tab)) {
  1069.     TRef sep = !tref_isnil(J->base[1]) ?
  1070.                lj_ir_tostr(J, J->base[1]) : lj_ir_knull(J, IRT_STR);
  1071.     TRef tri = (J->base[1] && !tref_isnil(J->base[2])) ?
  1072.                lj_opt_narrow_toint(J, J->base[2]) : lj_ir_kint(J, 1);
  1073.     TRef tre = (J->base[1] && J->base[2] && !tref_isnil(J->base[3])) ?
  1074.                lj_opt_narrow_toint(J, J->base[3]) :
  1075.                lj_ir_call(J, IRCALL_lj_tab_len, tab);
  1076.     TRef hdr = recff_bufhdr(J);
  1077.     TRef tr = lj_ir_call(J, IRCALL_lj_buf_puttab, hdr, tab, sep, tri, tre);
  1078.     emitir(IRTG(IR_NE, IRT_PTR), tr, lj_ir_kptr(J, NULL));
  1079.     J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
  1080.   }  /* else: Interpreter will throw. */
  1081.   UNUSED(rd);
  1082. }

  1084. ‌static void LJ_FASTCALL recff_table_new(jit_State *J, RecordFFData *rd)
  1085. {
  1086.   TRef tra = lj_opt_narrow_toint(J, J->base[0]);
  1087.   TRef trh = lj_opt_narrow_toint(J, J->base[1]);
  1088.   J->base[0] = lj_ir_call(J, IRCALL_lj_tab_new_ah, tra, trh);
  1089.   UNUSED(rd);
  1090. }

  1092. ‌static void LJ_FASTCALL recff_table_clear(jit_State *J, RecordFFData *rd)
  1093. {
  1094.   TRef tr = J->base[0];
  1095.   if (tref_istab(tr)) {
  1096.     rd->nres = 0;
  1097.     lj_ir_call(J, IRCALL_lj_tab_clear, tr);
  1098.     J->needsnap = 1;
  1099.   }  /* else: Interpreter will throw. */
  1100. }

  1102. /* -- I/O library fast functions ------------------------------------------ */

  1104. /* Get FILE* for I/O function. Any I/O error aborts recording, so there's
  1105. ** no need to encode the alternate cases for any of the guards.
  1106. */
  1107. ‌static TRef recff_io_fp(jit_State *J, TRef *udp, int32_t id)
  1108. {
  1109.   TRef tr, ud, fp;
  1110.   if (id) {  /* io.func() */
  1111.     tr = lj_ir_kptr(J, &J2G(J)->gcroot[id]);
  1112.     ud = emitir(IRT(IR_XLOAD, IRT_UDATA), tr, 0);
  1113.   } else {  /* fp:method() */
  1114.     ud = J->base[0];
  1115.     if (!tref_isudata(ud))
  1116.       lj_trace_err(J, LJ_TRERR_BADTYPE);
  1117.     tr = emitir(IRT(IR_FLOAD, IRT_U8), ud, IRFL_UDATA_UDTYPE);
  1118.     emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, UDTYPE_IO_FILE));
  1119.   }
  1120.   *udp = ud;
  1121.   fp = emitir(IRT(IR_FLOAD, IRT_PTR), ud, IRFL_UDATA_FILE);
  1122.   emitir(IRTG(IR_NE, IRT_PTR), fp, lj_ir_knull(J, IRT_PTR));
  1123.   return fp;
  1124. }

  1126. ‌static void LJ_FASTCALL recff_io_write(jit_State *J, RecordFFData *rd)
  1127. {
  1128.   TRef ud, fp = recff_io_fp(J, &ud, rd->data);
  1129.   TRef zero = lj_ir_kint(J, 0);
  1130.   TRef one = lj_ir_kint(J, 1);
  1131.   ptrdiff_t i = rd->data == 0 ? 1 : 0;
  1132.   for (; J->base[i]; i++) {
  1133.     TRef str = lj_ir_tostr(J, J->base[i]);
  1134.     TRef buf = emitir(IRT(IR_STRREF, IRT_P32), str, zero);
  1135.     TRef len = emitir(IRTI(IR_FLOAD), str, IRFL_STR_LEN);
  1136.     if (tref_isk(len) && IR(tref_ref(len))->i == 1) {
  1137.       IRIns *irs = IR(tref_ref(str));
  1138.       TRef tr = (irs->o == IR_TOSTR && irs->op2 == IRTOSTR_CHAR) ?
  1139.                 irs->op1 :
  1140.                 emitir(IRT(IR_XLOAD, IRT_U8), buf, IRXLOAD_READONLY);
  1141.       tr = lj_ir_call(J, IRCALL_fputc, tr, fp);
  1142.       if (results_wanted(J) != 0)  /* Check result only if not ignored. */
  1143.         emitir(IRTGI(IR_NE), tr, lj_ir_kint(J, -1));
  1144.     } else {
  1145.       TRef tr = lj_ir_call(J, IRCALL_fwrite, buf, one, len, fp);
  1146.       if (results_wanted(J) != 0)  /* Check result only if not ignored. */
  1147.         emitir(IRTGI(IR_EQ), tr, len);
  1148.     }
  1149.   }
  1150.   J->base[0] = LJ_52 ? ud : TREF_TRUE;
  1151. }

  1153. ‌static void LJ_FASTCALL recff_io_flush(jit_State *J, RecordFFData *rd)
  1154. {
  1155.   TRef ud, fp = recff_io_fp(J, &ud, rd->data);
  1156.   TRef tr = lj_ir_call(J, IRCALL_fflush, fp);
  1157.   if (results_wanted(J) != 0)  /* Check result only if not ignored. */
  1158.     emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, 0));
  1159.   J->base[0] = TREF_TRUE;
  1160. }

  1162. /* -- Debug library fast functions ---------------------------------------- */

  1164. ‌static void LJ_FASTCALL recff_debug_getmetatable(jit_State *J, RecordFFData *rd)
  1165. {
  1166.   GCtab *mt;
  1167.   TRef mtref;
  1168.   TRef tr = J->base[0];
  1169.   if (tref_istab(tr)) {
  1170.     mt = tabref(tabV(&rd->argv[0])->metatable);
  1171.     mtref = emitir(IRT(IR_FLOAD, IRT_TAB), tr, IRFL_TAB_META);
  1172.   } else if (tref_isudata(tr)) {
  1173.     mt = tabref(udataV(&rd->argv[0])->metatable);
  1174.     mtref = emitir(IRT(IR_FLOAD, IRT_TAB), tr, IRFL_UDATA_META);
  1175.   } else {
  1176.     mt = tabref(basemt_obj(J2G(J), &rd->argv[0]));
  1177.     J->base[0] = mt ? lj_ir_ktab(J, mt) : TREF_NIL;
  1178.     return;
  1179.   }
  1180.   emitir(IRTG(mt ? IR_NE : IR_EQ, IRT_TAB), mtref, lj_ir_knull(J, IRT_TAB));
  1181.   J->base[0] = mt ? mtref : TREF_NIL;
  1182. }

  1184. /* -- Record calls to fast functions -------------------------------------- */

  1186. #include "lj_recdef.h"

  1188. ‌static uint32_t recdef_lookup(GCfunc *fn)
  1189. {
  1190.   if (fn->c.ffid < sizeof(recff_idmap)/sizeof(recff_idmap[0]))
  1191.     return recff_idmap[fn->c.ffid];
  1192.   else
  1193.     return 0;
  1194. }

  1196. /* Record entry to a fast function or C function. */
  1197. ‌void lj_ffrecord_func(jit_State *J)
  1198. {
  1199.   RecordFFData rd;
  1200.   uint32_t m = recdef_lookup(J->fn);
  1201.   rd.data = m & 0xff;
  1202.   rd.nres = 1;  /* Default is one result. */
  1203.   rd.argv = J->L->base;
  1204.   J->base[J->maxslot] = 0;  /* Mark end of arguments. */
  1205.   (recff_func[m >> 8])(J, &rd);  /* Call recff_* handler. */
  1206.   if (rd.nres >= 0) {
  1207.     if (J->postproc == LJ_POST_NONE) J->postproc = LJ_POST_FFRETRY;
  1208.     lj_record_ret(J, 0, rd.nres);
  1209.   }
  1210. }

  1212. ‌#undef IR
  1213. ‌#undef emitir

  1215. #endif

One Level Up Top Level