emitir             42 lj_crecord.c     emitir(IRT(IR_CONV, (dt)), (a), (st)|((dt) << 5)|(flags))
emitir             54 lj_crecord.c     trtypeid = emitir(IRT(IR_FLOAD, IRT_U16), tr, IRFL_CDATA_CTYPEID);
emitir             55 lj_crecord.c     emitir(IRTG(IR_EQ, IRT_INT), trtypeid, lj_ir_kint(J, (int32_t)cd->ctypeid));
emitir             65 lj_crecord.c     tr = emitir(IRT(IR_FLOAD, IRT_INT), tr, IRFL_CDATA_INT);
emitir             66 lj_crecord.c     emitir(IRTG(IR_EQ, IRT_INT), tr, lj_ir_kint(J, (int32_t)id));
emitir             77 lj_crecord.c       emitir(IRTG(IR_EQ, IRT_STR), tr, lj_ir_kstr(J, s));
emitir            210 lj_crecord.c       TRef trsptr = emitir(IRT(IR_ADD, IRT_PTR), trsrc, trofs);
emitir            211 lj_crecord.c       ml[i].trval = emitir(IRT(IR_XLOAD, ml[i].tp), trsptr, 0);
emitir            218 lj_crecord.c   	TRef trdptr = emitir(IRT(IR_ADD, IRT_PTR), trdst, ml[j].trofs);
emitir            219 lj_crecord.c   	emitir(IRT(IR_XSTORE, ml[j].tp), trdptr, ml[j].trval);
emitir            264 lj_crecord.c   	emitir(IRT(IR_XBAR, IRT_NIL), 0, 0);
emitir            271 lj_crecord.c     emitir(IRT(IR_XBAR, IRT_NIL), 0, 0);
emitir            304 lj_crecord.c       TRef trdptr = emitir(IRT(IR_ADD, IRT_PTR), trdst, trofs);
emitir            305 lj_crecord.c       emitir(IRT(IR_XSTORE, ml[i].tp), trdptr, trfill);
emitir            329 lj_crecord.c   	trfill = emitir(IRT(IR_MUL, IRT_U64), trfill,
emitir            332 lj_crecord.c   	trfill = emitir(IRTI(IR_MUL), trfill,
emitir            342 lj_crecord.c     emitir(IRT(IR_XBAR, IRT_NIL), 0, 0);
emitir            415 lj_crecord.c         emitir(IRTG(isnz ? IR_NE : IR_EQ, st), sp, zero);
emitir            437 lj_crecord.c       emitir(IRT(IR_XSTORE, dt), dp, sp);
emitir            440 lj_crecord.c       sp = emitir(IRT(IR_XLOAD, st), sp, 0);  /* Load re. */
emitir            465 lj_crecord.c       sp = emitir(IRT(IR_XLOAD, st), sp, 0);  /* Load re. */
emitir            477 lj_crecord.c         TRef ptr = emitir(IRT(IR_ADD, IRT_PTR), dp, lj_ir_kintp(J, (dsize >> 1)));
emitir            478 lj_crecord.c         emitir(IRT(IR_XSTORE, dt), ptr, lj_ir_knum(J, 0));
emitir            487 lj_crecord.c         re = emitir(IRT(IR_XLOAD, st), sp, 0);
emitir            488 lj_crecord.c         ptr = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, (ssize >> 1)));
emitir            489 lj_crecord.c         im = emitir(IRT(IR_XLOAD, st), ptr, 0);
emitir            494 lj_crecord.c         emitir(IRT(IR_XSTORE, dt), dp, re);
emitir            495 lj_crecord.c         ptr = emitir(IRT(IR_ADD, IRT_PTR), dp, lj_ir_kintp(J, (dsize >> 1)));
emitir            496 lj_crecord.c         emitir(IRT(IR_XSTORE, dt), ptr, im);
emitir            555 lj_crecord.c       tr = emitir(IRT(IR_XLOAD, t), sp, 0);
emitir            570 lj_crecord.c       sp = emitir(IRT(IR_XLOAD, t), sp, 0);  /* Box pointers and enums. */
emitir            577 lj_crecord.c       dp = emitir(IRTG(IR_CNEW, IRT_CDATA), lj_ir_kint(J, sid), TREF_NIL);
emitir            578 lj_crecord.c       tr1 = emitir(IRT(IR_XLOAD, t), sp, 0);
emitir            579 lj_crecord.c       ptr = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, esz));
emitir            580 lj_crecord.c       tr2 = emitir(IRT(IR_XLOAD, t), ptr, 0);
emitir            581 lj_crecord.c       ptr = emitir(IRT(IR_ADD, IRT_PTR), dp, lj_ir_kintp(J, sizeof(GCcdata)));
emitir            582 lj_crecord.c       emitir(IRT(IR_XSTORE, t), ptr, tr1);
emitir            583 lj_crecord.c       ptr = emitir(IRT(IR_ADD, IRT_PTR), dp, lj_ir_kintp(J, sizeof(GCcdata)+esz));
emitir            584 lj_crecord.c       emitir(IRT(IR_XSTORE, t), ptr, tr2);
emitir            592 lj_crecord.c     return emitir(IRTG(IR_CNEWI, IRT_CDATA), lj_ir_kint(J, sid), sp);
emitir            617 lj_crecord.c         TRef tr = emitir(IRT(IR_FLOAD, IRT_U8), sp, IRFL_UDATA_UDTYPE);
emitir            618 lj_crecord.c         emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, UDTYPE_IO_FILE));
emitir            619 lj_crecord.c         sp = emitir(IRT(IR_FLOAD, IRT_PTR), sp, IRFL_UDATA_FILE);
emitir            621 lj_crecord.c         sp = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, sizeof(GCudata)));
emitir            629 lj_crecord.c         emitir(IRTG(IR_EQ, IRT_STR), sp, lj_ir_kstr(J, str));
emitir            640 lj_crecord.c         sp = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, sizeof(GCstr)));
emitir            650 lj_crecord.c         sp = emitir(IRT(IR_FLOAD, t), sp, IRFL_CDATA_PTR);
emitir            660 lj_crecord.c         sp = emitir(IRT(IR_FLOAD, t), sp, IRFL_CDATA_INT64);
emitir            665 lj_crecord.c         sp = emitir(IRT(IR_FLOAD, t), sp, IRFL_CDATA_INT);
emitir            668 lj_crecord.c         sp = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, sizeof(GCcdata)));
emitir            671 lj_crecord.c         sp = emitir(IRT(IR_XLOAD, t), sp, 0);  /* Load number value. */
emitir            721 lj_crecord.c       emitir(IRTG(IR_EQ, IRT_STR), J->base[1], lj_ir_kstr(J, strV(&rd->argv[1])));
emitir            743 lj_crecord.c       ptr = emitir(IRT(IR_FLOAD, t), ptr, IRFL_CDATA_PTR);
emitir            756 lj_crecord.c   	idx = emitir(IRT(IR_BAND, IRT_INTP), idx, lj_ir_kintp(J, 1));
emitir            766 lj_crecord.c   	ptr = emitir(IRT(IR_ADD, IRT_PTR), ptr, lj_ir_kintp(J, ofs));
emitir            770 lj_crecord.c         idx = emitir(IRT(IR_MUL, IRT_INTP), idx, lj_ir_kintp(J, sz));
emitir            771 lj_crecord.c         ptr = emitir(IRT(IR_ADD, IRT_PTR), idx, ptr);
emitir            779 lj_crecord.c   	idx = emitir(IRT(IR_FLOAD, t), idx, IRFL_CDATA_INT64);
emitir            781 lj_crecord.c   	idx = emitir(IRT(IR_FLOAD, t), idx, IRFL_CDATA_INT);
emitir            783 lj_crecord.c   	idx = emitir(IRT(IR_ADD, IRT_PTR), idx,
emitir            785 lj_crecord.c   	idx = emitir(IRT(IR_XLOAD, t), idx, 0);
emitir            805 lj_crecord.c   	emitir(IRTG(IR_EQ, IRT_STR), idx, lj_ir_kstr(J, name));
emitir            827 lj_crecord.c   	emitir(IRTG(IR_EQ, IRT_STR), idx, lj_ir_kstr(J, name));
emitir            847 lj_crecord.c       ptr = emitir(IRT(IR_ADD, IRT_PTR), ptr, lj_ir_kintp(J, ofs));
emitir            852 lj_crecord.c       ptr = emitir(IRT(IR_XLOAD, IRT_PTR), ptr, 0);
emitir            873 lj_crecord.c     TRef trhi = emitir(IRT(IR_ADD, IRT_P32), trlo, lj_ir_kint(J, 4));
emitir            876 lj_crecord.c       emitir(IRT(IR_XSTORE, IRT_P32), trlo, lj_ir_kfunc(J, funcV(fin)));
emitir            877 lj_crecord.c       emitir(IRTI(IR_XSTORE), trhi, lj_ir_kint(J, LJ_TFUNC));
emitir            879 lj_crecord.c       emitir(IRT(IR_XSTORE, IRT_P32), trlo,
emitir            881 lj_crecord.c       emitir(IRTI(IR_XSTORE), trhi, lj_ir_kint(J, LJ_TCDATA));
emitir            905 lj_crecord.c       J->base[0] = emitir(IRTG(IR_CNEWI, IRT_CDATA), trid, sp);
emitir            907 lj_crecord.c       TRef trcd = emitir(IRTG(IR_CNEW, IRT_CDATA), trid, TREF_NIL);
emitir            924 lj_crecord.c   	TRef dp = emitir(IRT(IR_ADD, IRT_PTR), trcd,
emitir            959 lj_crecord.c   	  dp = emitir(IRT(IR_ADD, IRT_PTR), trcd,
emitir            970 lj_crecord.c         dp = emitir(IRT(IR_ADD, IRT_PTR), trcd, lj_ir_kintp(J, sizeof(GCcdata)));
emitir           1079 lj_crecord.c       tr = emitir(IRT(IR_CARG, IRT_NIL), tr, args[i]);
emitir           1116 lj_crecord.c       TRef func = emitir(IRT(IR_FLOAD, tp), J->base[0], IRFL_CDATA_PTR);
emitir           1138 lj_crecord.c         func = emitir(IRT(IR_CARG, IRT_NIL), func,
emitir           1140 lj_crecord.c       tr = emitir(IRT(IR_CALLXS, t), crec_call_args(J, rd, cts, ct), func);
emitir           1159 lj_crecord.c         tr = emitir(IRTG(IR_CNEWI, IRT_CDATA), trid, tr);
emitir           1255 lj_crecord.c         tr = emitir(IRT(mm+(int)IR_ADD-(int)MM_add, dt), sp[0], sp[1]);
emitir           1257 lj_crecord.c       return emitir(IRTG(IR_CNEWI, IRT_CDATA), lj_ir_kint(J, id), tr);
emitir           1275 lj_crecord.c   	tr = emitir(IRT(IR_SUB, IRT_INTP), sp[0], sp[1]);
emitir           1276 lj_crecord.c   	tr = emitir(IRT(IR_BSAR, IRT_INTP), tr, lj_ir_kint(J, lj_fls(sz)));
emitir           1316 lj_crecord.c       tr = emitir(IRT(IR_MUL, IRT_INTP), tr, lj_ir_kintp(J, sz));
emitir           1317 lj_crecord.c       tr = emitir(IRT(mm+(int)IR_ADD-(int)MM_add, IRT_PTR), sp[0], tr);
emitir           1320 lj_crecord.c       return emitir(IRTG(IR_CNEWI, IRT_CDATA), lj_ir_kint(J, id), tr);
emitir           1380 lj_crecord.c   	tr = emitir(IRT(IR_FLOAD, t), tr, IRFL_CDATA_PTR);
emitir           1386 lj_crecord.c   	tr = emitir(IRT(IR_FLOAD, t), tr, IRFL_CDATA_INT64);
emitir           1390 lj_crecord.c   	tr = emitir(IRT(IR_FLOAD, t), tr, IRFL_CDATA_INT);
emitir           1394 lj_crecord.c   	tr = emitir(IRT(IR_FLOAD, IRT_PTR), tr, IRFL_CDATA_PTR);
emitir           1399 lj_crecord.c   	tr = emitir(IRT(IR_ADD, IRT_PTR), tr, lj_ir_kintp(J, sizeof(GCcdata)));
emitir           1407 lj_crecord.c   	  tr = emitir(IRT(IR_XLOAD, t), tr, 0);
emitir           1425 lj_crecord.c   	  emitir(IRTG(IR_EQ, IRT_STR), tr, lj_ir_kstr(J, str));
emitir           1432 lj_crecord.c   	tr = emitir(IRT(IR_ADD, IRT_PTR), tr, lj_ir_kintp(J, sizeof(GCstr)));
emitir           1479 lj_crecord.c         emitir(IRTG(IR_EQ, IRT_STR), J->base[1], lj_ir_kstr(J, name));
emitir           1543 lj_crecord.c       J->base[0] = emitir(IRT(IR_XSNEW, IRT_STR), tr, trlen);
emitir           1557 lj_crecord.c         trlen = emitir(IRTI(IR_FLOAD), J->base[1], IRFL_STR_LEN);
emitir           1558 lj_crecord.c         trlen = emitir(IRTI(IR_ADD), trlen, lj_ir_kint(J, 1));
emitir           1593 lj_crecord.c       J->base[0] = emitir(IRTG(IR_CNEWI, IRT_CDATA),
emitir           1617 lj_crecord.c       emitir(IRTG(IR_EQ, IRT_STR), J->base[0], lj_ir_kstr(J, strV(&rd->argv[0])));
emitir           1636 lj_crecord.c       emitir(IRTG(IR_EQ, IRT_STR), J->base[1], lj_ir_kstr(J, strV(&rd->argv[1])));
emitir            170 lj_ffrecord.c      fref = emitir(IRT(IR_FREF, IRT_P32), tr, IRFL_TAB_META);
emitir            172 lj_ffrecord.c      emitir(IRT(IR_FSTORE, IRT_TAB), fref, mtref);
emitir            174 lj_ffrecord.c        emitir(IRT(IR_TBAR, IRT_TAB), tr, 0);
emitir            221 lj_ffrecord.c      J->base[0] = emitir(IRTI(IR_FLOAD), tr, IRFL_STR_LEN);
emitir            234 lj_ffrecord.c        emitir(IRTG(IR_EQ, IRT_STR), tr, lj_ir_kstr(J, strV(tv)));
emitir            236 lj_ffrecord.c        TRef trptr = emitir(IRT(IR_STRREF, IRT_P32), tr, lj_ir_kint(J, 0));
emitir            237 lj_ffrecord.c        TRef trchar = emitir(IRT(IR_XLOAD, IRT_U8), trptr, IRXLOAD_READONLY);
emitir            238 lj_ffrecord.c        emitir(IRTG(IR_EQ, IRT_INT), trchar, lj_ir_kint(J, '#'));
emitir            285 lj_ffrecord.c        tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
emitir            341 lj_ffrecord.c        J->base[0] = emitir(IRT(IR_TOSTR, IRT_STR), tr, 0);
emitir            361 lj_ffrecord.c      J->base[0] = ix.key = emitir(IRTI(IR_ADD), ix.key, lj_ir_kint(J, 1));
emitir            425 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_ABS), tr, lj_ir_knum_abs(J));
emitir            434 lj_ffrecord.c      tr = emitir(IRTN(IR_FPMATH), lj_ir_tonum(J, tr), rd->data);
emitir            439 lj_ffrecord.c  	tr = emitir(IRTGI(IR_CONV), tr, IRCONV_INT_NUM|IRCONV_CHECK);
emitir            448 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_FPMATH), lj_ir_tonum(J, J->base[0]), rd->data);
emitir            462 lj_ffrecord.c      tr = emitir(IRTN(IR_FPMATH), tr, fpm);
emitir            463 lj_ffrecord.c      trb = emitir(IRTN(IR_FPMATH), trb, fpm);
emitir            464 lj_ffrecord.c      trb = emitir(IRTN(IR_DIV), lj_ir_knum_one(J), trb);
emitir            465 lj_ffrecord.c      tr = emitir(IRTN(IR_MUL), tr, trb);
emitir            467 lj_ffrecord.c      tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_LOG);
emitir            478 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_ATAN2), tr, tr2);
emitir            491 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_LDEXP), tr, tr2);
emitir            502 lj_ffrecord.c      TRef tmp = emitir(IRTN(IR_MUL), y, y);
emitir            503 lj_ffrecord.c      tmp = emitir(IRTN(IR_SUB), x, tmp);
emitir            504 lj_ffrecord.c      tmp = emitir(IRTN(IR_FPMATH), tmp, IRFPM_SQRT);
emitir            507 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_ATAN2), y, x);
emitir            513 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_CALLN), tr, rd->data);
emitir            525 lj_ffrecord.c      trt = emitir(IRTN(IR_FPMATH), tr, IRFPM_TRUNC);
emitir            527 lj_ffrecord.c      J->base[1] = emitir(IRTN(IR_SUB), tr, trt);
emitir            536 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_MUL), tr, trm);
emitir            556 lj_ffrecord.c        if (tref_isinteger(tr)) tr = emitir(IRTN(IR_CONV), tr, IRCONV_NUM_INT);
emitir            557 lj_ffrecord.c        if (tref_isinteger(tr2)) tr2 = emitir(IRTN(IR_CONV), tr2, IRCONV_NUM_INT);
emitir            560 lj_ffrecord.c      tr = emitir(IRT(op, t), tr, tr2);
emitir            572 lj_ffrecord.c    tr = emitir(IRTN(IR_SUB), tr, one);
emitir            577 lj_ffrecord.c        tr2 = emitir(IRTN(IR_SUB), tr2, tr1);
emitir            578 lj_ffrecord.c        tr2 = emitir(IRTN(IR_ADD), tr2, one);
emitir            579 lj_ffrecord.c        tr = emitir(IRTN(IR_MUL), tr, tr2);
emitir            580 lj_ffrecord.c        tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_FLOOR);
emitir            581 lj_ffrecord.c        tr = emitir(IRTN(IR_ADD), tr, tr1);
emitir            583 lj_ffrecord.c        tr = emitir(IRTN(IR_MUL), tr, tr1);
emitir            584 lj_ffrecord.c        tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_FLOOR);
emitir            585 lj_ffrecord.c        tr = emitir(IRTN(IR_ADD), tr, one);
emitir            598 lj_ffrecord.c    J->base[0] = (rd->data == IR_TOBIT) ? tr : emitir(IRTI(rd->data), tr, 0);
emitir            608 lj_ffrecord.c      tr = emitir(IRTI(op), tr, lj_opt_narrow_tobit(J, J->base[i]));
emitir            620 lj_ffrecord.c      tsh = emitir(IRTI(IR_BAND), tsh, lj_ir_kint(J, 31));
emitir            624 lj_ffrecord.c      tsh = emitir(IRTI(IR_NEG), tsh, tsh);
emitir            627 lj_ffrecord.c    J->base[0] = emitir(IRTI(op), tr, tsh);
emitir            634 lj_ffrecord.c    J->base[0] = emitir(IRTI(IR_FLOAD), lj_ir_tostr(J, J->base[0]), IRFL_STR_LEN);
emitir            642 lj_ffrecord.c    TRef trlen = emitir(IRTI(IR_FLOAD), trstr, IRFL_STR_LEN);
emitir            675 lj_ffrecord.c      emitir(IRTGI(IR_LT), trend, tr0);
emitir            676 lj_ffrecord.c      trend = emitir(IRTI(IR_ADD), emitir(IRTI(IR_ADD), trlen, trend),
emitir            680 lj_ffrecord.c      emitir(IRTGI(IR_ULE), trend, trlen);
emitir            682 lj_ffrecord.c      emitir(IRTGI(IR_GT), trend, trlen);
emitir            687 lj_ffrecord.c      emitir(IRTGI(IR_LT), trstart, tr0);
emitir            688 lj_ffrecord.c      trstart = emitir(IRTI(IR_ADD), trlen, trstart);
emitir            690 lj_ffrecord.c      emitir(start < 0 ? IRTGI(IR_LT) : IRTGI(IR_GE), trstart, tr0);
emitir            697 lj_ffrecord.c        emitir(IRTGI(IR_EQ), trstart, tr0);
emitir            700 lj_ffrecord.c        trstart = emitir(IRTI(IR_ADD), trstart, lj_ir_kint(J, -1));
emitir            701 lj_ffrecord.c        emitir(IRTGI(IR_GE), trstart, tr0);
emitir            708 lj_ffrecord.c        TRef trptr, trslen = emitir(IRTI(IR_SUB), trend, trstart);
emitir            709 lj_ffrecord.c        emitir(IRTGI(IR_GE), trslen, tr0);
emitir            710 lj_ffrecord.c        trptr = emitir(IRT(IR_STRREF, IRT_P32), trstr, trstart);
emitir            711 lj_ffrecord.c        J->base[0] = emitir(IRT(IR_SNEW, IRT_STR), trptr, trslen);
emitir            713 lj_ffrecord.c        emitir(IRTGI(IR_LT), trend, trstart);
emitir            719 lj_ffrecord.c        TRef trslen = emitir(IRTI(IR_SUB), trend, trstart);
emitir            720 lj_ffrecord.c        emitir(IRTGI(IR_EQ), trslen, lj_ir_kint(J, (int32_t)len));
emitir            725 lj_ffrecord.c  	TRef tmp = emitir(IRTI(IR_ADD), trstart, lj_ir_kint(J, (int32_t)i));
emitir            726 lj_ffrecord.c  	tmp = emitir(IRT(IR_STRREF, IRT_P32), trstr, tmp);
emitir            727 lj_ffrecord.c  	J->base[i] = emitir(IRT(IR_XLOAD, IRT_U8), tmp, IRXLOAD_READONLY);
emitir            730 lj_ffrecord.c        emitir(IRTGI(IR_LE), trend, trstart);
emitir            755 lj_ffrecord.c        emitir(IRTGI(len ? IR_NE : IR_EQ), trlen, lj_ir_kint(J, 0));
emitir            788 lj_ffrecord.c        ix.key = emitir(IRTI(IR_ADD), trlen, lj_ir_kint(J, 1));
emitir            809 lj_ffrecord.c      ud = emitir(IRT(IR_XLOAD, IRT_UDATA), tr, 0);
emitir            814 lj_ffrecord.c      tr = emitir(IRT(IR_FLOAD, IRT_U8), ud, IRFL_UDATA_UDTYPE);
emitir            815 lj_ffrecord.c      emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, UDTYPE_IO_FILE));
emitir            818 lj_ffrecord.c    fp = emitir(IRT(IR_FLOAD, IRT_PTR), ud, IRFL_UDATA_FILE);
emitir            819 lj_ffrecord.c    emitir(IRTG(IR_NE, IRT_PTR), fp, lj_ir_knull(J, IRT_PTR));
emitir            831 lj_ffrecord.c      TRef buf = emitir(IRT(IR_STRREF, IRT_P32), str, zero);
emitir            832 lj_ffrecord.c      TRef len = emitir(IRTI(IR_FLOAD), str, IRFL_STR_LEN);
emitir            834 lj_ffrecord.c        TRef tr = emitir(IRT(IR_XLOAD, IRT_U8), buf, IRXLOAD_READONLY);
emitir            837 lj_ffrecord.c  	emitir(IRTGI(IR_NE), tr, lj_ir_kint(J, -1));
emitir            841 lj_ffrecord.c  	emitir(IRTGI(IR_EQ), tr, len);
emitir            852 lj_ffrecord.c      emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, 0));
emitir            139 lj_ir.c            tr = emitir(IRT(IR_CARG, IRT_NIL), tr, va_arg(argp, IRRef));
emitir            143 lj_ir.c          return emitir(CCI_OPTYPE(ci), tr, id);
emitir            419 lj_ir.c              tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
emitir            431 lj_ir.c              tr = emitir(IRTN(IR_CONV), tr, IRCONV_NUM_INT);
emitir            433 lj_ir.c              tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
emitir            446 lj_ir.c            tr = emitir(IRT(IR_TOSTR, IRT_STR), tr, 0);
emitir            511 lj_opt_fold.c        fins->op2 = emitir(IRTI(IR_ADD), ir->op2, fins->op2); /* Clobbers fins! */
emitir            893 lj_opt_fold.c      ref = emitir(IRTN(IR_DIV), lj_ir_knum_one(J), ref);
emitir            898 lj_opt_fold.c      ref = emitir(IRTN(IR_MUL), ref, ref);
emitir            900 lj_opt_fold.c      TRef tmp = emitir(IRTN(IR_MUL), ref, ref);
emitir            903 lj_opt_fold.c  	ref = emitir(IRTN(IR_MUL), ref, tmp);
emitir            904 lj_opt_fold.c        tmp = emitir(IRTN(IR_MUL), tmp, tmp);
emitir            906 lj_opt_fold.c      ref = emitir(IRTN(IR_MUL), ref, tmp);
emitir           1089 lj_opt_fold.c    op1 = emitir(IRTI(IR_CONV), op1, mode);
emitir           1090 lj_opt_fold.c    op2 = emitir(IRTI(IR_CONV), op2, mode);
emitir           1837 lj_opt_fold.c        emitir(IRTGI(IR_EQ), fleft->op2, lj_ir_kint(J, len));
emitir           1851 lj_opt_fold.c        TRef tmp = emitir(ot, strref,
emitir           1855 lj_opt_fold.c  	tmp = emitir(IRTI(IR_BAND), tmp,
emitir            321 lj_opt_loop.c        IRRef ref = tref_ref(emitir(ir->ot & ~IRT_ISPHI, op1, op2));
emitir            338 lj_opt_loop.c  	      ref = tref_ref(emitir(IRTN(IR_CONV), ref, IRCONV_NUM_INT));
emitir            340 lj_opt_loop.c  	      ref = tref_ref(emitir(IRTGI(IR_CONV), ref,
emitir            376 lj_opt_narrow.c       sp[-1] = emitir(IRT(IR_CONV, IRT_I64), sp[-1],
emitir            395 lj_opt_narrow.c       sp[-1] = emitir(op+guardot, sp[-1], sp[0]);
emitir            441 lj_opt_narrow.c       tr = emitir(IRT(op - IR_ADDOV + IR_ADD,
emitir            446 lj_opt_narrow.c     tr = emitir(IRT(IR_CONV, IRT_INTP), tr, mode);
emitir            457 lj_opt_narrow.c     return emitir(IRTGI(IR_CONV), tr, IRCONV_INT_NUM|IRCONV_INDEX);
emitir            462 lj_opt_narrow.c     return emitir(IRTI(ir->o - IR_ADDOV + IR_ADD), ir->op1, ir->op2);
emitir            470 lj_opt_narrow.c     tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
emitir            472 lj_opt_narrow.c     return emitir(IRTI(IR_CONV), tr, IRCONV_INT_NUM|IRCONV_ANY);
emitir            486 lj_opt_narrow.c     tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
emitir            488 lj_opt_narrow.c     return emitir(IRTI(IR_TOBIT), tr, lj_ir_knum_tobit(J));
emitir            504 lj_opt_narrow.c     return emitir(IRT(IR_CONV, IRT_INTP), tr, (IRT_INTP<<5)|IRT_NUM|IRCONV_ANY);
emitir            524 lj_opt_narrow.c     tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
emitir            543 lj_opt_narrow.c     return emitir(IRTGI((int)op - (int)IR_ADD + (int)IR_ADDOV), rb, rc);
emitir            544 lj_opt_narrow.c   if (!tref_isnum(rb)) rb = emitir(IRTN(IR_CONV), rb, IRCONV_NUM_INT);
emitir            545 lj_opt_narrow.c   if (!tref_isnum(rc)) rc = emitir(IRTN(IR_CONV), rc, IRCONV_NUM_INT);
emitir            546 lj_opt_narrow.c   return emitir(IRTN(op), rb, rc);
emitir            555 lj_opt_narrow.c       return emitir(IRTGI(IR_SUBOV), lj_ir_kint(J, 0), rc);
emitir            556 lj_opt_narrow.c     rc = emitir(IRTN(IR_CONV), rc, IRCONV_NUM_INT);
emitir            558 lj_opt_narrow.c   return emitir(IRTN(IR_NEG), rc, lj_ir_knum_neg(J));
emitir            570 lj_opt_narrow.c     emitir(IRTGI(IR_NE), rc, lj_ir_kint(J, 0));
emitir            571 lj_opt_narrow.c     return emitir(IRTI(IR_MOD), rb, rc);
emitir            576 lj_opt_narrow.c   tmp = emitir(IRTN(IR_DIV), rb, rc);
emitir            577 lj_opt_narrow.c   tmp = emitir(IRTN(IR_FPMATH), tmp, IRFPM_FLOOR);
emitir            578 lj_opt_narrow.c   tmp = emitir(IRTN(IR_MUL), tmp, rc);
emitir            579 lj_opt_narrow.c   return emitir(IRTN(IR_SUB), rb, tmp);
emitir            599 lj_opt_narrow.c       rc = emitir(IRTGI(IR_CONV), rc, IRCONV_INT_NUM|IRCONV_CHECK);
emitir            602 lj_opt_narrow.c       TRef tmp = emitir(IRTI(IR_ADD), rc, lj_ir_kint(J, 65536));
emitir            603 lj_opt_narrow.c       emitir(IRTGI(IR_ULE), tmp, lj_ir_kint(J, 2*65536));
emitir            605 lj_opt_narrow.c     return emitir(IRTN(IR_POW), rb, rc);
emitir            613 lj_opt_narrow.c     return emitir(IRTN(IR_FPMATH), rb, IRFPM_SQRT);  /* x ^ 0.5 ==> sqrt(x) */
emitir            615 lj_opt_narrow.c   rb = emitir(IRTN(IR_FPMATH), rb, IRFPM_LOG2);
emitir            616 lj_opt_narrow.c   rc = emitir(IRTN(IR_MUL), rb, rc);
emitir            617 lj_opt_narrow.c   return emitir(IRTN(IR_FPMATH), rc, IRFPM_EXP2);
emitir            180 lj_record.c    	a = emitir(IRTN(IR_CONV), a, IRCONV_NUM_INT);
emitir            183 lj_record.c    	b = emitir(IRTN(IR_CONV), b, IRCONV_NUM_INT);
emitir            188 lj_record.c        emitir(IRTG(diff ? IR_NE : IR_EQ, ta), a, b);
emitir            227 lj_record.c    	J->slot[s] = emitir(IRTN(IR_CONV), tr, IRCONV_NUM_INT);
emitir            361 lj_record.c        emitir(IRTG(dir ? IR_GE : IR_LT, t), step, zero);
emitir            369 lj_record.c    	    emitir(IRTGI(IR_LE), step, lj_ir_kint(J, (int32_t)0x7fffffff-k));
emitir            372 lj_record.c    	    emitir(IRTGI(IR_GE), step, lj_ir_kint(J, (int32_t)0x80000000-k));
emitir            376 lj_record.c    	TRef tr = emitir(IRTGI(IR_ADDOV), step, stop);
emitir            377 lj_record.c    	emitir(IRTI(IR_USE), tr, 0);  /* ADDOV is weak. Avoid dead result. */
emitir            384 lj_record.c        emitir(IRTGI(dir ? IR_LE : IR_GE), stop, lj_ir_kint(J, k));
emitir            421 lj_record.c        J->base[ra+FORL_IDX] = idx = emitir(IRT(IR_ADD, t), idx, step);
emitir            443 lj_record.c          idx = emitir(IRT(IR_ADD, t), idx, J->scev.step);
emitir            460 lj_record.c    	tr[i] = emitir(IRTG(IR_STRTO, IRT_NUM), tr[i], 0);
emitir            463 lj_record.c    	  tr[i] = emitir(IRTGI(IR_CONV), tr[i], IRCONV_INT_NUM|IRCONV_CHECK);
emitir            466 lj_record.c    	  tr[i] = emitir(IRTN(IR_CONV), tr[i], IRCONV_NUM_INT);
emitir            485 lj_record.c      emitir(IRTG(op, t), tr[FORL_IDX], stop);
emitir            593 lj_record.c          TRef trpt = emitir(IRT(IR_FLOAD, IRT_P32), tr, IRFL_FUNC_PC);
emitir            594 lj_record.c          emitir(IRTG(IR_EQ, IRT_P32), trpt, lj_ir_kptr(J, proto_bc(pt)));
emitir            601 lj_record.c      emitir(IRTG(IR_EQ, IRT_FUNC), tr, kfunc);
emitir            755 lj_record.c          emitir(IRTG(IR_RETF, IRT_P32), trpt, trpc);
emitir            817 lj_record.c        mix.tab = emitir(IRT(IR_FLOAD, IRT_TAB), ix->tab, IRFL_TAB_META);
emitir            826 lj_record.c    	emitir(IRTG(IR_EQ, IRT_P32), ix->tab, lj_ir_kptr(J, udataV(&ix->tabv)));
emitir            829 lj_record.c    	TRef tr = emitir(IRT(IR_FLOAD, IRT_U8), ix->tab, IRFL_UDATA_UDTYPE);
emitir            830 lj_record.c    	emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, udtype));
emitir            845 lj_record.c        mix.tab = emitir(IRT(IR_FLOAD, IRT_TAB), ix->tab, IRFL_UDATA_META);
emitir            859 lj_record.c      emitir(IRTG(mt ? IR_NE : IR_EQ, IRT_TAB), mix.tab, lj_ir_knull(J, IRT_TAB));
emitir            956 lj_record.c          TRef mt2 = emitir(IRT(IR_FLOAD, IRT_TAB), ix->key, IRFL_TAB_META);
emitir            957 lj_record.c          emitir(IRTG(IR_EQ, IRT_TAB), mt2, ix->mt);
emitir            959 lj_record.c          TRef mt2 = emitir(IRT(IR_FLOAD, IRT_TAB), ix->key, IRFL_UDATA_META);
emitir            960 lj_record.c          emitir(IRTG(IR_EQ, IRT_TAB), mt2, ix->mt);
emitir            997 lj_record.c    	TRef mt2 = emitir(IRT(IR_FLOAD, IRT_TAB), ix->key, IRFL_TAB_META);
emitir            998 lj_record.c    	emitir(IRTG(IR_EQ, IRT_TAB), mt2, ix->mt);
emitir           1000 lj_record.c    	TRef mt2 = emitir(IRT(IR_FLOAD, IRT_TAB), ix->key, IRFL_UDATA_META);
emitir           1001 lj_record.c    	emitir(IRTG(IR_EQ, IRT_TAB), mt2, ix->mt);
emitir           1069 lj_record.c    	emitir(IRTG(IR_ABC, IRT_P32), asizeref, ofs == 0 ? J->scev.stop :
emitir           1070 lj_record.c    	       emitir(IRTI(IR_ADD), J->scev.stop, ofsref));
emitir           1074 lj_record.c    	  emitir(IRTG(IR_ABC, IRT_P32), asizeref, ikey);
emitir           1079 lj_record.c      emitir(IRTGI(IR_ABC), asizeref, ikey);  /* Emit regular bounds check. */
emitir           1097 lj_record.c          TRef asizeref = emitir(IRTI(IR_FLOAD), ix->tab, IRFL_TAB_ASIZE);
emitir           1101 lj_record.c    	arrayref = emitir(IRT(IR_FLOAD, IRT_P32), ix->tab, IRFL_TAB_ARRAY);
emitir           1102 lj_record.c    	return emitir(IRT(IR_AREF, IRT_P32), arrayref, ikey);
emitir           1104 lj_record.c    	emitir(IRTGI(IR_ULE), asizeref, ikey);  /* Inv. bounds check. */
emitir           1115 lj_record.c    	TRef tmp = emitir(IRTI(IR_FLOAD), ix->tab, IRFL_TAB_ASIZE);
emitir           1116 lj_record.c    	emitir(IRTGI(IR_EQ), tmp, lj_ir_kint(J, 0));
emitir           1126 lj_record.c        TRef tmp = emitir(IRTI(IR_FLOAD), ix->tab, IRFL_TAB_HMASK);
emitir           1127 lj_record.c        emitir(IRTGI(IR_EQ), tmp, lj_ir_kint(J, 0));
emitir           1131 lj_record.c        key = emitir(IRTN(IR_CONV), key, IRCONV_NUM_INT);
emitir           1138 lj_record.c          TRef hm = emitir(IRTI(IR_FLOAD), ix->tab, IRFL_TAB_HMASK);
emitir           1139 lj_record.c          emitir(IRTGI(IR_EQ), hm, lj_ir_kint(J, (int32_t)t->hmask));
emitir           1140 lj_record.c          node = emitir(IRT(IR_FLOAD, IRT_P32), ix->tab, IRFL_TAB_NODE);
emitir           1142 lj_record.c          return emitir(IRTG(IR_HREFK, IRT_P32), node, kslot);
emitir           1146 lj_record.c      return emitir(IRT(IR_HREF, IRT_P32), ix->tab, key);
emitir           1226 lj_record.c          emitir(IRTG(IR_EQ, IRT_P32), xref, lj_ir_kkptr(J, niltvg(J2G(J))));
emitir           1229 lj_record.c          res = emitir(IRTG(loadop, t), xref, 0);
emitir           1246 lj_record.c    	emitir(IRTG(loadop, IRT_NIL), xref, 0);  /* Guard for nil value. */
emitir           1248 lj_record.c    	emitir(IRTG(oldv == niltvg(J2G(J)) ? IR_EQ : IR_NE, IRT_P32),
emitir           1258 lj_record.c    	  key = emitir(IRTN(IR_CONV), key, IRCONV_NUM_INT);
emitir           1259 lj_record.c    	xref = emitir(IRT(IR_NEWREF, IRT_P32), ix->tab, key);
emitir           1265 lj_record.c    	emitir(IRTG(IR_NE, IRT_P32), xref, lj_ir_kkptr(J, niltvg(J2G(J))));
emitir           1269 lj_record.c    	  TRef mtref = emitir(IRT(IR_FLOAD, IRT_TAB), ix->tab, IRFL_TAB_META);
emitir           1270 lj_record.c    	  emitir(IRTG(IR_EQ, IRT_TAB), mtref, lj_ir_knull(J, IRT_TAB));
emitir           1273 lj_record.c    	  emitir(IRTG(loadop, t), xref, 0);  /* Guard for non-nil value. */
emitir           1281 lj_record.c          ix->val = emitir(IRTN(IR_CONV), ix->val, IRCONV_NUM_INT);
emitir           1282 lj_record.c        emitir(IRT(loadop+IRDELTA_L2S, tref_type(ix->val)), xref, ix->val);
emitir           1284 lj_record.c          emitir(IRT(IR_TBAR, IRT_NIL), ix->tab, 0);
emitir           1287 lj_record.c          TRef fref = emitir(IRT(IR_FREF, IRT_P32), ix->tab, IRFL_TAB_NOMM);
emitir           1288 lj_record.c          emitir(IRT(IR_FSTORE, IRT_U8), fref, lj_ir_kint(J, 0));
emitir           1336 lj_record.c          emitir(IRTG(IR_EQ, IRT_FUNC), fn, kfunc);
emitir           1348 lj_record.c        uref = tref_ref(emitir(IRTG(IR_UREFO, IRT_P32), fn, uv));
emitir           1354 lj_record.c    	emitir(IRTG(IR_EQ, IRT_P32),
emitir           1356 lj_record.c    	       emitir(IRT(IR_ADD, IRT_P32), uref,
emitir           1368 lj_record.c        emitir(IRTG(IR_UGT, IRT_P32),
emitir           1369 lj_record.c    	   emitir(IRT(IR_SUB, IRT_P32), uref, REF_BASE),
emitir           1373 lj_record.c        uref = tref_ref(emitir(IRTG(IR_UREFC, IRT_P32), fn, uv));
emitir           1377 lj_record.c        TRef res = emitir(IRTG(IR_ULOAD, t), uref, 0);
emitir           1383 lj_record.c          val = emitir(IRTN(IR_CONV), val, IRCONV_NUM_INT);
emitir           1384 lj_record.c        emitir(IRT(IR_USTORE, tref_type(val)), uref, val);
emitir           1386 lj_record.c          emitir(IRT(IR_OBAR, IRT_NIL), uref, val);
emitir           1503 lj_record.c          emitir(IRTG(IR_EQ, IRT_FUNC), getslot(J, bc_a(ins)), kfunc);
emitir           1528 lj_record.c        TRef fr = emitir(IRTI(IR_SLOAD), 0, IRSLOAD_READONLY|IRSLOAD_FRAME);
emitir           1536 lj_record.c    	  emitir(IRTGI(IR_GE), fr, lj_ir_kint(J, frofs+8*(int32_t)nresults));
emitir           1538 lj_record.c    	  emitir(IRTGI(IR_EQ), fr, lj_ir_kint(J, frame_ftsz(J->L->base-1)));
emitir           1539 lj_record.c    	vbase = emitir(IRTI(IR_SUB), REF_BASE, fr);
emitir           1540 lj_record.c    	vbase = emitir(IRT(IR_ADD, IRT_P32), vbase, lj_ir_kint(J, frofs-8));
emitir           1543 lj_record.c    	  TRef aref = emitir(IRT(IR_AREF, IRT_P32),
emitir           1545 lj_record.c    	  TRef tr = emitir(IRTG(IR_VLOAD, t), aref, 0);
emitir           1550 lj_record.c    	emitir(IRTGI(IR_LE), fr, lj_ir_kint(J, frofs));
emitir           1563 lj_record.c    	tridx = emitir(IRTGI(IR_CONV), tridx, IRCONV_INT_NUM|IRCONV_INDEX);
emitir           1565 lj_record.c    	emitir(IRTGI(idx <= nvararg ? IR_GE : IR_LT),
emitir           1569 lj_record.c    	TRef tmp = emitir(IRTI(IR_ADD), fr, lj_ir_kint(J, -frofs));
emitir           1571 lj_record.c    	  emitir(IRTGI(IR_GE), tmp, lj_ir_kint(J, 0));
emitir           1572 lj_record.c    	tr = emitir(IRTI(IR_BSHR), tmp, lj_ir_kint(J, 3));
emitir           1574 lj_record.c    	  tridx = emitir(IRTI(IR_ADD), tridx, lj_ir_kint(J, -1));
emitir           1580 lj_record.c    	  TRef tmp2 = emitir(IRTI(IR_BSHL), tridx, lj_ir_kint(J, 3));
emitir           1581 lj_record.c    	  tmp = emitir(IRTI(IR_ADD), tmp2, tmp);
emitir           1585 lj_record.c    	emitir(IRTGI(IR_LT), fr, tmp);
emitir           1589 lj_record.c    	TRef aref, vbase = emitir(IRTI(IR_SUB), REF_BASE, fr);
emitir           1590 lj_record.c    	vbase = emitir(IRT(IR_ADD, IRT_P32), vbase, lj_ir_kint(J, frofs-8));
emitir           1592 lj_record.c    	aref = emitir(IRT(IR_AREF, IRT_P32), vbase, tridx);
emitir           1593 lj_record.c    	tr = emitir(IRTG(IR_VLOAD, t), aref, 0);
emitir           1614 lj_record.c      return emitir(IRTG(IR_TNEW, IRT_TAB), asize, hbits);
emitir           1777 lj_record.c    	  ra = emitir(IRTN(IR_CONV), ra, IRCONV_NUM_INT);
emitir           1780 lj_record.c    	  rc = emitir(IRTN(IR_CONV), rc, IRCONV_NUM_INT);
emitir           1806 lj_record.c          emitir(IRTG(irop, ta), ra, rc);
emitir           1853 lj_record.c          rc = emitir(IRTI(IR_FLOAD), rc, IRFL_STR_LEN);
emitir           1942 lj_record.c        ix.tab = emitir(IRT(IR_FLOAD, IRT_TAB), getcurrf(J), IRFL_FUNC_ENV);
emitir           1960 lj_record.c        rc = emitir(IRTG(IR_TDUP, IRT_TAB),
emitir           2251 lj_record.c        TRef tr = emitir(IRT(IR_XLOAD, IRT_U8),
emitir           2253 lj_record.c        tr = emitir(IRTI(IR_BAND), tr, lj_ir_kint(J, (LUA_MASKLINE|LUA_MASKCOUNT)));
emitir           2254 lj_record.c        emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, 0));
emitir            399 lj_snap.c          tr = emitir(IRT(IR_PVAL, irt_type(ir->t)), ref - REF_BIAS, 0);
emitir            518 lj_snap.c      	  J->slot[snap_slot(sn)] = emitir(ir->ot & ~(IRT_MARK|IRT_ISPHI), op1, op2);
emitir            521 lj_snap.c      	  TRef tr = emitir(ir->ot, op1, op2);
emitir            536 lj_snap.c      		  tmp = emitir(irf->ot, tmp, irf->op2);
emitir            539 lj_snap.c      	      tmp = emitir(irr->ot, tmp, key);
emitir            545 lj_snap.c      		val = emitir(IRTN(IR_CONV), val, IRCONV_NUM_INT);
emitir            561 lj_snap.c      		tmp = emitir(IRT(irs->o, t), tmp, val);
emitir            564 lj_snap.c      	      tmp = emitir(irs->ot, tmp, val);
emitir            566 lj_snap.c      	      emitir(IRT(IR_XBAR, IRT_NIL), 0, 0);