src/lj_ffrecord.c

   1 /*
   2 ** Fast function call recorder.
   3 ** Copyright (C) 2005-2012 Mike Pall. See Copyright Notice in luajit.h
   4 */
   5
   6 #define lj_ffrecord_c
   7 #define LUA_CORE
   8
   9 #include "lj_obj.h"
  10
  11 #if LJ_HASJIT
  12
  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
  30 /* Some local macros to save typing. Undef'd at the end. */
  31 #define IR(ref)                 (&J->cur.ir[(ref)])
  32
  33 /* Pass IR on to next optimization in chain (FOLD). */
  34 #define emitir(ot, a, b)        (lj_ir_set(J, (ot), (a), (b)), lj_opt_fold(J))
  35
  36 /* -- Fast function recording handlers ------------------------------------ */
  37
  38 /* Conventions for fast function call handlers:
  39 **
  40 ** The argument slots start at J->base[0]. All of them are guaranteed to be
  41 ** valid and type-specialized references. J->base[J->maxslot] is set to 0
  42 ** as a sentinel. The runtime argument values start at rd->argv[0].
  43 **
  44 ** In general fast functions should check for presence of all of their
  45 ** arguments and for the correct argument types. Some simplifications
  46 ** are allowed if the interpreter throws instead. But even if recording
  47 ** is aborted, the generated IR must be consistent (no zero-refs).
  48 **
  49 ** The number of results in rd->nres is set to 1. Handlers that return
  50 ** a different number of results need to override it. A negative value
  51 ** prevents return processing (e.g. for pending calls).
  52 **
  53 ** Results need to be stored starting at J->base[0]. Return processing
  54 ** moves them to the right slots later.
  55 **
  56 ** The per-ffid auxiliary data is the value of the 2nd part of the
  57 ** LJLIB_REC() annotation. This allows handling similar functionality
  58 ** in a common handler.
  59 */
  60
  61 /* Type of handler to record a fast function. */
  62 typedef void (LJ_FASTCALL *RecordFunc)(jit_State *J, RecordFFData *rd);
  63
  64 /* Get runtime value of int argument. */
  65 static int32_t argv2int(jit_State *J, TValue *o)
  66 {
  67   if (!tvisnumber(o) && !(tvisstr(o) && lj_str_tonumber(strV(o), o)))
  68     lj_trace_err(J, LJ_TRERR_BADTYPE);
  69   return tvisint(o) ? intV(o) : lj_num2int(numV(o));
  70 }
  71
  72 /* Get runtime value of string argument. */
  73 static GCstr *argv2str(jit_State *J, TValue *o)
  74 {
  75   if (LJ_LIKELY(tvisstr(o))) {
  76     return strV(o);
  77   } else {
  78     GCstr *s;
  79     if (!tvisnumber(o))
  80       lj_trace_err(J, LJ_TRERR_BADTYPE);
  81     if (tvisint(o))
  82       s = lj_str_fromint(J->L, intV(o));
  83     else
  84       s = lj_str_fromnum(J->L, &o->n);
  85     setstrV(J->L, o, s);
  86     return s;
  87   }
  88 }
  89
  90 /* Return number of results wanted by caller. */
  91 static ptrdiff_t results_wanted(jit_State *J)
  92 {
  93   TValue *frame = J->L->base-1;
  94   if (frame_islua(frame))
  95     return (ptrdiff_t)bc_b(frame_pc(frame)[-1]) - 1;
  96   else
  97     return -1;
  98 }
  99
 100 /* Throw error for unsupported variant of fast function. */
 101 LJ_NORET static void recff_nyiu(jit_State *J)
 102 {
 103   setfuncV(J->L, &J->errinfo, J->fn);
 104   lj_trace_err_info(J, LJ_TRERR_NYIFFU);
 105 }
 106
 107 /* Fallback handler for all fast functions that are not recorded (yet). */
 108 static void LJ_FASTCALL recff_nyi(jit_State *J, RecordFFData *rd)
 109 {
 110   setfuncV(J->L, &J->errinfo, J->fn);
 111   lj_trace_err_info(J, LJ_TRERR_NYIFF);
 112   UNUSED(rd);
 113 }
 114
 115 /* C functions can have arbitrary side-effects and are not recorded (yet). */
 116 static void LJ_FASTCALL recff_c(jit_State *J, RecordFFData *rd)
 117 {
 118   setfuncV(J->L, &J->errinfo, J->fn);
 119   lj_trace_err_info(J, LJ_TRERR_NYICF);
 120   UNUSED(rd);
 121 }
 122
 123 /* -- Base library fast functions ----------------------------------------- */
 124
 125 static void LJ_FASTCALL recff_assert(jit_State *J, RecordFFData *rd)
 126 {
 127   /* Arguments already specialized. The interpreter throws for nil/false. */
 128   rd->nres = J->maxslot;  /* Pass through all arguments. */
 129 }
 130
 131 static void LJ_FASTCALL recff_type(jit_State *J, RecordFFData *rd)
 132 {
 133   /* Arguments already specialized. Result is a constant string. Neat, huh? */
 134   uint32_t t;
 135   if (tvisnumber(&rd->argv[0]))
 136     t = ~LJ_TNUMX;
 137   else if (LJ_64 && tvislightud(&rd->argv[0]))
 138     t = ~LJ_TLIGHTUD;
 139   else
 140     t = ~itype(&rd->argv[0]);
 141   J->base[0] = lj_ir_kstr(J, strV(&J->fn->c.upvalue[t]));
 142   UNUSED(rd);
 143 }
 144
 145 static void LJ_FASTCALL recff_getmetatable(jit_State *J, RecordFFData *rd)
 146 {
 147   TRef tr = J->base[0];
 148   if (tr) {
 149     RecordIndex ix;
 150     ix.tab = tr;
 151     copyTV(J->L, &ix.tabv, &rd->argv[0]);
 152     if (lj_record_mm_lookup(J, &ix, MM_metatable))
 153       J->base[0] = ix.mobj;
 154     else
 155       J->base[0] = ix.mt;
 156   }  /* else: Interpreter will throw. */
 157 }
 158
 159 static void LJ_FASTCALL recff_setmetatable(jit_State *J, RecordFFData *rd)
 160 {
 161   TRef tr = J->base[0];
 162   TRef mt = J->base[1];
 163   if (tref_istab(tr) && (tref_istab(mt) || (mt && tref_isnil(mt)))) {
 164     TRef fref, mtref;
 165     RecordIndex ix;
 166     ix.tab = tr;
 167     copyTV(J->L, &ix.tabv, &rd->argv[0]);
 168     lj_record_mm_lookup(J, &ix, MM_metatable); /* Guard for no __metatable. */
 169     fref = emitir(IRT(IR_FREF, IRT_P32), tr, IRFL_TAB_META);
 170     mtref = tref_isnil(mt) ? lj_ir_knull(J, IRT_TAB) : mt;
 171     emitir(IRT(IR_FSTORE, IRT_TAB), fref, mtref);
 172     if (!tref_isnil(mt))
 173       emitir(IRT(IR_TBAR, IRT_TAB), tr, 0);
 174     J->base[0] = tr;
 175     J->needsnap = 1;
 176   }  /* else: Interpreter will throw. */
 177 }
 178
 179 static void LJ_FASTCALL recff_rawget(jit_State *J, RecordFFData *rd)
 180 {
 181   RecordIndex ix;
 182   ix.tab = J->base[0]; ix.key = J->base[1];
 183   if (tref_istab(ix.tab) && ix.key) {
 184     ix.val = 0; ix.idxchain = 0;
 185     settabV(J->L, &ix.tabv, tabV(&rd->argv[0]));
 186     copyTV(J->L, &ix.keyv, &rd->argv[1]);
 187     J->base[0] = lj_record_idx(J, &ix);
 188   }  /* else: Interpreter will throw. */
 189 }
 190
 191 static void LJ_FASTCALL recff_rawset(jit_State *J, RecordFFData *rd)
 192 {
 193   RecordIndex ix;
 194   ix.tab = J->base[0]; ix.key = J->base[1]; ix.val = J->base[2];
 195   if (tref_istab(ix.tab) && ix.key && ix.val) {
 196     ix.idxchain = 0;
 197     settabV(J->L, &ix.tabv, tabV(&rd->argv[0]));
 198     copyTV(J->L, &ix.keyv, &rd->argv[1]);
 199     copyTV(J->L, &ix.valv, &rd->argv[2]);
 200     lj_record_idx(J, &ix);
 201     /* Pass through table at J->base[0] as result. */
 202   }  /* else: Interpreter will throw. */
 203 }
 204
 205 static void LJ_FASTCALL recff_rawequal(jit_State *J, RecordFFData *rd)
 206 {
 207   TRef tra = J->base[0];
 208   TRef trb = J->base[1];
 209   if (tra && trb) {
 210     int diff = lj_record_objcmp(J, tra, trb, &rd->argv[0], &rd->argv[1]);
 211     J->base[0] = diff ? TREF_FALSE : TREF_TRUE;
 212   }  /* else: Interpreter will throw. */
 213 }
 214
 215 /* Determine mode of select() call. */
 216 int32_t lj_ffrecord_select_mode(jit_State *J, TRef tr, TValue *tv)
 217 {
 218   if (tref_isstr(tr) && *strVdata(tv) == '#') {  /* select('#', ...) */
 219     if (strV(tv)->len == 1) {
 220       emitir(IRTG(IR_EQ, IRT_STR), tr, lj_ir_kstr(J, strV(tv)));
 221     } else {
 222       TRef trptr = emitir(IRT(IR_STRREF, IRT_P32), tr, lj_ir_kint(J, 0));
 223       TRef trchar = emitir(IRT(IR_XLOAD, IRT_U8), trptr, IRXLOAD_READONLY);
 224       emitir(IRTG(IR_EQ, IRT_INT), trchar, lj_ir_kint(J, '#'));
 225     }
 226     return 0;
 227   } else {  /* select(n, ...) */
 228     int32_t start = argv2int(J, tv);
 229     if (start == 0) lj_trace_err(J, LJ_TRERR_BADTYPE);  /* A bit misleading. */
 230     return start;
 231   }
 232 }
 233
 234 static void LJ_FASTCALL recff_select(jit_State *J, RecordFFData *rd)
 235 {
 236   TRef tr = J->base[0];
 237   if (tr) {
 238     ptrdiff_t start = lj_ffrecord_select_mode(J, tr, &rd->argv[0]);
 239     if (start == 0) {  /* select('#', ...) */
 240       J->base[0] = lj_ir_kint(J, J->maxslot - 1);
 241     } else if (tref_isk(tr)) {  /* select(k, ...) */
 242       ptrdiff_t n = (ptrdiff_t)J->maxslot;
 243       if (start < 0) start += n;
 244       else if (start > n) start = n;
 245       rd->nres = n - start;
 246       if (start >= 1) {
 247         ptrdiff_t i;
 248         for (i = 0; i < n - start; i++)
 249           J->base[i] = J->base[start+i];
 250       }  /* else: Interpreter will throw. */
 251     } else {
 252       recff_nyiu(J);
 253     }
 254   }  /* else: Interpreter will throw. */
 255 }
 256
 257 static void LJ_FASTCALL recff_tonumber(jit_State *J, RecordFFData *rd)
 258 {
 259   TRef tr = J->base[0];
 260   TRef base = J->base[1];
 261   if (tr && base) {
 262     base = lj_opt_narrow_toint(J, base);
 263     if (!tref_isk(base) || IR(tref_ref(base))->i != 10)
 264       recff_nyiu(J);
 265   }
 266   if (tref_isnumber_str(tr)) {
 267     if (tref_isstr(tr)) {
 268       TValue tmp;
 269       if (!lj_str_tonum(strV(&rd->argv[0]), &tmp))
 270         recff_nyiu(J);  /* Would need an inverted STRTO for this case. */
 271       tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
 272     }
 273 #if LJ_HASFFI
 274   } else if (tref_iscdata(tr)) {
 275     lj_crecord_tonumber(J, rd);
 276     return;
 277 #endif
 278   } else {
 279     tr = TREF_NIL;
 280   }
 281   J->base[0] = tr;
 282   UNUSED(rd);
 283 }
 284
 285 static TValue *recff_metacall_cp(lua_State *L, lua_CFunction dummy, void *ud)
 286 {
 287   jit_State *J = (jit_State *)ud;
 288   lj_record_tailcall(J, 0, 1);
 289   UNUSED(L); UNUSED(dummy);
 290   return NULL;
 291 }
 292
 293 static int recff_metacall(jit_State *J, RecordFFData *rd, MMS mm)
 294 {
 295   RecordIndex ix;
 296   ix.tab = J->base[0];
 297   copyTV(J->L, &ix.tabv, &rd->argv[0]);
 298   if (lj_record_mm_lookup(J, &ix, mm)) {  /* Has metamethod? */
 299     int errcode;
 300     TValue argv0;
 301     /* Temporarily insert metamethod below object. */
 302     J->base[1] = J->base[0];
 303     J->base[0] = ix.mobj;
 304     copyTV(J->L, &argv0, &rd->argv[0]);
 305     copyTV(J->L, &rd->argv[1], &rd->argv[0]);
 306     copyTV(J->L, &rd->argv[0], &ix.mobjv);
 307     /* Need to protect lj_record_tailcall because it may throw. */
 308     errcode = lj_vm_cpcall(J->L, NULL, J, recff_metacall_cp);
 309     /* Always undo Lua stack changes to avoid confusing the interpreter. */
 310     copyTV(J->L, &rd->argv[0], &argv0);
 311     if (errcode)
 312       lj_err_throw(J->L, errcode);  /* Propagate errors. */
 313     rd->nres = -1;  /* Pending call. */
 314     return 1;  /* Tailcalled to metamethod. */
 315   }
 316   return 0;
 317 }
 318
 319 static void LJ_FASTCALL recff_tostring(jit_State *J, RecordFFData *rd)
 320 {
 321   TRef tr = J->base[0];
 322   if (tref_isstr(tr)) {
 323     /* Ignore __tostring in the string base metatable. */
 324     /* Pass on result in J->base[0]. */
 325   } else if (!recff_metacall(J, rd, MM_tostring)) {
 326     if (tref_isnumber(tr)) {
 327       J->base[0] = emitir(IRT(IR_TOSTR, IRT_STR), tr, 0);
 328     } else if (tref_ispri(tr)) {
 329       J->base[0] = lj_ir_kstr(J, strV(&J->fn->c.upvalue[tref_type(tr)]));
 330     } else {
 331       recff_nyiu(J);
 332     }
 333   }
 334 }
 335
 336 static void LJ_FASTCALL recff_ipairs_aux(jit_State *J, RecordFFData *rd)
 337 {
 338   RecordIndex ix;
 339   ix.tab = J->base[0];
 340   if (tref_istab(ix.tab)) {
 341     if (!tvisnumber(&rd->argv[1]))  /* No support for string coercion. */
 342       lj_trace_err(J, LJ_TRERR_BADTYPE);
 343     setintV(&ix.keyv, numberVint(&rd->argv[1])+1);
 344     settabV(J->L, &ix.tabv, tabV(&rd->argv[0]));
 345     ix.val = 0; ix.idxchain = 0;
 346     ix.key = lj_opt_narrow_toint(J, J->base[1]);
 347     J->base[0] = ix.key = emitir(IRTI(IR_ADD), ix.key, lj_ir_kint(J, 1));
 348     J->base[1] = lj_record_idx(J, &ix);
 349     rd->nres = tref_isnil(J->base[1]) ? 0 : 2;
 350   }  /* else: Interpreter will throw. */
 351 }
 352
 353 static void LJ_FASTCALL recff_ipairs(jit_State *J, RecordFFData *rd)
 354 {
 355 #ifdef LUAJIT_ENABLE_LUA52COMPAT
 356   if (!recff_metacall(J, rd, MM_ipairs))
 357 #endif
 358   {
 359     TRef tab = J->base[0];
 360     if (tref_istab(tab)) {
 361       J->base[0] = lj_ir_kfunc(J, funcV(&J->fn->c.upvalue[0]));
 362       J->base[1] = tab;
 363       J->base[2] = lj_ir_kint(J, 0);
 364       rd->nres = 3;
 365     }  /* else: Interpreter will throw. */
 366   }
 367 }
 368
 369 static void LJ_FASTCALL recff_pcall(jit_State *J, RecordFFData *rd)
 370 {
 371   if (J->maxslot >= 1) {
 372     lj_record_call(J, 0, J->maxslot - 1);
 373     rd->nres = -1;  /* Pending call. */
 374   }  /* else: Interpreter will throw. */
 375 }
 376
 377 static TValue *recff_xpcall_cp(lua_State *L, lua_CFunction dummy, void *ud)
 378 {
 379   jit_State *J = (jit_State *)ud;
 380   lj_record_call(J, 1, J->maxslot - 2);
 381   UNUSED(L); UNUSED(dummy);
 382   return NULL;
 383 }
 384
 385 static void LJ_FASTCALL recff_xpcall(jit_State *J, RecordFFData *rd)
 386 {
 387   if (J->maxslot >= 2) {
 388     TValue argv0, argv1;
 389     TRef tmp;
 390     int errcode;
 391     /* Swap function and traceback. */
 392     tmp = J->base[0]; J->base[0] = J->base[1]; J->base[1] = tmp;
 393     copyTV(J->L, &argv0, &rd->argv[0]);
 394     copyTV(J->L, &argv1, &rd->argv[1]);
 395     copyTV(J->L, &rd->argv[0], &argv1);
 396     copyTV(J->L, &rd->argv[1], &argv0);
 397     /* Need to protect lj_record_call because it may throw. */
 398     errcode = lj_vm_cpcall(J->L, NULL, J, recff_xpcall_cp);
 399     /* Always undo Lua stack swap to avoid confusing the interpreter. */
 400     copyTV(J->L, &rd->argv[0], &argv0);
 401     copyTV(J->L, &rd->argv[1], &argv1);
 402     if (errcode)
 403       lj_err_throw(J->L, errcode);  /* Propagate errors. */
 404     rd->nres = -1;  /* Pending call. */
 405   }  /* else: Interpreter will throw. */
 406 }
 407
 408 /* -- Math library fast functions ----------------------------------------- */
 409
 410 static void LJ_FASTCALL recff_math_abs(jit_State *J, RecordFFData *rd)
 411 {
 412   TRef tr = lj_ir_tonum(J, J->base[0]);
 413   J->base[0] = emitir(IRTN(IR_ABS), tr, lj_ir_knum_abs(J));
 414   UNUSED(rd);
 415 }
 416
 417 /* Record rounding functions math.floor and math.ceil. */
 418 static void LJ_FASTCALL recff_math_round(jit_State *J, RecordFFData *rd)
 419 {
 420   TRef tr = J->base[0];
 421   if (!tref_isinteger(tr)) {  /* Pass through integers unmodified. */
 422     tr = emitir(IRTN(IR_FPMATH), lj_ir_tonum(J, tr), rd->data);
 423     /* Result is integral (or NaN/Inf), but may not fit an int32_t. */
 424     if (LJ_DUALNUM) {  /* Try to narrow using a guarded conversion to int. */
 425       lua_Number n = lj_vm_foldfpm(numberVnum(&rd->argv[0]), rd->data);
 426       if (n == (lua_Number)lj_num2int(n))
 427         tr = emitir(IRTGI(IR_CONV), tr, IRCONV_INT_NUM|IRCONV_CHECK);
 428     }
 429     J->base[0] = tr;
 430   }
 431 }
 432
 433 /* Record unary math.* functions, mapped to IR_FPMATH opcode. */
 434 static void LJ_FASTCALL recff_math_unary(jit_State *J, RecordFFData *rd)
 435 {
 436   J->base[0] = emitir(IRTN(IR_FPMATH), lj_ir_tonum(J, J->base[0]), rd->data);
 437 }
 438
 439 /* Record math.atan2. */
 440 static void LJ_FASTCALL recff_math_atan2(jit_State *J, RecordFFData *rd)
 441 {
 442   TRef tr = lj_ir_tonum(J, J->base[0]);
 443   TRef tr2 = lj_ir_tonum(J, J->base[1]);
 444   J->base[0] = emitir(IRTN(IR_ATAN2), tr, tr2);
 445   UNUSED(rd);
 446 }
 447
 448 /* Record math.ldexp. */
 449 static void LJ_FASTCALL recff_math_ldexp(jit_State *J, RecordFFData *rd)
 450 {
 451   TRef tr = lj_ir_tonum(J, J->base[0]);
 452 #if LJ_TARGET_X86ORX64
 453   TRef tr2 = lj_ir_tonum(J, J->base[1]);
 454 #else
 455   TRef tr2 = lj_opt_narrow_toint(J, J->base[1]);
 456 #endif
 457   J->base[0] = emitir(IRTN(IR_LDEXP), tr, tr2);
 458   UNUSED(rd);
 459 }
 460
 461 /* Record math.asin, math.acos, math.atan. */
 462 static void LJ_FASTCALL recff_math_atrig(jit_State *J, RecordFFData *rd)
 463 {
 464   TRef y = lj_ir_tonum(J, J->base[0]);
 465   TRef x = lj_ir_knum_one(J);
 466   uint32_t ffid = rd->data;
 467   if (ffid != FF_math_atan) {
 468     TRef tmp = emitir(IRTN(IR_MUL), y, y);
 469     tmp = emitir(IRTN(IR_SUB), x, tmp);
 470     tmp = emitir(IRTN(IR_FPMATH), tmp, IRFPM_SQRT);
 471     if (ffid == FF_math_asin) { x = tmp; } else { x = y; y = tmp; }
 472   }
 473   J->base[0] = emitir(IRTN(IR_ATAN2), y, x);
 474 }
 475
 476 static void LJ_FASTCALL recff_math_htrig(jit_State *J, RecordFFData *rd)
 477 {
 478   TRef tr = lj_ir_tonum(J, J->base[0]);
 479   J->base[0] = emitir(IRTN(IR_CALLN), tr, rd->data);
 480 }
 481
 482 static void LJ_FASTCALL recff_math_modf(jit_State *J, RecordFFData *rd)
 483 {
 484   TRef tr = J->base[0];
 485   if (tref_isinteger(tr)) {
 486     J->base[0] = tr;
 487     J->base[1] = lj_ir_kint(J, 0);
 488   } else {
 489     TRef trt;
 490     tr = lj_ir_tonum(J, tr);
 491     trt = emitir(IRTN(IR_FPMATH), tr, IRFPM_TRUNC);
 492     J->base[0] = trt;
 493     J->base[1] = emitir(IRTN(IR_SUB), tr, trt);
 494   }
 495   rd->nres = 2;
 496 }
 497
 498 static void LJ_FASTCALL recff_math_degrad(jit_State *J, RecordFFData *rd)
 499 {
 500   TRef tr = lj_ir_tonum(J, J->base[0]);
 501   TRef trm = lj_ir_knum(J, numV(&J->fn->c.upvalue[0]));
 502   J->base[0] = emitir(IRTN(IR_MUL), tr, trm);
 503   UNUSED(rd);
 504 }
 505
 506 static void LJ_FASTCALL recff_math_pow(jit_State *J, RecordFFData *rd)
 507 {
 508   TRef tr = lj_ir_tonum(J, J->base[0]);
 509   if (!tref_isnumber_str(J->base[1]))
 510     lj_trace_err(J, LJ_TRERR_BADTYPE);
 511   J->base[0] = lj_opt_narrow_pow(J, tr, J->base[1], &rd->argv[1]);
 512   UNUSED(rd);
 513 }
 514
 515 static void LJ_FASTCALL recff_math_minmax(jit_State *J, RecordFFData *rd)
 516 {
 517   TRef tr = lj_ir_tonumber(J, J->base[0]);
 518   uint32_t op = rd->data;
 519   BCReg i;
 520   for (i = 1; J->base[i] != 0; i++) {
 521     TRef tr2 = lj_ir_tonumber(J, J->base[i]);
 522     IRType t = IRT_INT;
 523     if (!(tref_isinteger(tr) && tref_isinteger(tr2))) {
 524       if (tref_isinteger(tr)) tr = emitir(IRTN(IR_CONV), tr, IRCONV_NUM_INT);
 525       if (tref_isinteger(tr2)) tr2 = emitir(IRTN(IR_CONV), tr2, IRCONV_NUM_INT);
 526       t = IRT_NUM;
 527     }
 528     tr = emitir(IRT(op, t), tr, tr2);
 529   }
 530   J->base[0] = tr;
 531 }
 532
 533 static void LJ_FASTCALL recff_math_random(jit_State *J, RecordFFData *rd)
 534 {
 535   GCudata *ud = udataV(&J->fn->c.upvalue[0]);
 536   TRef tr, one;
 537   lj_ir_kgc(J, obj2gco(ud), IRT_UDATA);  /* Prevent collection. */
 538   tr = lj_ir_call(J, IRCALL_lj_math_random_step, lj_ir_kptr(J, uddata(ud)));
 539   one = lj_ir_knum_one(J);
 540   tr = emitir(IRTN(IR_SUB), tr, one);
 541   if (J->base[0]) {
 542     TRef tr1 = lj_ir_tonum(J, J->base[0]);
 543     if (J->base[1]) {  /* d = floor(d*(r2-r1+1.0)) + r1 */
 544       TRef tr2 = lj_ir_tonum(J, J->base[1]);
 545       tr2 = emitir(IRTN(IR_SUB), tr2, tr1);
 546       tr2 = emitir(IRTN(IR_ADD), tr2, one);
 547       tr = emitir(IRTN(IR_MUL), tr, tr2);
 548       tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_FLOOR);
 549       tr = emitir(IRTN(IR_ADD), tr, tr1);
 550     } else {  /* d = floor(d*r1) + 1.0 */
 551       tr = emitir(IRTN(IR_MUL), tr, tr1);
 552       tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_FLOOR);
 553       tr = emitir(IRTN(IR_ADD), tr, one);
 554     }
 555   }
 556   J->base[0] = tr;
 557   UNUSED(rd);
 558 }
 559
 560 /* -- Bit library fast functions ------------------------------------------ */
 561
 562 /* Record unary bit.tobit, bit.bnot, bit.bswap. */
 563 static void LJ_FASTCALL recff_bit_unary(jit_State *J, RecordFFData *rd)
 564 {
 565   TRef tr = lj_opt_narrow_tobit(J, J->base[0]);
 566   J->base[0] = (rd->data == IR_TOBIT) ? tr : emitir(IRTI(rd->data), tr, 0);
 567 }
 568
 569 /* Record N-ary bit.band, bit.bor, bit.bxor. */
 570 static void LJ_FASTCALL recff_bit_nary(jit_State *J, RecordFFData *rd)
 571 {
 572   TRef tr = lj_opt_narrow_tobit(J, J->base[0]);
 573   uint32_t op = rd->data;
 574   BCReg i;
 575   for (i = 1; J->base[i] != 0; i++)
 576     tr = emitir(IRTI(op), tr, lj_opt_narrow_tobit(J, J->base[i]));
 577   J->base[0] = tr;
 578 }
 579
 580 /* Record bit shifts. */
 581 static void LJ_FASTCALL recff_bit_shift(jit_State *J, RecordFFData *rd)
 582 {
 583   TRef tr = lj_opt_narrow_tobit(J, J->base[0]);
 584   TRef tsh = lj_opt_narrow_tobit(J, J->base[1]);
 585   IROp op = (IROp)rd->data;
 586   if (!(op < IR_BROL ? LJ_TARGET_MASKSHIFT : LJ_TARGET_MASKROT) &&
 587       !tref_isk(tsh))
 588     tsh = emitir(IRTI(IR_BAND), tsh, lj_ir_kint(J, 31));
 589 #ifdef LJ_TARGET_UNIFYROT
 590   if (op == (LJ_TARGET_UNIFYROT == 1 ? IR_BROR : IR_BROL)) {
 591     op = LJ_TARGET_UNIFYROT == 1 ? IR_BROL : IR_BROR;
 592     tsh = emitir(IRTI(IR_NEG), tsh, tsh);
 593   }
 594 #endif
 595   J->base[0] = emitir(IRTI(op), tr, tsh);
 596 }
 597
 598 /* -- String library fast functions --------------------------------------- */
 599
 600 static void LJ_FASTCALL recff_string_len(jit_State *J, RecordFFData *rd)
 601 {
 602   J->base[0] = emitir(IRTI(IR_FLOAD), lj_ir_tostr(J, J->base[0]), IRFL_STR_LEN);
 603   UNUSED(rd);
 604 }
 605
 606 /* Handle string.byte (rd->data = 0) and string.sub (rd->data = 1). */
 607 static void LJ_FASTCALL recff_string_range(jit_State *J, RecordFFData *rd)
 608 {
 609   TRef trstr = lj_ir_tostr(J, J->base[0]);
 610   TRef trlen = emitir(IRTI(IR_FLOAD), trstr, IRFL_STR_LEN);
 611   TRef tr0 = lj_ir_kint(J, 0);
 612   TRef trstart, trend;
 613   GCstr *str = argv2str(J, &rd->argv[0]);
 614   int32_t start, end;
 615   if (rd->data) {  /* string.sub(str, start [,end]) */
 616     start = argv2int(J, &rd->argv[1]);
 617     trstart = lj_opt_narrow_toint(J, J->base[1]);
 618     trend = J->base[2];
 619     if (tref_isnil(trend)) {
 620       trend = lj_ir_kint(J, -1);
 621       end = -1;
 622     } else {
 623       trend = lj_opt_narrow_toint(J, trend);
 624       end = argv2int(J, &rd->argv[2]);
 625     }
 626   } else {  /* string.byte(str, [,start [,end]]) */
 627     if (J->base[1]) {
 628       start = argv2int(J, &rd->argv[1]);
 629       trstart = lj_opt_narrow_toint(J, J->base[1]);
 630       trend = J->base[2];
 631       if (tref_isnil(trend)) {
 632         trend = trstart;
 633         end = start;
 634       } else {
 635         trend = lj_opt_narrow_toint(J, trend);
 636         end = argv2int(J, &rd->argv[2]);
 637       }
 638     } else {
 639       trend = trstart = lj_ir_kint(J, 1);
 640       end = start = 1;
 641     }
 642   }
 643   if (end < 0) {
 644     emitir(IRTGI(IR_LT), trend, tr0);
 645     trend = emitir(IRTI(IR_ADD), emitir(IRTI(IR_ADD), trlen, trend),
 646                    lj_ir_kint(J, 1));
 647     end = end+(int32_t)str->len+1;
 648   } else if ((MSize)end <= str->len) {
 649     emitir(IRTGI(IR_ULE), trend, trlen);
 650   } else {
 651     emitir(IRTGI(IR_GT), trend, trlen);
 652     end = (int32_t)str->len;
 653     trend = trlen;
 654   }
 655   if (start < 0) {
 656     emitir(IRTGI(IR_LT), trstart, tr0);
 657     trstart = emitir(IRTI(IR_ADD), trlen, trstart);
 658     start = start+(int32_t)str->len;
 659     emitir(start < 0 ? IRTGI(IR_LT) : IRTGI(IR_GE), trstart, tr0);
 660     if (start < 0) {
 661       trstart = tr0;
 662       start = 0;
 663     }
 664   } else {
 665     if (start == 0) {
 666       emitir(IRTGI(IR_EQ), trstart, tr0);
 667       trstart = tr0;
 668     } else {
 669       trstart = emitir(IRTI(IR_ADD), trstart, lj_ir_kint(J, -1));
 670       emitir(IRTGI(IR_GE), trstart, tr0);
 671       start--;
 672     }
 673   }
 674   if (rd->data) {  /* Return string.sub result. */
 675     if (end - start >= 0) {
 676       /* Also handle empty range here, to avoid extra traces. */
 677       TRef trptr, trslen = emitir(IRTI(IR_SUB), trend, trstart);
 678       emitir(IRTGI(IR_GE), trslen, tr0);
 679       trptr = emitir(IRT(IR_STRREF, IRT_P32), trstr, trstart);
 680       J->base[0] = emitir(IRT(IR_SNEW, IRT_STR), trptr, trslen);
 681     } else {  /* Range underflow: return empty string. */
 682       emitir(IRTGI(IR_LT), trend, trstart);
 683       J->base[0] = lj_ir_kstr(J, lj_str_new(J->L, strdata(str), 0));
 684     }
 685   } else {  /* Return string.byte result(s). */
 686     ptrdiff_t i, len = end - start;
 687     if (len > 0) {
 688       TRef trslen = emitir(IRTI(IR_SUB), trend, trstart);
 689       emitir(IRTGI(IR_EQ), trslen, lj_ir_kint(J, (int32_t)len));
 690       if (J->baseslot + len > LJ_MAX_JSLOTS)
 691         lj_trace_err_info(J, LJ_TRERR_STACKOV);
 692       rd->nres = len;
 693       for (i = 0; i < len; i++) {
 694         TRef tmp = emitir(IRTI(IR_ADD), trstart, lj_ir_kint(J, (int32_t)i));
 695         tmp = emitir(IRT(IR_STRREF, IRT_P32), trstr, tmp);
 696         J->base[i] = emitir(IRT(IR_XLOAD, IRT_U8), tmp, IRXLOAD_READONLY);
 697       }
 698     } else {  /* Empty range or range underflow: return no results. */
 699       emitir(IRTGI(IR_LE), trend, trstart);
 700       rd->nres = 0;
 701     }
 702   }
 703 }
 704
 705 /* -- Table library fast functions ---------------------------------------- */
 706
 707 static void LJ_FASTCALL recff_table_getn(jit_State *J, RecordFFData *rd)
 708 {
 709   if (tref_istab(J->base[0]))
 710     J->base[0] = lj_ir_call(J, IRCALL_lj_tab_len, J->base[0]);
 711   /* else: Interpreter will throw. */
 712   UNUSED(rd);
 713 }
 714
 715 static void LJ_FASTCALL recff_table_remove(jit_State *J, RecordFFData *rd)
 716 {
 717   TRef tab = J->base[0];
 718   rd->nres = 0;
 719   if (tref_istab(tab)) {
 720     if (!J->base[1] || tref_isnil(J->base[1])) {  /* Simple pop: t[#t] = nil */
 721       TRef trlen = lj_ir_call(J, IRCALL_lj_tab_len, tab);
 722       GCtab *t = tabV(&rd->argv[0]);
 723       MSize len = lj_tab_len(t);
 724       emitir(IRTGI(len ? IR_NE : IR_EQ), trlen, lj_ir_kint(J, 0));
 725       if (len) {
 726         RecordIndex ix;
 727         ix.tab = tab;
 728         ix.key = trlen;
 729         settabV(J->L, &ix.tabv, t);
 730         setintV(&ix.keyv, len);
 731         ix.idxchain = 0;
 732         if (results_wanted(J) != 0) {  /* Specialize load only if needed. */
 733           ix.val = 0;
 734           J->base[0] = lj_record_idx(J, &ix);  /* Load previous value. */
 735           rd->nres = 1;
 736           /* Assumes ix.key/ix.tab is not modified for raw lj_record_idx(). */
 737         }
 738         ix.val = TREF_NIL;
 739         lj_record_idx(J, &ix);  /* Remove value. */
 740       }
 741     } else {  /* Complex case: remove in the middle. */
 742       recff_nyiu(J);
 743     }
 744   }  /* else: Interpreter will throw. */
 745 }
 746
 747 static void LJ_FASTCALL recff_table_insert(jit_State *J, RecordFFData *rd)
 748 {
 749   RecordIndex ix;
 750   ix.tab = J->base[0];
 751   ix.val = J->base[1];
 752   rd->nres = 0;
 753   if (tref_istab(ix.tab) && ix.val) {
 754     if (!J->base[2]) {  /* Simple push: t[#t+1] = v */
 755       TRef trlen = lj_ir_call(J, IRCALL_lj_tab_len, ix.tab);
 756       GCtab *t = tabV(&rd->argv[0]);
 757       ix.key = emitir(IRTI(IR_ADD), trlen, lj_ir_kint(J, 1));
 758       settabV(J->L, &ix.tabv, t);
 759       setintV(&ix.keyv, lj_tab_len(t) + 1);
 760       ix.idxchain = 0;
 761       lj_record_idx(J, &ix);  /* Set new value. */
 762     } else {  /* Complex case: insert in the middle. */
 763       recff_nyiu(J);
 764     }
 765   }  /* else: Interpreter will throw. */
 766 }
 767
 768 /* -- I/O library fast functions ------------------------------------------ */
 769
 770 /* Get FILE* for I/O function. Any I/O error aborts recording, so there's
 771 ** no need to encode the alternate cases for any of the guards.
 772 */
 773 static TRef recff_io_fp(jit_State *J, uint32_t id)
 774 {
 775   TRef tr, ud, fp;
 776   if (id) {  /* io.func() */
 777     tr = lj_ir_kptr(J, &J2G(J)->gcroot[id]);
 778     ud = emitir(IRT(IR_XLOAD, IRT_UDATA), tr, 0);
 779   } else {  /* fp:method() */
 780     ud = J->base[0];
 781     if (!tref_isudata(ud))
 782       lj_trace_err(J, LJ_TRERR_BADTYPE);
 783     tr = emitir(IRT(IR_FLOAD, IRT_U8), ud, IRFL_UDATA_UDTYPE);
 784     emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, UDTYPE_IO_FILE));
 785   }
 786   fp = emitir(IRT(IR_FLOAD, IRT_PTR), ud, IRFL_UDATA_FILE);
 787   emitir(IRTG(IR_NE, IRT_PTR), fp, lj_ir_knull(J, IRT_PTR));
 788   return fp;
 789 }
 790
 791 static void LJ_FASTCALL recff_io_write(jit_State *J, RecordFFData *rd)
 792 {
 793   TRef fp = recff_io_fp(J, rd->data);
 794   TRef zero = lj_ir_kint(J, 0);
 795   TRef one = lj_ir_kint(J, 1);
 796   ptrdiff_t i = rd->data == 0 ? 1 : 0;
 797   for (; J->base[i]; i++) {
 798     TRef str = lj_ir_tostr(J, J->base[i]);
 799     TRef buf = emitir(IRT(IR_STRREF, IRT_P32), str, zero);
 800     TRef len = emitir(IRTI(IR_FLOAD), str, IRFL_STR_LEN);
 801     if (tref_isk(len) && IR(tref_ref(len))->i == 1) {
 802       TRef tr = emitir(IRT(IR_XLOAD, IRT_U8), buf, IRXLOAD_READONLY);
 803       tr = lj_ir_call(J, IRCALL_fputc, tr, fp);
 804       if (results_wanted(J) != 0)  /* Check result only if not ignored. */
 805         emitir(IRTGI(IR_NE), tr, lj_ir_kint(J, -1));
 806     } else {
 807       TRef tr = lj_ir_call(J, IRCALL_fwrite, buf, one, len, fp);
 808       if (results_wanted(J) != 0)  /* Check result only if not ignored. */
 809         emitir(IRTGI(IR_EQ), tr, len);
 810     }
 811   }
 812   J->base[0] = TREF_TRUE;
 813 }
 814
 815 static void LJ_FASTCALL recff_io_flush(jit_State *J, RecordFFData *rd)
 816 {
 817   TRef fp = recff_io_fp(J, rd->data);
 818   TRef tr = lj_ir_call(J, IRCALL_fflush, fp);
 819   if (results_wanted(J) != 0)  /* Check result only if not ignored. */
 820     emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, 0));
 821   J->base[0] = TREF_TRUE;
 822 }
 823
 824 /* -- Record calls to fast functions -------------------------------------- */
 825
 826 #include "lj_recdef.h"
 827
 828 static uint32_t recdef_lookup(GCfunc *fn)
 829 {
 830   if (fn->c.ffid < sizeof(recff_idmap)/sizeof(recff_idmap[0]))
 831     return recff_idmap[fn->c.ffid];
 832   else
 833     return 0;
 834 }
 835
 836 /* Record entry to a fast function or C function. */
 837 void lj_ffrecord_func(jit_State *J)
 838 {
 839   RecordFFData rd;
 840   uint32_t m = recdef_lookup(J->fn);
 841   rd.data = m & 0xff;
 842   rd.nres = 1;  /* Default is one result. */
 843   rd.argv = J->L->base;
 844   J->base[J->maxslot] = 0;  /* Mark end of arguments. */
 845   (recff_func[m >> 8])(J, &rd);  /* Call recff_* handler. */
 846   if (rd.nres >= 0) {
 847     if (J->postproc == LJ_POST_NONE) J->postproc = LJ_POST_FFRETRY;
 848     lj_record_ret(J, 0, rd.nres);
 849   }
 850 }
 851
 852 #undef IR
 853 #undef emitir
 854
 855 #endif