emitir             43 lj_crecord.c     emitir(IRT(IR_CONV, (dt)), (a), (st)|((dt) << 5)|(flags))
emitir             55 lj_crecord.c     trtypeid = emitir(IRT(IR_FLOAD, IRT_U16), tr, IRFL_CDATA_CTYPEID);
emitir             56 lj_crecord.c     emitir(IRTG(IR_EQ, IRT_INT), trtypeid, lj_ir_kint(J, (int32_t)cd->ctypeid));
emitir             66 lj_crecord.c     tr = emitir(IRT(IR_FLOAD, IRT_INT), tr, IRFL_CDATA_INT);
emitir             67 lj_crecord.c     emitir(IRTG(IR_EQ, IRT_INT), tr, lj_ir_kint(J, (int32_t)id));
emitir             78 lj_crecord.c       emitir(IRTG(IR_EQ, IRT_STR), tr, lj_ir_kstr(J, s));
emitir            211 lj_crecord.c       TRef trsptr = emitir(IRT(IR_ADD, IRT_PTR), trsrc, trofs);
emitir            212 lj_crecord.c       ml[i].trval = emitir(IRT(IR_XLOAD, ml[i].tp), trsptr, 0);
emitir            219 lj_crecord.c   	TRef trdptr = emitir(IRT(IR_ADD, IRT_PTR), trdst, ml[j].trofs);
emitir            220 lj_crecord.c   	emitir(IRT(IR_XSTORE, ml[j].tp), trdptr, ml[j].trval);
emitir            265 lj_crecord.c   	emitir(IRT(IR_XBAR, IRT_NIL), 0, 0);
emitir            272 lj_crecord.c     emitir(IRT(IR_XBAR, IRT_NIL), 0, 0);
emitir            305 lj_crecord.c       TRef trdptr = emitir(IRT(IR_ADD, IRT_PTR), trdst, trofs);
emitir            306 lj_crecord.c       emitir(IRT(IR_XSTORE, ml[i].tp), trdptr, trfill);
emitir            330 lj_crecord.c   	trfill = emitir(IRT(IR_MUL, IRT_U64), trfill,
emitir            333 lj_crecord.c   	trfill = emitir(IRTI(IR_MUL), trfill,
emitir            343 lj_crecord.c     emitir(IRT(IR_XBAR, IRT_NIL), 0, 0);
emitir            416 lj_crecord.c         emitir(IRTG(isnz ? IR_NE : IR_EQ, st), sp, zero);
emitir            438 lj_crecord.c       emitir(IRT(IR_XSTORE, dt), dp, sp);
emitir            441 lj_crecord.c       sp = emitir(IRT(IR_XLOAD, st), sp, 0);  /* Load re. */
emitir            466 lj_crecord.c       sp = emitir(IRT(IR_XLOAD, st), sp, 0);  /* Load re. */
emitir            478 lj_crecord.c         TRef ptr = emitir(IRT(IR_ADD, IRT_PTR), dp, lj_ir_kintp(J, (dsize >> 1)));
emitir            479 lj_crecord.c         emitir(IRT(IR_XSTORE, dt), ptr, lj_ir_knum(J, 0));
emitir            488 lj_crecord.c         re = emitir(IRT(IR_XLOAD, st), sp, 0);
emitir            489 lj_crecord.c         ptr = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, (ssize >> 1)));
emitir            490 lj_crecord.c         im = emitir(IRT(IR_XLOAD, st), ptr, 0);
emitir            495 lj_crecord.c         emitir(IRT(IR_XSTORE, dt), dp, re);
emitir            496 lj_crecord.c         ptr = emitir(IRT(IR_ADD, IRT_PTR), dp, lj_ir_kintp(J, (dsize >> 1)));
emitir            497 lj_crecord.c         emitir(IRT(IR_XSTORE, dt), ptr, im);
emitir            556 lj_crecord.c       tr = emitir(IRT(IR_XLOAD, t), sp, 0);
emitir            571 lj_crecord.c       sp = emitir(IRT(IR_XLOAD, t), sp, 0);  /* Box pointers and enums. */
emitir            578 lj_crecord.c       dp = emitir(IRTG(IR_CNEW, IRT_CDATA), lj_ir_kint(J, sid), TREF_NIL);
emitir            579 lj_crecord.c       tr1 = emitir(IRT(IR_XLOAD, t), sp, 0);
emitir            580 lj_crecord.c       ptr = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, esz));
emitir            581 lj_crecord.c       tr2 = emitir(IRT(IR_XLOAD, t), ptr, 0);
emitir            582 lj_crecord.c       ptr = emitir(IRT(IR_ADD, IRT_PTR), dp, lj_ir_kintp(J, sizeof(GCcdata)));
emitir            583 lj_crecord.c       emitir(IRT(IR_XSTORE, t), ptr, tr1);
emitir            584 lj_crecord.c       ptr = emitir(IRT(IR_ADD, IRT_PTR), dp, lj_ir_kintp(J, sizeof(GCcdata)+esz));
emitir            585 lj_crecord.c       emitir(IRT(IR_XSTORE, t), ptr, tr2);
emitir            593 lj_crecord.c     return emitir(IRTG(IR_CNEWI, IRT_CDATA), lj_ir_kint(J, sid), sp);
emitir            618 lj_crecord.c         TRef tr = emitir(IRT(IR_FLOAD, IRT_U8), sp, IRFL_UDATA_UDTYPE);
emitir            619 lj_crecord.c         emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, UDTYPE_IO_FILE));
emitir            620 lj_crecord.c         sp = emitir(IRT(IR_FLOAD, IRT_PTR), sp, IRFL_UDATA_FILE);
emitir            622 lj_crecord.c         sp = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, sizeof(GCudata)));
emitir            630 lj_crecord.c         emitir(IRTG(IR_EQ, IRT_STR), sp, lj_ir_kstr(J, str));
emitir            641 lj_crecord.c         sp = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, sizeof(GCstr)));
emitir            646 lj_crecord.c       sp = emitir(IRT(IR_BAND, IRT_P64), sp,
emitir            662 lj_crecord.c         sp = emitir(IRT(IR_FLOAD, t), sp, IRFL_CDATA_PTR);
emitir            672 lj_crecord.c         sp = emitir(IRT(IR_FLOAD, t), sp, IRFL_CDATA_INT64);
emitir            677 lj_crecord.c         sp = emitir(IRT(IR_FLOAD, t), sp, IRFL_CDATA_INT);
emitir            680 lj_crecord.c         sp = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, sizeof(GCcdata)));
emitir            683 lj_crecord.c         sp = emitir(IRT(IR_XLOAD, t), sp, 0);  /* Load number value. */
emitir            745 lj_crecord.c       emitir(IRTG(IR_EQ, IRT_STR), J->base[1], lj_ir_kstr(J, strV(&rd->argv[1])));
emitir            758 lj_crecord.c     TRef tr = emitir(IRT(IR_XLOAD, t), ptr, 0);
emitir            763 lj_crecord.c         tr = emitir(IRTI(IR_BAND), tr, lj_ir_kint(J, (int32_t)((1u << pos))));
emitir            769 lj_crecord.c         tr = emitir(IRTI(IR_BSHL), tr, lj_ir_kint(J, shift - pos));
emitir            770 lj_crecord.c         tr = emitir(IRTI(IR_BSAR), tr, lj_ir_kint(J, shift));
emitir            773 lj_crecord.c         tr = emitir(IRTI(IR_BSHR), tr, lj_ir_kint(J, pos));
emitir            774 lj_crecord.c         tr = emitir(IRTI(IR_BAND), tr, lj_ir_kint(J, (int32_t)((1u << bsz)-1)));
emitir            785 lj_crecord.c       sp = emitir(IRTI(IR_BSHL), sp, lj_ir_kint(J, pos));
emitir            787 lj_crecord.c       sp = emitir(IRT(IR_BAND, t), sp, lj_ir_kint(J, mask));
emitir            788 lj_crecord.c       tr = emitir(IRT(IR_BAND, t), tr, lj_ir_kint(J, (int32_t)~mask));
emitir            789 lj_crecord.c       tr = emitir(IRT(IR_BOR, t), tr, sp);
emitir            790 lj_crecord.c       emitir(IRT(IR_XSTORE, t), ptr, tr);
emitir            809 lj_crecord.c       ptr = emitir(IRT(IR_FLOAD, t), ptr, IRFL_CDATA_PTR);
emitir            822 lj_crecord.c   	idx = emitir(IRT(IR_BAND, IRT_INTP), idx, lj_ir_kintp(J, 1));
emitir            832 lj_crecord.c   	ptr = emitir(IRT(IR_ADD, IRT_PTR), ptr, lj_ir_kintp(J, ofs));
emitir            836 lj_crecord.c         idx = emitir(IRT(IR_MUL, IRT_INTP), idx, lj_ir_kintp(J, sz));
emitir            837 lj_crecord.c         ptr = emitir(IRT(IR_ADD, IRT_PTR), idx, ptr);
emitir            845 lj_crecord.c   	idx = emitir(IRT(IR_FLOAD, t), idx, IRFL_CDATA_INT64);
emitir            847 lj_crecord.c   	idx = emitir(IRT(IR_FLOAD, t), idx, IRFL_CDATA_INT);
emitir            849 lj_crecord.c   	idx = emitir(IRT(IR_ADD, IRT_PTR), idx,
emitir            851 lj_crecord.c   	idx = emitir(IRT(IR_XLOAD, t), idx, 0);
emitir            872 lj_crecord.c   	emitir(IRTG(IR_EQ, IRT_STR), idx, lj_ir_kstr(J, name));
emitir            883 lj_crecord.c   	    ptr = emitir(IRT(IR_ADD, IRT_PTR), ptr, lj_ir_kintp(J, ofs));
emitir            896 lj_crecord.c   	emitir(IRTG(IR_EQ, IRT_STR), idx, lj_ir_kstr(J, name));
emitir            916 lj_crecord.c       ptr = emitir(IRT(IR_ADD, IRT_PTR), ptr, lj_ir_kintp(J, ofs));
emitir            921 lj_crecord.c       ptr = emitir(IRT(IR_XLOAD, IRT_PTR), ptr, 0);
emitir            968 lj_crecord.c       J->base[0] = emitir(IRTG(IR_CNEWI, IRT_CDATA), trid, sp);
emitir            980 lj_crecord.c         trsz = emitir(IRTGI(IR_MULOV), trsz, lj_ir_kint(J, (int32_t)(sz1-sz0)));
emitir            981 lj_crecord.c         trsz = emitir(IRTGI(IR_ADDOV), trsz, lj_ir_kint(J, (int32_t)sz0));
emitir            986 lj_crecord.c       trcd = emitir(IRTG(IR_CNEW, IRT_CDATA), trid, trsz);
emitir            993 lj_crecord.c         dp = emitir(IRT(IR_ADD, IRT_PTR), trcd, lj_ir_kintp(J, sizeof(GCcdata)));
emitir           1013 lj_crecord.c   	TRef dp = emitir(IRT(IR_ADD, IRT_PTR), trcd,
emitir           1048 lj_crecord.c   	  dp = emitir(IRT(IR_ADD, IRT_PTR), trcd,
emitir           1059 lj_crecord.c         dp = emitir(IRT(IR_ADD, IRT_PTR), trcd, lj_ir_kintp(J, sizeof(GCcdata)));
emitir           1169 lj_crecord.c       tr = emitir(IRT(IR_CARG, IRT_NIL), tr, args[i]);
emitir           1206 lj_crecord.c       TRef func = emitir(IRT(IR_FLOAD, tp), J->base[0], IRFL_CDATA_PTR);
emitir           1228 lj_crecord.c         func = emitir(IRT(IR_CARG, IRT_NIL), func,
emitir           1230 lj_crecord.c       tr = emitir(IRT(IR_CALLXS, t), crec_call_args(J, rd, cts, ct), func);
emitir           1249 lj_crecord.c         tr = emitir(IRTG(IR_CNEWI, IRT_CDATA), trid, tr);
emitir           1344 lj_crecord.c         tr = emitir(IRT(mm+(int)IR_ADD-(int)MM_add, dt), sp[0], sp[1]);
emitir           1346 lj_crecord.c       return emitir(IRTG(IR_CNEWI, IRT_CDATA), lj_ir_kint(J, id), tr);
emitir           1364 lj_crecord.c   	tr = emitir(IRT(IR_SUB, IRT_INTP), sp[0], sp[1]);
emitir           1365 lj_crecord.c   	tr = emitir(IRT(IR_BSAR, IRT_INTP), tr, lj_ir_kint(J, lj_fls(sz)));
emitir           1404 lj_crecord.c       tr = emitir(IRT(IR_MUL, IRT_INTP), tr, lj_ir_kintp(J, sz));
emitir           1405 lj_crecord.c       tr = emitir(IRT(mm+(int)IR_ADD-(int)MM_add, IRT_PTR), sp[0], tr);
emitir           1408 lj_crecord.c       return emitir(IRTG(IR_CNEWI, IRT_CDATA), lj_ir_kint(J, id), tr);
emitir           1467 lj_crecord.c   	tr = emitir(IRT(IR_FLOAD, t), tr, IRFL_CDATA_PTR);
emitir           1473 lj_crecord.c   	tr = emitir(IRT(IR_FLOAD, t), tr, IRFL_CDATA_INT64);
emitir           1477 lj_crecord.c   	tr = emitir(IRT(IR_FLOAD, t), tr, IRFL_CDATA_INT);
emitir           1481 lj_crecord.c   	tr = emitir(IRT(IR_FLOAD, IRT_PTR), tr, IRFL_CDATA_PTR);
emitir           1486 lj_crecord.c   	tr = emitir(IRT(IR_ADD, IRT_PTR), tr, lj_ir_kintp(J, sizeof(GCcdata)));
emitir           1494 lj_crecord.c   	  tr = emitir(IRT(IR_XLOAD, t), tr, 0);
emitir           1512 lj_crecord.c   	  emitir(IRTG(IR_EQ, IRT_STR), tr, lj_ir_kstr(J, str));
emitir           1519 lj_crecord.c   	tr = emitir(IRT(IR_ADD, IRT_PTR), tr, lj_ir_kintp(J, sizeof(GCstr)));
emitir           1565 lj_crecord.c         emitir(IRTG(IR_EQ, IRT_STR), J->base[1], lj_ir_kstr(J, name));
emitir           1629 lj_crecord.c       J->base[0] = emitir(IRT(IR_XSNEW, IRT_STR), tr, trlen);
emitir           1643 lj_crecord.c         trlen = emitir(IRTI(IR_FLOAD), J->base[1], IRFL_STR_LEN);
emitir           1644 lj_crecord.c         trlen = emitir(IRTI(IR_ADD), trlen, lj_ir_kint(J, 1));
emitir           1679 lj_crecord.c       J->base[0] = emitir(IRTG(IR_CNEWI, IRT_CDATA),
emitir           1703 lj_crecord.c       emitir(IRTG(IR_EQ, IRT_STR), J->base[0], lj_ir_kstr(J, strV(&rd->argv[0])));
emitir           1722 lj_crecord.c       emitir(IRTG(IR_EQ, IRT_STR), J->base[1], lj_ir_kstr(J, strV(&rd->argv[1])));
emitir           1769 lj_crecord.c       tr = emitir(IRT(rd->data, id-CTID_INT64+IRT_I64), tr, 0);
emitir           1770 lj_crecord.c       J->base[0] = emitir(IRTG(IR_CNEWI, IRT_CDATA), lj_ir_kint(J, id), tr);
emitir           1791 lj_crecord.c         tr = emitir(ot, tr, tr2);
emitir           1793 lj_crecord.c       J->base[0] = emitir(IRTG(IR_CNEWI, IRT_CDATA), lj_ir_kint(J, id), tr);
emitir           1818 lj_crecord.c         tsh = emitir(IRTI(IR_BAND), tsh, lj_ir_kint(J, 63));
emitir           1822 lj_crecord.c   	tsh = emitir(IRTI(IR_NEG), tsh, tsh);
emitir           1825 lj_crecord.c       tr = emitir(IRT(op, id-CTID_INT64+IRT_I64), tr, tsh);
emitir           1826 lj_crecord.c       J->base[0] = emitir(IRTG(IR_CNEWI, IRT_CDATA), lj_ir_kint(J, id), tr);
emitir           1846 lj_crecord.c       emitir(IRTGI(IR_EQ), trsf, lj_ir_kint(J, n));  /* Specialize to n. */
emitir           1855 lj_crecord.c         tr = emitir(IRT(IR_BAND, IRT_U64), tr,
emitir           1860 lj_crecord.c         tr = emitir(IRTI(IR_BAND), tr, lj_ir_kint(J, (int32_t)((1u << 4*n)-1)));
emitir            181 lj_ffrecord.c    return emitir(IRT(IR_BUFHDR, IRT_PGC),
emitir            231 lj_ffrecord.c      fref = emitir(IRT(IR_FREF, IRT_PGC), tr, IRFL_TAB_META);
emitir            233 lj_ffrecord.c      emitir(IRT(IR_FSTORE, IRT_TAB), fref, mtref);
emitir            235 lj_ffrecord.c        emitir(IRT(IR_TBAR, IRT_TAB), tr, 0);
emitir            282 lj_ffrecord.c      J->base[0] = emitir(IRTI(IR_FLOAD), tr, IRFL_STR_LEN);
emitir            295 lj_ffrecord.c        emitir(IRTG(IR_EQ, IRT_STR), tr, lj_ir_kstr(J, strV(tv)));
emitir            297 lj_ffrecord.c        TRef trptr = emitir(IRT(IR_STRREF, IRT_PGC), tr, lj_ir_kint(J, 0));
emitir            298 lj_ffrecord.c        TRef trchar = emitir(IRT(IR_XLOAD, IRT_U8), trptr, IRXLOAD_READONLY);
emitir            299 lj_ffrecord.c        emitir(IRTG(IR_EQ, IRT_INT), trchar, lj_ir_kint(J, '#'));
emitir            351 lj_ffrecord.c        tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
emitir            407 lj_ffrecord.c        J->base[0] = emitir(IRT(IR_TOSTR, IRT_STR), tr,
emitir            429 lj_ffrecord.c      J->base[0] = ix.key = emitir(IRTI(IR_ADD), ix.key, lj_ir_kint(J, 1));
emitir            501 lj_ffrecord.c      TRef trl = emitir(IRT(IR_LREF, IRT_THREAD), 0, 0);
emitir            502 lj_ffrecord.c      J->base[0] = emitir(IRT(IR_FLOAD, IRT_TAB), trl, IRFL_THREAD_ENV);
emitir            513 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_ABS), tr, lj_ir_ksimd(J, LJ_KSIMD_ABS));
emitir            522 lj_ffrecord.c      tr = emitir(IRTN(IR_FPMATH), lj_ir_tonum(J, tr), rd->data);
emitir            527 lj_ffrecord.c  	tr = emitir(IRTGI(IR_CONV), tr, IRCONV_INT_NUM|IRCONV_CHECK);
emitir            536 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_FPMATH), lj_ir_tonum(J, J->base[0]), rd->data);
emitir            550 lj_ffrecord.c      tr = emitir(IRTN(IR_FPMATH), tr, fpm);
emitir            551 lj_ffrecord.c      trb = emitir(IRTN(IR_FPMATH), trb, fpm);
emitir            552 lj_ffrecord.c      trb = emitir(IRTN(IR_DIV), lj_ir_knum_one(J), trb);
emitir            553 lj_ffrecord.c      tr = emitir(IRTN(IR_MUL), tr, trb);
emitir            555 lj_ffrecord.c      tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_LOG);
emitir            566 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_ATAN2), tr, tr2);
emitir            579 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_LDEXP), tr, tr2);
emitir            590 lj_ffrecord.c      TRef tmp = emitir(IRTN(IR_MUL), y, y);
emitir            591 lj_ffrecord.c      tmp = emitir(IRTN(IR_SUB), x, tmp);
emitir            592 lj_ffrecord.c      tmp = emitir(IRTN(IR_FPMATH), tmp, IRFPM_SQRT);
emitir            595 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_ATAN2), y, x);
emitir            601 lj_ffrecord.c    J->base[0] = emitir(IRTN(IR_CALLN), tr, rd->data);
emitir            613 lj_ffrecord.c      trt = emitir(IRTN(IR_FPMATH), tr, IRFPM_TRUNC);
emitir            615 lj_ffrecord.c      J->base[1] = emitir(IRTN(IR_SUB), tr, trt);
emitir            636 lj_ffrecord.c        if (tref_isinteger(tr)) tr = emitir(IRTN(IR_CONV), tr, IRCONV_NUM_INT);
emitir            637 lj_ffrecord.c        if (tref_isinteger(tr2)) tr2 = emitir(IRTN(IR_CONV), tr2, IRCONV_NUM_INT);
emitir            640 lj_ffrecord.c      tr = emitir(IRT(op, t), tr, tr2);
emitir            652 lj_ffrecord.c    tr = emitir(IRTN(IR_SUB), tr, one);
emitir            657 lj_ffrecord.c        tr2 = emitir(IRTN(IR_SUB), tr2, tr1);
emitir            658 lj_ffrecord.c        tr2 = emitir(IRTN(IR_ADD), tr2, one);
emitir            659 lj_ffrecord.c        tr = emitir(IRTN(IR_MUL), tr, tr2);
emitir            660 lj_ffrecord.c        tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_FLOOR);
emitir            661 lj_ffrecord.c        tr = emitir(IRTN(IR_ADD), tr, tr1);
emitir            663 lj_ffrecord.c        tr = emitir(IRTN(IR_MUL), tr, tr1);
emitir            664 lj_ffrecord.c        tr = emitir(IRTN(IR_FPMATH), tr, IRFPM_FLOOR);
emitir            665 lj_ffrecord.c        tr = emitir(IRTN(IR_ADD), tr, one);
emitir            692 lj_ffrecord.c    J->base[0] = emitir(IRTI(rd->data), lj_opt_narrow_tobit(J, J->base[0]), 0);
emitir            707 lj_ffrecord.c        tr = emitir(ot, tr, lj_opt_narrow_tobit(J, J->base[i]));
emitir            725 lj_ffrecord.c        tsh = emitir(IRTI(IR_BAND), tsh, lj_ir_kint(J, 31));
emitir            729 lj_ffrecord.c        tsh = emitir(IRTI(IR_NEG), tsh, tsh);
emitir            732 lj_ffrecord.c      J->base[0] = emitir(IRTI(op), tr, tsh);
emitir            741 lj_ffrecord.c    J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
emitir            755 lj_ffrecord.c      emitir(IRTGI(IR_LT), tr, tr0);
emitir            756 lj_ffrecord.c      tr = emitir(IRTI(IR_ADD), trlen, tr);
emitir            758 lj_ffrecord.c      emitir(start < 0 ? IRTGI(IR_LT) : IRTGI(IR_GE), tr, tr0);
emitir            764 lj_ffrecord.c      emitir(IRTGI(IR_EQ), tr, tr0);
emitir            767 lj_ffrecord.c      tr = emitir(IRTI(IR_ADD), tr, lj_ir_kint(J, -1));
emitir            768 lj_ffrecord.c      emitir(IRTGI(IR_GE), tr, tr0);
emitir            779 lj_ffrecord.c    TRef trlen = emitir(IRTI(IR_FLOAD), trstr, IRFL_STR_LEN);
emitir            812 lj_ffrecord.c      emitir(IRTGI(IR_LT), trend, tr0);
emitir            813 lj_ffrecord.c      trend = emitir(IRTI(IR_ADD), emitir(IRTI(IR_ADD), trlen, trend),
emitir            817 lj_ffrecord.c      emitir(IRTGI(IR_ULE), trend, trlen);
emitir            819 lj_ffrecord.c      emitir(IRTGI(IR_UGT), trend, trlen);
emitir            827 lj_ffrecord.c        TRef trptr, trslen = emitir(IRTI(IR_SUB), trend, trstart);
emitir            828 lj_ffrecord.c        emitir(IRTGI(IR_GE), trslen, tr0);
emitir            829 lj_ffrecord.c        trptr = emitir(IRT(IR_STRREF, IRT_PGC), trstr, trstart);
emitir            830 lj_ffrecord.c        J->base[0] = emitir(IRT(IR_SNEW, IRT_STR), trptr, trslen);
emitir            832 lj_ffrecord.c        emitir(IRTGI(IR_LT), trend, trstart);
emitir            838 lj_ffrecord.c        TRef trslen = emitir(IRTI(IR_SUB), trend, trstart);
emitir            839 lj_ffrecord.c        emitir(IRTGI(IR_EQ), trslen, lj_ir_kint(J, (int32_t)len));
emitir            844 lj_ffrecord.c  	TRef tmp = emitir(IRTI(IR_ADD), trstart, lj_ir_kint(J, (int32_t)i));
emitir            845 lj_ffrecord.c  	tmp = emitir(IRT(IR_STRREF, IRT_PGC), trstr, tmp);
emitir            846 lj_ffrecord.c  	J->base[i] = emitir(IRT(IR_XLOAD, IRT_U8), tmp, IRXLOAD_READONLY);
emitir            849 lj_ffrecord.c        emitir(IRTGI(IR_LE), trend, trstart);
emitir            861 lj_ffrecord.c      emitir(IRTGI(IR_ULE), tr, k255);
emitir            862 lj_ffrecord.c      J->base[i] = emitir(IRT(IR_TOSTR, IRT_STR), tr, IRTOSTR_CHAR);
emitir            867 lj_ffrecord.c        tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr, J->base[i]);
emitir            868 lj_ffrecord.c      J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
emitir            881 lj_ffrecord.c      emitir(IRTGI(vrep > 1 ? IR_GT : IR_LE), rep, lj_ir_kint(J, 1));
emitir            884 lj_ffrecord.c        TRef tr2 = emitir(IRT(IR_BUFPUT, IRT_PGC), hdr2, sep);
emitir            885 lj_ffrecord.c        tr2 = emitir(IRT(IR_BUFPUT, IRT_PGC), tr2, str);
emitir            886 lj_ffrecord.c        str2 = emitir(IRT(IR_BUFSTR, IRT_STR), tr2, hdr2);
emitir            891 lj_ffrecord.c      tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr, str);
emitir            893 lj_ffrecord.c      rep = emitir(IRTI(IR_ADD), rep, lj_ir_kint(J, -1));
emitir            896 lj_ffrecord.c    J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
emitir            904 lj_ffrecord.c    J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
emitir            911 lj_ffrecord.c    TRef trlen = emitir(IRTI(IR_FLOAD), trstr, IRFL_STR_LEN);
emitir            927 lj_ffrecord.c      emitir(IRTGI(IR_ULE), trstart, trlen);
emitir            929 lj_ffrecord.c      emitir(IRTGI(IR_UGT), trstart, trlen);
emitir            940 lj_ffrecord.c        (emitir(IRTG(IR_EQ, IRT_STR), trpat, lj_ir_kstr(J, pat)),
emitir            942 lj_ffrecord.c      TRef trsptr = emitir(IRT(IR_STRREF, IRT_PGC), trstr, trstart);
emitir            943 lj_ffrecord.c      TRef trpptr = emitir(IRT(IR_STRREF, IRT_PGC), trpat, tr0);
emitir            944 lj_ffrecord.c      TRef trslen = emitir(IRTI(IR_SUB), trlen, trstart);
emitir            945 lj_ffrecord.c      TRef trplen = emitir(IRTI(IR_FLOAD), trpat, IRFL_STR_LEN);
emitir            951 lj_ffrecord.c        emitir(IRTG(IR_NE, IRT_PGC), tr, trp0);
emitir            952 lj_ffrecord.c        pos = emitir(IRTI(IR_SUB), tr, emitir(IRT(IR_STRREF, IRT_PGC), trstr, tr0));
emitir            953 lj_ffrecord.c        J->base[0] = emitir(IRTI(IR_ADD), pos, lj_ir_kint(J, 1));
emitir            954 lj_ffrecord.c        J->base[1] = emitir(IRTI(IR_ADD), pos, trplen);
emitir            957 lj_ffrecord.c        emitir(IRTG(IR_EQ, IRT_PGC), tr, trp0);
emitir            975 lj_ffrecord.c    emitir(IRTG(IR_EQ, IRT_STR), trfmt, lj_ir_kstr(J, fmt));
emitir            984 lj_ffrecord.c        tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr,
emitir            993 lj_ffrecord.c  	tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr,
emitir            994 lj_ffrecord.c  		    emitir(IRT(IR_TOSTR, IRT_STR), tra, IRTOSTR_INT));
emitir            997 lj_ffrecord.c  	tra = emitir(IRT(IR_CONV, IRT_U64), tra,
emitir           1023 lj_ffrecord.c  	tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr, tra);
emitir           1032 lj_ffrecord.c  	tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr,
emitir           1033 lj_ffrecord.c  		    emitir(IRT(IR_TOSTR, IRT_STR), tra, IRTOSTR_CHAR));
emitir           1044 lj_ffrecord.c    J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
emitir           1059 lj_ffrecord.c        ix.key = emitir(IRTI(IR_ADD), trlen, lj_ir_kint(J, 1));
emitir           1084 lj_ffrecord.c      emitir(IRTG(IR_NE, IRT_PTR), tr, lj_ir_kptr(J, NULL));
emitir           1085 lj_ffrecord.c      J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
emitir           1122 lj_ffrecord.c      ud = emitir(IRT(IR_XLOAD, IRT_UDATA), tr, 0);
emitir           1128 lj_ffrecord.c      tr = emitir(IRT(IR_FLOAD, IRT_U8), ud, IRFL_UDATA_UDTYPE);
emitir           1129 lj_ffrecord.c      emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, UDTYPE_IO_FILE));
emitir           1132 lj_ffrecord.c    fp = emitir(IRT(IR_FLOAD, IRT_PTR), ud, IRFL_UDATA_FILE);
emitir           1133 lj_ffrecord.c    emitir(IRTG(IR_NE, IRT_PTR), fp, lj_ir_knull(J, IRT_PTR));
emitir           1145 lj_ffrecord.c      TRef buf = emitir(IRT(IR_STRREF, IRT_PGC), str, zero);
emitir           1146 lj_ffrecord.c      TRef len = emitir(IRTI(IR_FLOAD), str, IRFL_STR_LEN);
emitir           1151 lj_ffrecord.c  		emitir(IRT(IR_XLOAD, IRT_U8), buf, IRXLOAD_READONLY);
emitir           1154 lj_ffrecord.c  	emitir(IRTGI(IR_NE), tr, lj_ir_kint(J, -1));
emitir           1158 lj_ffrecord.c  	emitir(IRTGI(IR_EQ), tr, len);
emitir           1169 lj_ffrecord.c      emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, 0));
emitir           1182 lj_ffrecord.c      mtref = emitir(IRT(IR_FLOAD, IRT_TAB), tr, IRFL_TAB_META);
emitir           1185 lj_ffrecord.c      mtref = emitir(IRT(IR_FLOAD, IRT_TAB), tr, IRFL_UDATA_META);
emitir           1191 lj_ffrecord.c    emitir(IRTG(mt ? IR_NE : IR_EQ, IRT_TAB), mtref, lj_ir_knull(J, IRT_TAB));
emitir            141 lj_ir.c            tr = emitir(IRT(IR_CARG, IRT_NIL), tr, va_arg(argp, IRRef));
emitir            145 lj_ir.c          return emitir(CCI_OPTYPE(ci), tr, id);
emitir            411 lj_ir.c              tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
emitir            423 lj_ir.c              tr = emitir(IRTN(IR_CONV), tr, IRCONV_NUM_INT);
emitir            425 lj_ir.c              tr = emitir(IRTG(IR_STRTO, IRT_NUM), tr, 0);
emitir            438 lj_ir.c            tr = emitir(IRT(IR_TOSTR, IRT_STR), tr,
emitir            515 lj_opt_fold.c        fins->op2 = emitir(IRTI(IR_ADD), ir->op2, fins->op2); /* Clobbers fins! */
emitir           1068 lj_opt_fold.c      ref = emitir(IRTN(IR_DIV), lj_ir_knum_one(J), ref);
emitir           1073 lj_opt_fold.c      ref = emitir(IRTN(IR_MUL), ref, ref);
emitir           1075 lj_opt_fold.c      TRef tmp = emitir(IRTN(IR_MUL), ref, ref);
emitir           1078 lj_opt_fold.c  	ref = emitir(IRTN(IR_MUL), ref, tmp);
emitir           1079 lj_opt_fold.c        tmp = emitir(IRTN(IR_MUL), tmp, tmp);
emitir           1081 lj_opt_fold.c      ref = emitir(IRTN(IR_MUL), ref, tmp);
emitir           1264 lj_opt_fold.c    op1 = emitir(IRTI(IR_CONV), op1, mode);
emitir           1265 lj_opt_fold.c    op2 = emitir(IRTI(IR_CONV), op2, mode);
emitir           2060 lj_opt_fold.c        emitir(IRTGI(IR_EQ), fleft->op2, lj_ir_kint(J, len));
emitir           2074 lj_opt_fold.c        TRef tmp = emitir(ot, strref,
emitir           2078 lj_opt_fold.c  	tmp = emitir(IRTI(IR_BAND), tmp,
emitir            328 lj_opt_loop.c        IRRef ref = tref_ref(emitir(ir->ot & ~IRT_ISPHI, op1, op2));
emitir            345 lj_opt_loop.c  	      ref = tref_ref(emitir(IRTN(IR_CONV), ref, IRCONV_NUM_INT));
emitir            347 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_ksimd(J, LJ_KSIMD_NEG));
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            204 lj_record.c    	a = emitir(IRTN(IR_CONV), a, IRCONV_NUM_INT);
emitir            207 lj_record.c    	b = emitir(IRTN(IR_CONV), b, IRCONV_NUM_INT);
emitir            212 lj_record.c        emitir(IRTG(diff ? IR_NE : IR_EQ, ta), a, b);
emitir            251 lj_record.c    	J->slot[s] = emitir(IRTN(IR_CONV), tr, IRCONV_NUM_INT);
emitir            389 lj_record.c        emitir(IRTG(dir ? IR_GE : IR_LT, t), step, zero);
emitir            397 lj_record.c    	    emitir(IRTGI(IR_LE), step, lj_ir_kint(J, (int32_t)0x7fffffff-k));
emitir            400 lj_record.c    	    emitir(IRTGI(IR_GE), step, lj_ir_kint(J, (int32_t)0x80000000-k));
emitir            404 lj_record.c    	TRef tr = emitir(IRTGI(IR_ADDOV), step, stop);
emitir            405 lj_record.c    	emitir(IRTI(IR_USE), tr, 0);  /* ADDOV is weak. Avoid dead result. */
emitir            412 lj_record.c        emitir(IRTGI(dir ? IR_LE : IR_GE), stop, lj_ir_kint(J, k));
emitir            449 lj_record.c        J->base[ra+FORL_IDX] = idx = emitir(IRT(IR_ADD, t), idx, step);
emitir            471 lj_record.c          idx = emitir(IRT(IR_ADD, t), idx, J->scev.step);
emitir            488 lj_record.c    	tr[i] = emitir(IRTG(IR_STRTO, IRT_NUM), tr[i], 0);
emitir            491 lj_record.c    	  tr[i] = emitir(IRTGI(IR_CONV), tr[i], IRCONV_INT_NUM|IRCONV_CHECK);
emitir            494 lj_record.c    	  tr[i] = emitir(IRTN(IR_CONV), tr[i], IRCONV_NUM_INT);
emitir            513 lj_record.c      emitir(IRTG(op, t), tr[FORL_IDX], stop);
emitir            640 lj_record.c        emitir(IRTG(IR_PROF, IRT_NIL), 0, 0);
emitir            648 lj_record.c        emitir(IRTG(IR_PROF, IRT_NIL), 0, 0);
emitir            666 lj_record.c          TRef trpt = emitir(IRT(IR_FLOAD, IRT_PGC), tr, IRFL_FUNC_PC);
emitir            667 lj_record.c          emitir(IRTG(IR_EQ, IRT_PGC), trpt, lj_ir_kptr(J, proto_bc(pt)));
emitir            678 lj_record.c    	TRef trid = emitir(IRT(IR_FLOAD, IRT_U8), tr, IRFL_FUNC_FFID);
emitir            679 lj_record.c    	emitir(IRTG(IR_EQ, IRT_INT), trid, lj_ir_kint(J, fn->c.ffid));
emitir            689 lj_record.c      emitir(IRTG(IR_EQ, IRT_FUNC), tr, kfunc);
emitir            859 lj_record.c          emitir(IRTG(IR_RETF, IRT_PGC), trpt, trpc);
emitir            943 lj_record.c        mix.tab = emitir(IRT(IR_FLOAD, IRT_TAB), ix->tab, IRFL_TAB_META);
emitir            952 lj_record.c    	emitir(IRTG(IR_EQ, IRT_PGC), ix->tab, lj_ir_kptr(J, udataV(&ix->tabv)));
emitir            955 lj_record.c    	TRef tr = emitir(IRT(IR_FLOAD, IRT_U8), ix->tab, IRFL_UDATA_UDTYPE);
emitir            956 lj_record.c    	emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, udtype));
emitir            971 lj_record.c        mix.tab = emitir(IRT(IR_FLOAD, IRT_TAB), ix->tab, IRFL_UDATA_META);
emitir            991 lj_record.c      emitir(IRTG(mt ? IR_NE : IR_EQ, IRT_TAB), mix.tab, lj_ir_knull(J, IRT_TAB));
emitir           1093 lj_record.c          TRef mt2 = emitir(IRT(IR_FLOAD, IRT_TAB), ix->key, IRFL_TAB_META);
emitir           1094 lj_record.c          emitir(IRTG(IR_EQ, IRT_TAB), mt2, ix->mt);
emitir           1096 lj_record.c          TRef mt2 = emitir(IRT(IR_FLOAD, IRT_TAB), ix->key, IRFL_UDATA_META);
emitir           1097 lj_record.c          emitir(IRTG(IR_EQ, IRT_TAB), mt2, ix->mt);
emitir           1134 lj_record.c    	TRef mt2 = emitir(IRT(IR_FLOAD, IRT_TAB), ix->key, IRFL_TAB_META);
emitir           1135 lj_record.c    	emitir(IRTG(IR_EQ, IRT_TAB), mt2, ix->mt);
emitir           1137 lj_record.c    	TRef mt2 = emitir(IRT(IR_FLOAD, IRT_TAB), ix->key, IRFL_UDATA_META);
emitir           1138 lj_record.c    	emitir(IRTG(IR_EQ, IRT_TAB), mt2, ix->mt);
emitir           1272 lj_record.c    	emitir(IRTG(IR_ABC, IRT_P32), asizeref, ofs == 0 ? J->scev.stop :
emitir           1273 lj_record.c    	       emitir(IRTI(IR_ADD), J->scev.stop, ofsref));
emitir           1277 lj_record.c    	  emitir(IRTG(IR_ABC, IRT_P32), asizeref, ikey);
emitir           1282 lj_record.c      emitir(IRTGI(IR_ABC), asizeref, ikey);  /* Emit regular bounds check. */
emitir           1303 lj_record.c          TRef asizeref = emitir(IRTI(IR_FLOAD), ix->tab, IRFL_TAB_ASIZE);
emitir           1307 lj_record.c    	arrayref = emitir(IRT(IR_FLOAD, IRT_PGC), ix->tab, IRFL_TAB_ARRAY);
emitir           1308 lj_record.c    	return emitir(IRT(IR_AREF, IRT_PGC), arrayref, ikey);
emitir           1310 lj_record.c    	emitir(IRTGI(IR_ULE), asizeref, ikey);  /* Inv. bounds check. */
emitir           1321 lj_record.c    	TRef tmp = emitir(IRTI(IR_FLOAD), ix->tab, IRFL_TAB_ASIZE);
emitir           1322 lj_record.c    	emitir(IRTGI(IR_EQ), tmp, lj_ir_kint(J, 0));
emitir           1332 lj_record.c        TRef tmp = emitir(IRTI(IR_FLOAD), ix->tab, IRFL_TAB_HMASK);
emitir           1333 lj_record.c        emitir(IRTGI(IR_EQ), tmp, lj_ir_kint(J, 0));
emitir           1337 lj_record.c        key = emitir(IRTN(IR_CONV), key, IRCONV_NUM_INT);
emitir           1346 lj_record.c          hm = emitir(IRTI(IR_FLOAD), ix->tab, IRFL_TAB_HMASK);
emitir           1347 lj_record.c          emitir(IRTGI(IR_EQ), hm, lj_ir_kint(J, (int32_t)t->hmask));
emitir           1348 lj_record.c          node = emitir(IRT(IR_FLOAD, IRT_PGC), ix->tab, IRFL_TAB_NODE);
emitir           1350 lj_record.c          return emitir(IRTG(IR_HREFK, IRT_PGC), node, kslot);
emitir           1354 lj_record.c      return emitir(IRT(IR_HREF, IRT_PGC), ix->tab, key);
emitir           1436 lj_record.c          emitir(IRTG(IR_EQ, IRT_PGC), xref, lj_ir_kkptr(J, niltvg(J2G(J))));
emitir           1439 lj_record.c          res = emitir(IRTG(loadop, t), xref, 0);
emitir           1464 lj_record.c    	emitir(IRTG(loadop, IRT_NIL), xref, 0);  /* Guard for nil value. */
emitir           1466 lj_record.c    	emitir(IRTG(oldv == niltvg(J2G(J)) ? IR_EQ : IR_NE, IRT_PGC),
emitir           1476 lj_record.c    	  key = emitir(IRTN(IR_CONV), key, IRCONV_NUM_INT);
emitir           1477 lj_record.c    	xref = emitir(IRT(IR_NEWREF, IRT_PGC), ix->tab, key);
emitir           1487 lj_record.c    	emitir(IRTG(IR_NE, IRT_PGC), xref, lj_ir_kkptr(J, niltvg(J2G(J))));
emitir           1491 lj_record.c    	  TRef mtref = emitir(IRT(IR_FLOAD, IRT_TAB), ix->tab, IRFL_TAB_META);
emitir           1492 lj_record.c    	  emitir(IRTG(IR_EQ, IRT_TAB), mtref, lj_ir_knull(J, IRT_TAB));
emitir           1495 lj_record.c    	  emitir(IRTG(loadop, t), xref, 0);  /* Guard for non-nil value. */
emitir           1503 lj_record.c          ix->val = emitir(IRTN(IR_CONV), ix->val, IRCONV_NUM_INT);
emitir           1504 lj_record.c        emitir(IRT(loadop+IRDELTA_L2S, tref_type(ix->val)), xref, ix->val);
emitir           1506 lj_record.c          emitir(IRT(IR_TBAR, IRT_NIL), ix->tab, 0);
emitir           1509 lj_record.c          TRef fref = emitir(IRT(IR_FREF, IRT_PGC), ix->tab, IRFL_TAB_NOMM);
emitir           1510 lj_record.c          emitir(IRT(IR_FSTORE, IRT_U8), fref, lj_ir_kint(J, 0));
emitir           1583 lj_record.c          emitir(IRTG(IR_EQ, IRT_FUNC), fn, kfunc);
emitir           1599 lj_record.c        uref = tref_ref(emitir(IRTG(IR_UREFO, IRT_PGC), fn, uv));
emitir           1605 lj_record.c    	emitir(IRTG(IR_EQ, IRT_PGC),
emitir           1607 lj_record.c    	       emitir(IRT(IR_ADD, IRT_PGC), uref,
emitir           1619 lj_record.c        emitir(IRTG(IR_UGT, IRT_PGC),
emitir           1620 lj_record.c    	   emitir(IRT(IR_SUB, IRT_PGC), uref, REF_BASE),
emitir           1624 lj_record.c        uref = tref_ref(emitir(IRTG(IR_UREFC, IRT_PGC), fn, uv));
emitir           1628 lj_record.c        TRef res = emitir(IRTG(IR_ULOAD, t), uref, 0);
emitir           1634 lj_record.c          val = emitir(IRTN(IR_CONV), val, IRCONV_NUM_INT);
emitir           1635 lj_record.c        emitir(IRT(IR_USTORE, tref_type(val)), uref, val);
emitir           1637 lj_record.c          emitir(IRT(IR_OBAR, IRT_NIL), uref, val);
emitir           1757 lj_record.c          emitir(IRTG(IR_EQ, IRT_FUNC), getslot(J, bc_a(ins)), kfunc);
emitir           1784 lj_record.c        TRef fr = emitir(IRTI(IR_SLOAD), LJ_FR2, IRSLOAD_READONLY|IRSLOAD_FRAME);
emitir           1792 lj_record.c    	  emitir(IRTGI(IR_GE), fr, lj_ir_kint(J, frofs+8*(int32_t)nresults));
emitir           1794 lj_record.c    	  emitir(IRTGI(IR_EQ), fr,
emitir           1796 lj_record.c    	vbase = emitir(IRT(IR_SUB, IRT_IGC), REF_BASE, fr);
emitir           1797 lj_record.c    	vbase = emitir(IRT(IR_ADD, IRT_PGC), vbase, lj_ir_kint(J, frofs-8));
emitir           1800 lj_record.c    	  TRef aref = emitir(IRT(IR_AREF, IRT_PGC),
emitir           1802 lj_record.c    	  TRef tr = emitir(IRTG(IR_VLOAD, t), aref, 0);
emitir           1807 lj_record.c    	emitir(IRTGI(IR_LE), fr, lj_ir_kint(J, frofs));
emitir           1820 lj_record.c    	tridx = emitir(IRTGI(IR_CONV), tridx, IRCONV_INT_NUM|IRCONV_INDEX);
emitir           1822 lj_record.c    	emitir(IRTGI(idx <= nvararg ? IR_GE : IR_LT),
emitir           1826 lj_record.c    	TRef tmp = emitir(IRTI(IR_ADD), fr, lj_ir_kint(J, -frofs));
emitir           1828 lj_record.c    	  emitir(IRTGI(IR_GE), tmp, lj_ir_kint(J, 0));
emitir           1829 lj_record.c    	tr = emitir(IRTI(IR_BSHR), tmp, lj_ir_kint(J, 3));
emitir           1831 lj_record.c    	  tridx = emitir(IRTI(IR_ADD), tridx, lj_ir_kint(J, -1));
emitir           1837 lj_record.c    	  TRef tmp2 = emitir(IRTI(IR_BSHL), tridx, lj_ir_kint(J, 3));
emitir           1838 lj_record.c    	  tmp = emitir(IRTI(IR_ADD), tmp2, tmp);
emitir           1842 lj_record.c    	emitir(IRTGI(IR_LT), fr, tmp);
emitir           1846 lj_record.c    	TRef aref, vbase = emitir(IRT(IR_SUB, IRT_IGC), REF_BASE, fr);
emitir           1847 lj_record.c    	vbase = emitir(IRT(IR_ADD, IRT_PGC), vbase,
emitir           1850 lj_record.c    	aref = emitir(IRT(IR_AREF, IRT_PGC), vbase, tridx);
emitir           1851 lj_record.c    	tr = emitir(IRTG(IR_VLOAD, t), aref, 0);
emitir           1873 lj_record.c      tr = emitir(IRTG(IR_TNEW, IRT_TAB), asize, hbits);
emitir           1898 lj_record.c    	*trp = emitir(IRT(IR_TOSTR, IRT_STR), *trp,
emitir           1904 lj_record.c        tr = hdr = emitir(IRT(IR_BUFHDR, IRT_PGC),
emitir           1907 lj_record.c          tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr, *trp++);
emitir           1909 lj_record.c        tr = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
emitir           2102 lj_record.c    	  ra = emitir(IRTN(IR_CONV), ra, IRCONV_NUM_INT);
emitir           2105 lj_record.c    	  rc = emitir(IRTN(IR_CONV), rc, IRCONV_NUM_INT);
emitir           2131 lj_record.c          emitir(IRTG(irop, ta), ra, rc);
emitir           2190 lj_record.c          rc = emitir(IRTI(IR_FLOAD), rc, IRFL_STR_LEN);
emitir           2293 lj_record.c        ix.tab = emitir(IRT(IR_FLOAD, IRT_TAB), getcurrf(J), IRFL_FUNC_ENV);
emitir           2319 lj_record.c        rc = emitir(IRTG(IR_TDUP, IRT_TAB),
emitir           2636 lj_record.c        TRef tr = emitir(IRT(IR_XLOAD, IRT_U8),
emitir           2638 lj_record.c        tr = emitir(IRTI(IR_BAND), tr, lj_ir_kint(J, (LUA_MASKLINE|LUA_MASKCOUNT)));
emitir           2639 lj_record.c        emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, 0));
emitir            431 lj_snap.c          tr = emitir(IRT(IR_PVAL, irt_type(ir->t)), ref - REF_BIAS, 0);
emitir            554 lj_snap.c      	  J->slot[snap_slot(sn)] = emitir(ir->ot & ~(IRT_MARK|IRT_ISPHI), op1, op2);
emitir            557 lj_snap.c      	  TRef tr = emitir(ir->ot, op1, op2);
emitir            572 lj_snap.c      		  tmp = emitir(irf->ot, tmp, irf->op2);
emitir            575 lj_snap.c      	      tmp = emitir(irr->ot, tmp, key);
emitir            581 lj_snap.c      		val = emitir(IRTN(IR_CONV), val, IRCONV_NUM_INT);
emitir            596 lj_snap.c      		tmp = emitir(IRT(irs->o, t), tmp, val);
emitir            599 lj_snap.c      	      tmp = emitir(irs->ot, tmp, val);
emitir            601 lj_snap.c      	      emitir(IRT(IR_XBAR, IRT_NIL), 0, 0);