Reg               144 lj_asm.c       #define ra_krefreg(ref)		((Reg)(RID_MIN_KREF + (Reg)(ref)))
Reg               240 lj_asm.c             Reg r = va_arg(argp, Reg) & RID_MASK;
Reg               306 lj_asm.c         Reg r;
Reg               318 lj_asm.c       static Reg ra_rematk(ASMState *as, IRRef ref)
Reg               321 lj_asm.c         Reg r;
Reg               395 lj_asm.c       static Reg ra_releasetmp(ASMState *as, IRRef ref)
Reg               398 lj_asm.c         Reg r = ir->r;
Reg               407 lj_asm.c       static Reg ra_restore(ASMState *as, IRRef ref)
Reg               414 lj_asm.c           Reg r = ir->r;
Reg               440 lj_asm.c       static Reg ra_evict(ASMState *as, RegSet allow)
Reg               462 lj_asm.c       static Reg ra_pick(ASMState *as, RegSet allow)
Reg               472 lj_asm.c       static Reg ra_scratch(ASMState *as, RegSet allow)
Reg               474 lj_asm.c         Reg r = ra_pick(as, allow);
Reg               488 lj_asm.c           Reg r = rset_pickbot(work);
Reg               496 lj_asm.c           Reg r = rset_pickbot(work);
Reg               510 lj_asm.c           Reg r = rset_pickbot(work);
Reg               521 lj_asm.c           Reg r = rset_pickbot(work);
Reg               533 lj_asm.c       static Reg ra_allock(ASMState *as, intptr_t k, RegSet allow)
Reg               537 lj_asm.c         Reg r;
Reg               588 lj_asm.c         Reg kr = ra_allock(as, k, RID2RSET(r));
Reg               604 lj_asm.c       static Reg ra_allocref(ASMState *as, IRRef ref, RegSet allow)
Reg               608 lj_asm.c         Reg r;
Reg               647 lj_asm.c       static Reg ra_alloc1(ASMState *as, IRRef ref, RegSet allow)
Reg               649 lj_asm.c         Reg r = IR(ref)->r;
Reg               690 lj_asm.c       static Reg ra_dest(ASMState *as, IRIns *ir, RegSet allow)
Reg               692 lj_asm.c         Reg dest = ir->r;
Reg               713 lj_asm.c         Reg dest = ra_dest(as, ir, RID2RSET(r));
Reg               728 lj_asm.c         Reg left = ir->r;
Reg               775 lj_asm.c         Reg left = ir->r;
Reg               798 lj_asm.c         Reg destlo = ir->r, desthi = (ir+1)->r;
Reg               851 lj_asm.c         Reg r;
Reg               917 lj_asm.c       	Reg r = ra_allocref(as, ref, allow);  /* Allocate a register. */
Reg              1091 lj_asm.c         Reg sb = ra_dest(as, ir, RSET_GPR);
Reg              1105 lj_asm.c           Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, sb));
Reg              1156 lj_asm.c           Reg tmp = ra_releasetmp(as, ASMREF_TMP1);
Reg              1245 lj_asm.c         Reg r = ra_dest(as, ir, RSET_GPR);
Reg              1349 lj_asm.c           Reg down, up = ra_pick(as, ~blocked & allow);  /* Get a free register. */
Reg              1385 lj_asm.c             Reg r = rset_pickbot(phiset);
Reg              1387 lj_asm.c             Reg left = irl->r;
Reg              1421 lj_asm.c           Reg r = rset_pickbot(work);
Reg              1429 lj_asm.c           Reg r = rset_pickbot(work);
Reg              1438 lj_asm.c           Reg r = rset_picktop(work);
Reg              1461 lj_asm.c           Reg r = RID_TMP;
Reg              1463 lj_asm.c           Reg r = RID_RET;
Reg              1487 lj_asm.c           Reg r = RID_XMM0;
Reg              1489 lj_asm.c           Reg r = RID_FPRET;
Reg              1516 lj_asm.c           Reg r = rset_picktop(work);
Reg              1545 lj_asm.c           Reg r;
Reg              1822 lj_asm.c       	Reg r;
Reg              1861 lj_asm.c             Reg r = rset_pickbot(work);
Reg              1880 lj_asm.c             Reg rp = rset_pickbot(work);
Reg                 9 lj_asm_arm.h   static Reg ra_hintalloc(ASMState *as, IRRef ref, Reg hint, RegSet allow)
Reg                11 lj_asm_arm.h     Reg r = IR(ref)->r;
Reg                22 lj_asm_arm.h   static Reg ra_scratchpair(ASMState *as, RegSet allow)
Reg                26 lj_asm_arm.h     Reg r;
Reg                53 lj_asm_arm.h   static Reg ra_alloc2(ASMState *as, IRIns *ir, RegSet allow)
Reg                56 lj_asm_arm.h     Reg left = irl->r, right = irr->r;
Reg               155 lj_asm_arm.h   static Reg asm_fuseahuref(ASMState *as, IRRef ref, int32_t *ofsp, RegSet allow,
Reg               207 lj_asm_arm.h         Reg m = ra_alloc1(as, ir->op1, allow);
Reg               214 lj_asm_arm.h   	Reg s = ra_alloc1(as, ir->op2, rset_exclude(allow, m));
Reg               218 lj_asm_arm.h         Reg m = ra_alloc1(as, ir->op1, allow);
Reg               240 lj_asm_arm.h     Reg base;
Reg               253 lj_asm_arm.h   	Reg rn, rm;
Reg               282 lj_asm_arm.h   	Reg rn = ra_alloc1(as, ir->op1, allow);
Reg               292 lj_asm_arm.h   	Reg rn = ra_alloc1(as, ref, allow);
Reg               293 lj_asm_arm.h   	Reg rm = ra_allock(as, ofs, rset_exclude(allow, rn));
Reg               323 lj_asm_arm.h       Reg dest = ra_dest(as, ir, RSET_FPR);
Reg               324 lj_asm_arm.h       Reg add = ra_hintalloc(as, rref, dest, RSET_FPR);
Reg               325 lj_asm_arm.h       Reg right, left = ra_alloc2(as, irm,
Reg               344 lj_asm_arm.h     Reg gpr = REGARG_FIRSTGPR;
Reg               346 lj_asm_arm.h     Reg gpr, fpr = REGARG_FIRSTFPR, fprodd = 0;
Reg               361 lj_asm_arm.h         Reg src;
Reg               416 lj_asm_arm.h   	  Reg r = ra_alloc1(as, ref, RSET_GPR);
Reg               439 lj_asm_arm.h   	Reg dest = (ra_dest(as, ir, RSET_FPR) & 15);
Reg               470 lj_asm_arm.h       Reg freg = ra_alloc1(as, func, RSET_RANGE(RID_R4, RID_R12+1));
Reg               482 lj_asm_arm.h     Reg base = ra_alloc1(as, REF_BASE, RSET_GPR);
Reg               503 lj_asm_arm.h     Reg tmp = ra_scratch(as, rset_exclude(RSET_FPR, left));
Reg               504 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               516 lj_asm_arm.h     Reg left = ra_alloc1(as, ir->op1, allow);
Reg               517 lj_asm_arm.h     Reg right = ra_alloc1(as, ir->op2, rset_clear(allow, left));
Reg               518 lj_asm_arm.h     Reg tmp = ra_scratch(as, rset_clear(allow, right));
Reg               519 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               541 lj_asm_arm.h       Reg dest = ra_dest(as, ir, RSET_FPR);
Reg               546 lj_asm_arm.h         Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               559 lj_asm_arm.h         Reg left = ra_alloc1(as, lref, RSET_FPR);
Reg               560 lj_asm_arm.h         Reg tmp = ra_scratch(as, rset_exclude(RSET_FPR, left));
Reg               561 lj_asm_arm.h         Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               572 lj_asm_arm.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               574 lj_asm_arm.h         Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               599 lj_asm_arm.h     Reg rlo = 0, rhi = 0, tmp;
Reg               609 lj_asm_arm.h   	Reg r = (ir+i)->r;
Reg               679 lj_asm_arm.h       Reg type;
Reg               682 lj_asm_arm.h         Reg src = ra_alloc1(as, ref, allow);
Reg               695 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               696 lj_asm_arm.h     Reg idx, base;
Reg               725 lj_asm_arm.h     Reg dest = ra_dest(as, ir, allow);
Reg               726 lj_asm_arm.h     Reg tab = ra_alloc1(as, ir->op1, rset_clear(allow, dest));
Reg               727 lj_asm_arm.h     Reg key = 0, keyhi = 0, keynumhi = RID_NONE, tmp = RID_TMP;
Reg               866 lj_asm_arm.h     Reg dest = (ra_used(ir) || ofs > 4095) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
Reg               867 lj_asm_arm.h     Reg node = ra_alloc1(as, ir->op1, RSET_GPR);
Reg               868 lj_asm_arm.h     Reg key = RID_NONE, type = RID_TMP, idx = node;
Reg               912 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               918 lj_asm_arm.h       Reg uv = ra_scratch(as, RSET_GPR);
Reg               919 lj_asm_arm.h       Reg func = ra_alloc1(as, ir->op1, RSET_GPR);
Reg               942 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               944 lj_asm_arm.h     Reg r;
Reg               949 lj_asm_arm.h       Reg right, left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1003 lj_asm_arm.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1004 lj_asm_arm.h       Reg idx = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1025 lj_asm_arm.h       Reg src = ra_alloc1(as, ir->op2, RSET_GPR);
Reg              1027 lj_asm_arm.h       Reg idx = ra_alloc1(as, irf->op1, rset_exclude(RSET_GPR, src));
Reg              1039 lj_asm_arm.h     Reg dest = ra_dest(as, ir,
Reg              1048 lj_asm_arm.h       Reg src = ra_alloc1(as, ir->op2,
Reg              1061 lj_asm_arm.h     Reg dest = RID_NONE, type = RID_NONE, idx;
Reg              1103 lj_asm_arm.h       Reg idx, src = RID_NONE, type = RID_NONE;
Reg              1134 lj_asm_arm.h     Reg dest = RID_NONE, type = RID_NONE, base;
Reg              1152 lj_asm_arm.h       Reg tmp = RID_NONE;
Reg              1239 lj_asm_arm.h         Reg r = ra_alloc1(as, ir->op2, allow);
Reg              1259 lj_asm_arm.h       Reg r = k ? RID_R1 : ra_allock(as, id, allow);
Reg              1279 lj_asm_arm.h     Reg tab = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1280 lj_asm_arm.h     Reg link = ra_scratch(as, rset_exclude(RSET_GPR, tab));
Reg              1281 lj_asm_arm.h     Reg gr = ra_allock(as, i32ptr(J2G(as->J)),
Reg              1283 lj_asm_arm.h     Reg mark = RID_TMP;
Reg              1302 lj_asm_arm.h     Reg obj, val, tmp;
Reg              1330 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1331 lj_asm_arm.h     Reg right, left = ra_alloc2(as, ir, RSET_FPR);
Reg              1338 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1339 lj_asm_arm.h     Reg left = ra_hintalloc(as, ir->op1, dest, RSET_FPR);
Reg              1349 lj_asm_arm.h     Reg dest, src;
Reg              1399 lj_asm_arm.h     Reg left, dest = ra_dest(as, ir, RSET_GPR);
Reg              1427 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1428 lj_asm_arm.h     Reg left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              1435 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1436 lj_asm_arm.h     Reg left = ra_alloc1(as, ir->op1, rset_exclude(RSET_GPR, dest));
Reg              1437 lj_asm_arm.h     Reg right = ra_alloc1(as, ir->op2, rset_exclude(RSET_GPR, left));
Reg              1438 lj_asm_arm.h     Reg tmp = RID_NONE;
Reg              1532 lj_asm_arm.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1545 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1546 lj_asm_arm.h     Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1550 lj_asm_arm.h       Reg tmp2 = dest;
Reg              1569 lj_asm_arm.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1570 lj_asm_arm.h       Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1574 lj_asm_arm.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1575 lj_asm_arm.h       Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1576 lj_asm_arm.h       Reg right = ra_alloc1(as, ir->op2, rset_exclude(RSET_GPR, left));
Reg              1590 lj_asm_arm.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1591 lj_asm_arm.h     Reg left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              1592 lj_asm_arm.h     Reg right = 0;
Reg              1616 lj_asm_arm.h     Reg r;
Reg              1638 lj_asm_arm.h     Reg dest = (ra_dest(as, ir, RSET_FPR) & 15);
Reg              1639 lj_asm_arm.h     Reg right, left = ra_alloc2(as, ir, RSET_FPR);
Reg              1687 lj_asm_arm.h     Reg r;
Reg              1706 lj_asm_arm.h     Reg left, right;
Reg              1733 lj_asm_arm.h     Reg left;
Reg              1738 lj_asm_arm.h       Reg tmp = lref; lref = rref; rref = tmp;
Reg              1749 lj_asm_arm.h         Reg bleft;
Reg              1751 lj_asm_arm.h   	Reg tmp = blref; blref = brref; brref = tmp;
Reg              1796 lj_asm_arm.h     Reg leftlo, lefthi;
Reg              1928 lj_asm_arm.h     Reg pbase;
Reg              1981 lj_asm_arm.h         Reg tmp;
Reg              1990 lj_asm_arm.h         Reg src = ra_alloc1(as, ref, RSET_FPR);
Reg              1995 lj_asm_arm.h         Reg type;
Reg              1998 lj_asm_arm.h   	Reg src = ra_alloc1(as, ref, rset_exclude(RSET_GPREVEN, RID_BASE));
Reg              2027 lj_asm_arm.h     Reg tmp1, tmp2;
Reg              2073 lj_asm_arm.h       Reg r = ra_dest(as, ir, RSET_GPR);
Reg              2101 lj_asm_arm.h       Reg r = irp->r;
Reg              2148 lj_asm_arm.h   static Reg asm_setup_call_slots(ASMState *as, IRIns *ir, const CCallInfo *ci)
Reg                12 lj_asm_arm64.h static Reg ra_hintalloc(ASMState *as, IRRef ref, Reg hint, RegSet allow)
Reg                14 lj_asm_arm64.h   Reg r = IR(ref)->r;
Reg                25 lj_asm_arm64.h static Reg ra_alloc2(ASMState *as, IRIns *ir, RegSet allow)
Reg                28 lj_asm_arm64.h   Reg left = irl->r, right = irr->r;
Reg               161 lj_asm_arm64.h static Reg asm_fuseahuref(ASMState *as, IRRef ref, int32_t *ofsp, RegSet allow,
Reg               178 lj_asm_arm64.h 	  Reg base = ra_alloc1(as, ir->op1, allow);
Reg               236 lj_asm_arm64.h 	Reg m = ra_alloc1(as, irl->op1, allow);
Reg               239 lj_asm_arm64.h 	Reg m = ra_alloc1(as, ir->op1, allow);
Reg               244 lj_asm_arm64.h       Reg m = ra_alloc1(as, ir->op1, allow);
Reg               256 lj_asm_arm64.h   Reg base;
Reg               263 lj_asm_arm64.h 	Reg rn, rm;
Reg               298 lj_asm_arm64.h 	Reg rn = ra_alloc1(as, ir->op1, allow);
Reg               305 lj_asm_arm64.h 	    Reg rm = ra_alloc1(as, irr->op1, rset_exclude(allow, rn));
Reg               319 lj_asm_arm64.h 	Reg rn = ra_alloc1(as, ref, allow);
Reg               320 lj_asm_arm64.h 	Reg rm = ra_allock(as, ofs, rset_exclude(allow, rn));
Reg               340 lj_asm_arm64.h     Reg dest = ra_dest(as, ir, RSET_FPR);
Reg               341 lj_asm_arm64.h     Reg add = ra_hintalloc(as, rref, dest, RSET_FPR);
Reg               342 lj_asm_arm64.h     Reg left = ra_alloc2(as, irm,
Reg               344 lj_asm_arm64.h     Reg right = (left >> 8); left &= 255;
Reg               368 lj_asm_arm64.h 	Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               369 lj_asm_arm64.h 	Reg left = ra_alloc1(as, irl->op1, RSET_GPR);
Reg               399 lj_asm_arm64.h 	Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               400 lj_asm_arm64.h 	Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               401 lj_asm_arm64.h 	Reg right = ra_alloc1(as, rref, rset_exclude(RSET_GPR, left));
Reg               417 lj_asm_arm64.h   Reg gpr, fpr = REGARG_FIRSTFPR;
Reg               433 lj_asm_arm64.h 	  Reg r = ra_alloc1(as, ref, RSET_FPR);
Reg               443 lj_asm_arm64.h 	  Reg r = ra_alloc1(as, ref, RSET_GPR);
Reg               463 lj_asm_arm64.h 	Reg dest = ra_dest(as, ir, RSET_FPR) & 31;
Reg               490 lj_asm_arm64.h     Reg freg = ra_alloc1(as, func, RSET_RANGE(RID_X8, RID_MAX_GPR)-RSET_FIXED);
Reg               502 lj_asm_arm64.h   Reg base = ra_alloc1(as, REF_BASE, RSET_GPR);
Reg               522 lj_asm_arm64.h   Reg tmp = ra_scratch(as, rset_exclude(RSET_FPR, left));
Reg               523 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               533 lj_asm_arm64.h   Reg left = ra_alloc1(as, ir->op1, allow);
Reg               534 lj_asm_arm64.h   Reg right = ra_alloc1(as, ir->op2, rset_clear(allow, left));
Reg               535 lj_asm_arm64.h   Reg tmp = ra_scratch(as, rset_clear(allow, right));
Reg               536 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               549 lj_asm_arm64.h     Reg dest = ra_dest(as, ir, RSET_FPR);
Reg               554 lj_asm_arm64.h       Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               570 lj_asm_arm64.h       Reg left = ra_alloc1(as, lref, RSET_FPR);
Reg               571 lj_asm_arm64.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               582 lj_asm_arm64.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               583 lj_asm_arm64.h     Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               590 lj_asm_arm64.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               596 lj_asm_arm64.h 	Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               604 lj_asm_arm64.h 	Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               617 lj_asm_arm64.h   Reg dest = 0, tmp;
Reg               657 lj_asm_arm64.h     Reg src = ra_alloc1(as, ref, allow);
Reg               660 lj_asm_arm64.h       Reg type = ra_allock(as, (int64_t)irt_toitype(ir->t) << 47, allow);
Reg               664 lj_asm_arm64.h       Reg type = ra_allock(as, (int32_t)irt_toitype(ir->t), allow);
Reg               692 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               693 lj_asm_arm64.h   Reg idx, base;
Reg               722 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, allow);
Reg               723 lj_asm_arm64.h   Reg tab = ra_alloc1(as, ir->op1, rset_clear(allow, dest));
Reg               724 lj_asm_arm64.h   Reg key = 0, tmp = RID_TMP;
Reg               783 lj_asm_arm64.h       Reg tisnum = ra_allock(as, LJ_TISNUM << 15, allow);
Reg               784 lj_asm_arm64.h       Reg ftmp = ra_scratch(as, rset_exclude(RSET_FPR, key));
Reg               793 lj_asm_arm64.h     Reg scr;
Reg               806 lj_asm_arm64.h     Reg type, scr;
Reg               817 lj_asm_arm64.h     Reg type = ra_allock(as, (int32_t)irt_toitype(kt), allow);
Reg               830 lj_asm_arm64.h       Reg tmphash = ra_allock(as, khash, allow);
Reg               872 lj_asm_arm64.h   Reg dest = (ra_used(ir) || bigofs) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
Reg               873 lj_asm_arm64.h   Reg node = ra_alloc1(as, ir->op1, RSET_GPR);
Reg               874 lj_asm_arm64.h   Reg key, idx = node;
Reg               902 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               908 lj_asm_arm64.h     Reg uv = ra_scratch(as, RSET_GPR);
Reg               909 lj_asm_arm64.h     Reg func = ra_alloc1(as, ir->op1, RSET_GPR);
Reg               933 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, allow);
Reg               934 lj_asm_arm64.h   Reg base = ra_alloc1(as, ir->op1, allow);
Reg               975 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               976 lj_asm_arm64.h   Reg idx;
Reg               999 lj_asm_arm64.h     Reg src = ra_alloc1(as, ir->op2, RSET_GPR);
Reg              1001 lj_asm_arm64.h     Reg idx = ra_alloc1(as, irf->op1, rset_exclude(RSET_GPR, src));
Reg              1009 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, irt_isfp(ir->t) ? RSET_FPR : RSET_GPR);
Reg              1017 lj_asm_arm64.h     Reg src = ra_alloc1(as, ir->op2, irt_isfp(ir->t) ? RSET_FPR : RSET_GPR);
Reg              1025 lj_asm_arm64.h   Reg idx, tmp, type;
Reg              1031 lj_asm_arm64.h     Reg dest = ra_dest(as, ir, allow);
Reg              1070 lj_asm_arm64.h     Reg idx, src = RID_NONE, tmp = RID_TMP, type = RID_NONE;
Reg              1111 lj_asm_arm64.h   Reg dest = RID_NONE, base;
Reg              1120 lj_asm_arm64.h     Reg tmp = RID_NONE;
Reg              1151 lj_asm_arm64.h     Reg tmp;
Reg              1172 lj_asm_arm64.h       Reg type = ra_scratch(as, allow);
Reg              1205 lj_asm_arm64.h     Reg r = ra_alloc1(as, ir->op2, allow);
Reg              1221 lj_asm_arm64.h     Reg r = (id < 65536) ? RID_X1 : ra_allock(as, id, allow);
Reg              1241 lj_asm_arm64.h   Reg tab = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1242 lj_asm_arm64.h   Reg link = ra_scratch(as, rset_exclude(RSET_GPR, tab));
Reg              1243 lj_asm_arm64.h   Reg gr = ra_allock(as, i64ptr(J2G(as->J)),
Reg              1245 lj_asm_arm64.h   Reg mark = RID_TMP;
Reg              1265 lj_asm_arm64.h   Reg obj, val, tmp;
Reg              1290 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1291 lj_asm_arm64.h   Reg right, left = ra_alloc2(as, ir, RSET_FPR);
Reg              1298 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1299 lj_asm_arm64.h   Reg left = ra_hintalloc(as, ir->op1, dest, RSET_FPR);
Reg              1341 lj_asm_arm64.h   Reg left, dest = ra_dest(as, ir, RSET_GPR);
Reg              1368 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1369 lj_asm_arm64.h   Reg left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              1376 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1377 lj_asm_arm64.h   Reg left = ra_alloc1(as, ir->op1, rset_exclude(RSET_GPR, dest));
Reg              1378 lj_asm_arm64.h   Reg right = ra_alloc1(as, ir->op2, rset_exclude(RSET_GPR, left));
Reg              1489 lj_asm_arm64.h     Reg left, dest = ra_dest(as, ir, RSET_GPR);
Reg              1516 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1524 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1525 lj_asm_arm64.h   Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1533 lj_asm_arm64.h     Reg left, dest = ra_dest(as, ir, RSET_GPR);
Reg              1562 lj_asm_arm64.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1563 lj_asm_arm64.h     Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1564 lj_asm_arm64.h     Reg right = ra_alloc1(as, ir->op2, rset_exclude(RSET_GPR, left));
Reg              1577 lj_asm_arm64.h   Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1578 lj_asm_arm64.h   Reg left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              1579 lj_asm_arm64.h   Reg right = ra_alloc1(as, ir->op2, rset_exclude(RSET_GPR, left));
Reg              1586 lj_asm_arm64.h   Reg dest = (ra_dest(as, ir, RSET_FPR) & 31);
Reg              1587 lj_asm_arm64.h   Reg right, left = ra_alloc2(as, ir, RSET_FPR);
Reg              1625 lj_asm_arm64.h   Reg left, right;
Reg              1651 lj_asm_arm64.h   Reg left;
Reg              1672 lj_asm_arm64.h       Reg bleft;
Reg              1674 lj_asm_arm64.h 	Reg tmp = blref; blref = brref; brref = tmp;
Reg              1747 lj_asm_arm64.h   Reg pbase;
Reg              1798 lj_asm_arm64.h       Reg src = ra_alloc1(as, ref, RSET_FPR);
Reg              1816 lj_asm_arm64.h   Reg tmp1, tmp2;
Reg              1864 lj_asm_arm64.h     Reg r = ra_dest(as, ir, RSET_GPR);
Reg              1892 lj_asm_arm64.h     Reg r = irp->r;
Reg              1941 lj_asm_arm64.h static Reg asm_setup_call_slots(ASMState *as, IRIns *ir, const CCallInfo *ci)
Reg                 9 lj_asm_mips.h  static Reg ra_hintalloc(ASMState *as, IRRef ref, Reg hint, RegSet allow)
Reg                11 lj_asm_mips.h    Reg r = IR(ref)->r;
Reg                22 lj_asm_mips.h  static Reg ra_alloc1z(ASMState *as, IRRef ref, RegSet allow)
Reg                24 lj_asm_mips.h    Reg r = IR(ref)->r;
Reg                36 lj_asm_mips.h  static Reg ra_alloc2(ASMState *as, IRIns *ir, RegSet allow)
Reg                39 lj_asm_mips.h    Reg left = irl->r, right = irr->r;
Reg               140 lj_asm_mips.h  static Reg asm_fuseahuref(ASMState *as, IRRef ref, int32_t *ofsp, RegSet allow)
Reg               189 lj_asm_mips.h    Reg base;
Reg               211 lj_asm_mips.h  	Reg right, left = ra_alloc2(as, ir, allow);
Reg               232 lj_asm_mips.h    Reg gpr = REGARG_FIRSTGPR;
Reg               234 lj_asm_mips.h    Reg gpr, fpr = REGARG_FIRSTFPR;
Reg               266 lj_asm_mips.h  	    Reg r;
Reg               298 lj_asm_mips.h  	  Reg r = ra_alloc1z(as, ref, !LJ_SOFTFP && irt_isfp(ir->t) ? RSET_FPR : RSET_GPR);
Reg               349 lj_asm_mips.h  	Reg dest = ir->r;
Reg               395 lj_asm_mips.h      Reg r = ra_alloc1(as, func, RID2RSET(RID_CFUNCADDR));
Reg               427 lj_asm_mips.h    Reg base = ra_alloc1(as, REF_BASE, RSET_GPR);
Reg               445 lj_asm_mips.h    Reg tmp = ra_scratch(as, rset_exclude(RSET_FPR, left));
Reg               446 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               457 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               458 lj_asm_mips.h    Reg left = ra_alloc1(as, ir->op1, allow);
Reg               459 lj_asm_mips.h    Reg right = ra_alloc1(as, ir->op2, rset_clear(allow, left));
Reg               460 lj_asm_mips.h    Reg tmp = ra_scratch(as, rset_clear(allow, right));
Reg               484 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               512 lj_asm_mips.h      Reg dest = ra_dest(as, ir, RSET_FPR);
Reg               518 lj_asm_mips.h        Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               519 lj_asm_mips.h        Reg tmp = ra_scratch(as, rset_exclude(RSET_FPR, dest));
Reg               533 lj_asm_mips.h        Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               534 lj_asm_mips.h        Reg tmp = ra_scratch(as, rset_exclude(RSET_FPR, dest));
Reg               552 lj_asm_mips.h        Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               571 lj_asm_mips.h        Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               572 lj_asm_mips.h        Reg left = ra_alloc1(as, lref, RSET_FPR);
Reg               573 lj_asm_mips.h        Reg tmp = ra_scratch(as, rset_exclude(RSET_FPR, left));
Reg               674 lj_asm_mips.h      Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               676 lj_asm_mips.h        Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg               700 lj_asm_mips.h  	  Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               712 lj_asm_mips.h  	  Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg               736 lj_asm_mips.h  	Reg r = (ir+i)->r;
Reg               745 lj_asm_mips.h        Reg rhi = ra_dest(as, ir+1, RSET_GPR);
Reg               746 lj_asm_mips.h        Reg rlo = ra_dest(as, ir, rset_exclude(RSET_GPR, rhi));
Reg               780 lj_asm_mips.h      Reg src = ra_alloc1(as, ref, allow);
Reg               781 lj_asm_mips.h      Reg type = ra_allock(as, (int64_t)irt_toitype(ir->t) << 47,
Reg               807 lj_asm_mips.h      Reg type;
Reg               810 lj_asm_mips.h        Reg src = ra_alloc1(as, ref, allow);
Reg               828 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               829 lj_asm_mips.h    Reg idx, base;
Reg               859 lj_asm_mips.h    Reg dest = ra_dest(as, ir, allow);
Reg               860 lj_asm_mips.h    Reg tab = ra_alloc1(as, ir->op1, rset_clear(allow, dest));
Reg               861 lj_asm_mips.h    Reg key = RID_NONE, type = RID_NONE, tmpnum = RID_NONE, tmp1 = RID_TMP, tmp2;
Reg               863 lj_asm_mips.h    Reg cmp64 = RID_NONE;
Reg               986 lj_asm_mips.h      Reg tmphash = tmp1;
Reg              1057 lj_asm_mips.h    Reg dest = (ra_used(ir)||ofs > 32736) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
Reg              1058 lj_asm_mips.h    Reg node = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1060 lj_asm_mips.h    Reg idx = node;
Reg              1062 lj_asm_mips.h    Reg key = RID_NONE, type = RID_TMP;
Reg              1065 lj_asm_mips.h    Reg key = ra_scratch(as, allow);
Reg              1113 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1119 lj_asm_mips.h      Reg uv = ra_scratch(as, RSET_GPR);
Reg              1120 lj_asm_mips.h      Reg func = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1142 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1145 lj_asm_mips.h    Reg r;
Reg              1149 lj_asm_mips.h      Reg right, left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1175 lj_asm_mips.h    Reg dest = ra_dest(as, ir, allow);
Reg              1176 lj_asm_mips.h    Reg base = ra_alloc1(as, ir->op1, allow);
Reg              1217 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1219 lj_asm_mips.h    Reg idx;
Reg              1242 lj_asm_mips.h      Reg src = ra_alloc1z(as, ir->op2, RSET_GPR);
Reg              1244 lj_asm_mips.h      Reg idx = ra_alloc1(as, irf->op1, rset_exclude(RSET_GPR, src));
Reg              1254 lj_asm_mips.h    Reg dest = ra_dest(as, ir,
Reg              1263 lj_asm_mips.h      Reg src = ra_alloc1z(as, ir->op2,
Reg              1275 lj_asm_mips.h    Reg dest = RID_NONE, type = RID_TMP, idx;
Reg              1332 lj_asm_mips.h    Reg idx, src = RID_NONE, type = RID_NONE;
Reg              1356 lj_asm_mips.h      Reg tmp = RID_TMP;
Reg              1382 lj_asm_mips.h    Reg dest = RID_NONE, type = RID_NONE, base;
Reg              1417 lj_asm_mips.h  	Reg tmp = ra_scratch(as, LJ_SOFTFP ? RSET_GPR : RSET_FPR);
Reg              1431 lj_asm_mips.h  	Reg tmp = ra_scratch(as, RSET_GPR);
Reg              1467 lj_asm_mips.h        Reg ktype = ra_allock(as, irt_toitype(t), allow);
Reg              1540 lj_asm_mips.h        Reg r = ra_alloc1z(as, ir->op2, allow);
Reg              1581 lj_asm_mips.h    Reg tab = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1582 lj_asm_mips.h    Reg mark = ra_scratch(as, rset_exclude(RSET_GPR, tab));
Reg              1583 lj_asm_mips.h    Reg link = RID_TMP;
Reg              1600 lj_asm_mips.h    Reg obj, val, tmp;
Reg              1626 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1627 lj_asm_mips.h    Reg right, left = ra_alloc2(as, ir, RSET_FPR);
Reg              1634 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1635 lj_asm_mips.h    Reg left = ra_hintalloc(as, ir->op1, dest, RSET_FPR);
Reg              1675 lj_asm_mips.h      Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1676 lj_asm_mips.h      Reg right, left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              1699 lj_asm_mips.h      Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1700 lj_asm_mips.h      Reg right, left = ra_alloc2(as, ir, RSET_GPR);
Reg              1715 lj_asm_mips.h      Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1716 lj_asm_mips.h      Reg right, left = ra_alloc2(as, ir, RSET_GPR);
Reg              1774 lj_asm_mips.h      Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1775 lj_asm_mips.h      Reg left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              1781 lj_asm_mips.h      Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1782 lj_asm_mips.h      Reg left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              1793 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1794 lj_asm_mips.h    Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1804 lj_asm_mips.h    Reg right, left, tmp, dest = ra_dest(as, ir, RSET_GPR);
Reg              1841 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1842 lj_asm_mips.h    Reg tmp, right, left = ra_alloc2(as, ir, RSET_GPR);
Reg              1856 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1857 lj_asm_mips.h    Reg right, left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1884 lj_asm_mips.h  	Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, left));
Reg              1895 lj_asm_mips.h      Reg tmp = ra_scratch(as, rset_exclude(rset_exclude(RSET_GPR, left), right));
Reg              1905 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1906 lj_asm_mips.h    Reg right, left = ra_alloc2(as, ir, RSET_GPR);
Reg              1915 lj_asm_mips.h      Reg tmp = ra_scratch(as, rset_exclude(rset_exclude(RSET_GPR, left), right));
Reg              1925 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1926 lj_asm_mips.h    Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1939 lj_asm_mips.h    Reg left, right, dest = ra_dest(as, ir, RSET_GPR);
Reg              1953 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1954 lj_asm_mips.h    Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1960 lj_asm_mips.h      Reg tmp = ra_scratch(as, rset_exclude(rset_exclude(RSET_GPR, left), dest));
Reg              1984 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1985 lj_asm_mips.h    Reg right, left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              2003 lj_asm_mips.h    Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              2010 lj_asm_mips.h      Reg right, left = ra_alloc2(as, ir, RSET_GPR);
Reg              2027 lj_asm_mips.h      Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              2030 lj_asm_mips.h        Reg left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              2033 lj_asm_mips.h        Reg right, left = ra_alloc2(as, ir, RSET_GPR);
Reg              2071 lj_asm_mips.h      Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              2072 lj_asm_mips.h      Reg right, left = ra_alloc2(as, ir, RSET_FPR);
Reg              2083 lj_asm_mips.h      Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              2084 lj_asm_mips.h      Reg right, left = ra_alloc2(as, ir, RSET_GPR);
Reg              2108 lj_asm_mips.h    Reg r;
Reg              2177 lj_asm_mips.h      Reg right, left = ra_alloc2(as, ir, RSET_FPR);
Reg              2183 lj_asm_mips.h      Reg right, left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              2210 lj_asm_mips.h    Reg right, left = ra_alloc2(as, ir, (!LJ_SOFTFP && irt_isnum(ir->t)) ?
Reg              2232 lj_asm_mips.h    Reg rightlo, leftlo, righthi, lefthi = ra_alloc2(as, ir, RSET_GPR);
Reg              2250 lj_asm_mips.h    Reg tmp, right, left = ra_alloc2(as, ir, RSET_GPR);
Reg              2368 lj_asm_mips.h    Reg tmp, pbase = irp ? (ra_hasreg(irp->r) ? irp->r : RID_TMP) : RID_BASE;
Reg              2413 lj_asm_mips.h        Reg tmp;
Reg              2422 lj_asm_mips.h        Reg src = ra_alloc1(as, ref, rset_exclude(RSET_GPR, RID_BASE));
Reg              2425 lj_asm_mips.h        Reg src = ra_alloc1(as, ref, RSET_FPR);
Reg              2431 lj_asm_mips.h        Reg type;
Reg              2434 lj_asm_mips.h  	Reg src = ra_alloc1(as, ref, allow);
Reg              2466 lj_asm_mips.h    Reg tmp;
Reg              2509 lj_asm_mips.h    Reg r = ir->r;
Reg              2524 lj_asm_mips.h    Reg r = ir->r;
Reg              2564 lj_asm_mips.h  static Reg asm_setup_call_slots(ASMState *as, IRIns *ir, const CCallInfo *ci)
Reg                 9 lj_asm_ppc.h   static Reg ra_hintalloc(ASMState *as, IRRef ref, Reg hint, RegSet allow)
Reg                11 lj_asm_ppc.h     Reg r = IR(ref)->r;
Reg                22 lj_asm_ppc.h   static Reg ra_alloc2(ASMState *as, IRIns *ir, RegSet allow)
Reg                25 lj_asm_ppc.h     Reg left = irl->r, right = irr->r;
Reg               116 lj_asm_ppc.h   static Reg asm_fuseahuref(ASMState *as, IRRef ref, int32_t *ofsp, RegSet allow)
Reg               133 lj_asm_ppc.h   	  Reg base = ra_alloc1(as, ir->op1, allow);
Reg               134 lj_asm_ppc.h   	  Reg idx = ra_alloc1(as, ir->op2, rset_exclude(RSET_GPR, base));
Reg               170 lj_asm_ppc.h     Reg base;
Reg               178 lj_asm_ppc.h   	Reg right, left = ra_alloc2(as, ir, allow);
Reg               194 lj_asm_ppc.h   	Reg tmp, right, left = ra_alloc2(as, ir, allow);
Reg               202 lj_asm_ppc.h   	Reg left = ra_alloc1(as, ref, allow);
Reg               203 lj_asm_ppc.h   	Reg right = ra_allock(as, ofs, rset_exclude(allow, left));
Reg               218 lj_asm_ppc.h     Reg right, left;
Reg               240 lj_asm_ppc.h       Reg dest = ra_dest(as, ir, RSET_FPR);
Reg               241 lj_asm_ppc.h       Reg add = ra_alloc1(as, rref, RSET_FPR);
Reg               242 lj_asm_ppc.h       Reg right, left = ra_alloc2(as, irm, rset_exclude(RSET_FPR, add));
Reg               258 lj_asm_ppc.h     Reg gpr = REGARG_FIRSTGPR;
Reg               260 lj_asm_ppc.h     Reg fpr = REGARG_FIRSTFPR;
Reg               275 lj_asm_ppc.h   	  Reg r = ra_alloc1(as, ref, RSET_FPR);
Reg               288 lj_asm_ppc.h   	  Reg r = ra_alloc1(as, ref, RSET_GPR);
Reg               327 lj_asm_ppc.h   	Reg dest = ir->r;
Reg               363 lj_asm_ppc.h       Reg freg = ra_alloc1(as, func, allow);
Reg               376 lj_asm_ppc.h     Reg base = ra_alloc1(as, REF_BASE, RSET_GPR);
Reg               396 lj_asm_ppc.h     Reg tmp = ra_scratch(as, rset_clear(allow, left));
Reg               397 lj_asm_ppc.h     Reg fbias = ra_scratch(as, rset_clear(allow, tmp));
Reg               398 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               399 lj_asm_ppc.h     Reg hibias = ra_allock(as, 0x43300000, rset_exclude(RSET_GPR, dest));
Reg               417 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               418 lj_asm_ppc.h     Reg left = ra_alloc1(as, ir->op1, allow);
Reg               419 lj_asm_ppc.h     Reg right = ra_alloc1(as, ir->op2, rset_clear(allow, left));
Reg               420 lj_asm_ppc.h     Reg tmp = ra_scratch(as, rset_clear(allow, right));
Reg               443 lj_asm_ppc.h       Reg dest = ra_dest(as, ir, RSET_FPR);
Reg               453 lj_asm_ppc.h         Reg left = ra_alloc1(as, lref, allow);
Reg               454 lj_asm_ppc.h         Reg hibias = ra_allock(as, 0x43300000, rset_clear(allow, left));
Reg               455 lj_asm_ppc.h         Reg fbias = ra_scratch(as, rset_exclude(RSET_FPR, dest));
Reg               473 lj_asm_ppc.h         Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               474 lj_asm_ppc.h         Reg left = ra_alloc1(as, lref, RSET_FPR);
Reg               475 lj_asm_ppc.h         Reg tmp = ra_scratch(as, rset_exclude(RSET_FPR, left));
Reg               478 lj_asm_ppc.h   	Reg tmpi = ra_scratch(as, rset_exclude(RSET_GPR, dest));
Reg               503 lj_asm_ppc.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               505 lj_asm_ppc.h         Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg               530 lj_asm_ppc.h   	Reg r = (ir+i)->r;
Reg               539 lj_asm_ppc.h         Reg rhi = ra_dest(as, ir+1, RSET_GPR);
Reg               540 lj_asm_ppc.h         Reg rlo = ra_dest(as, ir, rset_exclude(RSET_GPR, rhi));
Reg               574 lj_asm_ppc.h       Reg type;
Reg               577 lj_asm_ppc.h         Reg src = ra_alloc1(as, ref, allow);
Reg               590 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               591 lj_asm_ppc.h     Reg idx, base;
Reg               621 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, allow);
Reg               622 lj_asm_ppc.h     Reg tab = ra_alloc1(as, ir->op1, rset_clear(allow, dest));
Reg               623 lj_asm_ppc.h     Reg key = RID_NONE, tmp1 = RID_TMP, tmp2;
Reg               624 lj_asm_ppc.h     Reg tisnum = RID_NONE, tmpnum = RID_NONE;
Reg               706 lj_asm_ppc.h       Reg tmphash = tmp1;
Reg               753 lj_asm_ppc.h     Reg dest = (ra_used(ir)||ofs > 32736) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
Reg               754 lj_asm_ppc.h     Reg node = ra_alloc1(as, ir->op1, RSET_GPR);
Reg               755 lj_asm_ppc.h     Reg key = RID_NONE, type = RID_TMP, idx = node;
Reg               792 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               798 lj_asm_ppc.h       Reg uv = ra_scratch(as, RSET_GPR);
Reg               799 lj_asm_ppc.h       Reg func = ra_alloc1(as, ir->op1, RSET_GPR);
Reg               821 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               824 lj_asm_ppc.h     Reg r;
Reg               828 lj_asm_ppc.h       Reg right, left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg               882 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               884 lj_asm_ppc.h     Reg idx;
Reg               907 lj_asm_ppc.h       Reg src = ra_alloc1(as, ir->op2, RSET_GPR);
Reg               909 lj_asm_ppc.h       Reg idx = ra_alloc1(as, irf->op1, rset_exclude(RSET_GPR, src));
Reg               918 lj_asm_ppc.h     Reg dest = ra_dest(as, ir,
Reg               934 lj_asm_ppc.h       Reg src = ra_alloc1(as, irb->op1, RSET_GPR);
Reg               937 lj_asm_ppc.h       Reg src = ra_alloc1(as, ir->op2,
Reg               949 lj_asm_ppc.h     Reg dest = RID_NONE, type = RID_TMP, tmp = RID_TMP, idx;
Reg               969 lj_asm_ppc.h       Reg tisnum = ra_allock(as, (int32_t)LJ_TISNUM, rset_exclude(allow, idx));
Reg               998 lj_asm_ppc.h     Reg idx, src = RID_NONE, type = RID_NONE;
Reg              1040 lj_asm_ppc.h     Reg dest = RID_NONE, type = RID_NONE, base;
Reg              1076 lj_asm_ppc.h   	Reg tmp = ra_scratch(as, allow);
Reg              1077 lj_asm_ppc.h   	Reg hibias = ra_allock(as, 0x43300000, rset_clear(allow, tmp));
Reg              1078 lj_asm_ppc.h   	Reg fbias = ra_scratch(as, rset_exclude(RSET_FPR, dest));
Reg              1098 lj_asm_ppc.h         Reg tisnum = ra_allock(as, (int32_t)LJ_TISNUM, allow);
Reg              1149 lj_asm_ppc.h         Reg r = ra_alloc1(as, ir->op2, allow);
Reg              1185 lj_asm_ppc.h     Reg tab = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1186 lj_asm_ppc.h     Reg mark = ra_scratch(as, rset_exclude(RSET_GPR, tab));
Reg              1187 lj_asm_ppc.h     Reg link = RID_TMP;
Reg              1205 lj_asm_ppc.h     Reg obj, val, tmp;
Reg              1231 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1232 lj_asm_ppc.h     Reg right, left = ra_alloc2(as, ir, RSET_FPR);
Reg              1242 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1243 lj_asm_ppc.h     Reg left = ra_hintalloc(as, ir->op1, dest, RSET_FPR);
Reg              1267 lj_asm_ppc.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1268 lj_asm_ppc.h       Reg right, left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              1313 lj_asm_ppc.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1314 lj_asm_ppc.h       Reg left, right;
Reg              1344 lj_asm_ppc.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1345 lj_asm_ppc.h       Reg right, left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              1376 lj_asm_ppc.h       Reg dest, left;
Reg              1395 lj_asm_ppc.h     Reg dest, left, right;
Reg              1404 lj_asm_ppc.h     if (pi == PPCI_SUBFO) { Reg tmp = left; left = right; right = tmp; }
Reg              1415 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1416 lj_asm_ppc.h     Reg right, left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1448 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1449 lj_asm_ppc.h     Reg left, right = ra_alloc1(as, ir->op2, RSET_GPR);
Reg              1481 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1482 lj_asm_ppc.h     Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1493 lj_asm_ppc.h     Reg dest, left, right;
Reg              1520 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1527 lj_asm_ppc.h       Reg left = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1528 lj_asm_ppc.h       Reg tmp = dest;
Reg              1543 lj_asm_ppc.h     Reg left;
Reg              1571 lj_asm_ppc.h     Reg dest, left, right;
Reg              1626 lj_asm_ppc.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1627 lj_asm_ppc.h     Reg right, left = ra_hintalloc(as, ir->op1, dest, RSET_GPR);
Reg              1630 lj_asm_ppc.h       Reg tmp = left;
Reg              1655 lj_asm_ppc.h     Reg dest, left;
Reg              1656 lj_asm_ppc.h     Reg dot = 0;
Reg              1673 lj_asm_ppc.h       Reg right = ra_alloc1(as, ir->op2, rset_exclude(RSET_GPR, left));
Reg              1692 lj_asm_ppc.h     Reg desthi = ra_dest(as, ir, RSET_GPR), destlo = ra_dest(as, ir+1, RSET_GPR);
Reg              1693 lj_asm_ppc.h     Reg righthi, lefthi = ra_alloc2(as, ir, RSET_GPR);
Reg              1694 lj_asm_ppc.h     Reg rightlo, leftlo = ra_alloc2(as, ir+1, RSET_GPR);
Reg              1720 lj_asm_ppc.h       Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1721 lj_asm_ppc.h       Reg tmp = dest;
Reg              1722 lj_asm_ppc.h       Reg right, left = ra_alloc2(as, ir, RSET_FPR);
Reg              1731 lj_asm_ppc.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1732 lj_asm_ppc.h       Reg tmp1 = RID_TMP, tmp2 = dest;
Reg              1733 lj_asm_ppc.h       Reg right, left = ra_alloc2(as, ir, RSET_GPR);
Reg              1773 lj_asm_ppc.h     Reg right, left = ra_alloc1(as, lref, RSET_GPR);
Reg              1808 lj_asm_ppc.h       Reg right, left = ra_alloc2(as, ir, RSET_FPR);
Reg              1834 lj_asm_ppc.h     Reg r;
Reg              1984 lj_asm_ppc.h     Reg tmp, pbase = irp ? (ra_hasreg(irp->r) ? irp->r : RID_TMP) : RID_BASE;
Reg              2020 lj_asm_ppc.h         Reg tmp;
Reg              2029 lj_asm_ppc.h         Reg src = ra_alloc1(as, ref, RSET_FPR);
Reg              2033 lj_asm_ppc.h         Reg type;
Reg              2037 lj_asm_ppc.h   	Reg src = ra_alloc1(as, ref, allow);
Reg              2066 lj_asm_ppc.h     Reg tmp;
Reg              2108 lj_asm_ppc.h     Reg r = ir->r;
Reg              2122 lj_asm_ppc.h     Reg r = ir->r;
Reg              2177 lj_asm_ppc.h   static Reg asm_setup_call_slots(ASMState *as, IRIns *ir, const CCallInfo *ci)
Reg               281 lj_asm_x86.h       Reg r = ra_alloc1(as, ir->op1, allow);
Reg               289 lj_asm_x86.h       Reg r;
Reg               330 lj_asm_x86.h         Reg r;
Reg               367 lj_asm_x86.h   static Reg asm_fuseloadk64(ASMState *as, IRIns *ir)
Reg               406 lj_asm_x86.h   static Reg asm_fuseload(ASMState *as, IRRef ref, RegSet allow)
Reg               495 lj_asm_x86.h   static Reg asm_fuseloadm(ASMState *as, IRRef ref, RegSet allow, int is64)
Reg               547 lj_asm_x86.h     Reg fpr = REGARG_FIRSTFPR;
Reg               580 lj_asm_x86.h       Reg r;
Reg               662 lj_asm_x86.h   	Reg dest = ir->r;
Reg               674 lj_asm_x86.h         Reg dest = ir->r;
Reg               745 lj_asm_x86.h       Reg r = ra_alloc1(as, func, allow);
Reg               759 lj_asm_x86.h     Reg base = ra_alloc1(as, REF_BASE, RSET_GPR);
Reg               761 lj_asm_x86.h     Reg rpc = ra_scratch(as, rset_exclude(RSET_GPR, base));
Reg               783 lj_asm_x86.h     Reg tmp = ra_scratch(as, rset_exclude(RSET_FPR, left));
Reg               784 lj_asm_x86.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               796 lj_asm_x86.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               797 lj_asm_x86.h     Reg tmp = ra_noreg(IR(ir->op1)->r) ?
Reg               800 lj_asm_x86.h     Reg right;
Reg               816 lj_asm_x86.h       Reg dest = ra_dest(as, ir, RSET_FPR);
Reg               818 lj_asm_x86.h         Reg left = asm_fuseload(as, lref, RSET_FPR);
Reg               824 lj_asm_x86.h         Reg bias = ra_scratch(as, rset_exclude(RSET_FPR, dest));
Reg               833 lj_asm_x86.h         Reg left = (LJ_64 && (st == IRT_U32 || st == IRT_U64)) ?
Reg               853 lj_asm_x86.h         Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               858 lj_asm_x86.h   	Reg tmp = ra_noreg(IR(lref)->r) ? ra_alloc1(as, lref, RSET_FPR) :
Reg               882 lj_asm_x86.h       Reg left, dest = ra_dest(as, ir, RSET_GPR);
Reg               898 lj_asm_x86.h         Reg tmp = ra_scratch(as, allow);
Reg               906 lj_asm_x86.h         Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               909 lj_asm_x86.h         Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               914 lj_asm_x86.h   	Reg left = asm_fuseload(as, lref, RSET_GPR);
Reg               918 lj_asm_x86.h         Reg dest = ra_dest(as, ir, RSET_GPR);
Reg               920 lj_asm_x86.h   	Reg left = asm_fuseload(as, lref, RSET_GPR);
Reg               938 lj_asm_x86.h     Reg hi = ra_alloc1(as, ir->op1, RSET_GPR);
Reg               939 lj_asm_x86.h     Reg lo = ra_alloc1(as, (ir-1)->op1, rset_exclude(RSET_GPR, hi));
Reg               941 lj_asm_x86.h     Reg dest = ir->r;
Reg               969 lj_asm_x86.h     Reg lo, hi;
Reg              1064 lj_asm_x86.h         Reg src = ra_alloc1(as, ref, rset_exclude(RSET_GPR, dest));
Reg              1076 lj_asm_x86.h         Reg src = ra_alloc1(as, ref, rset_exclude(RSET_GPR, dest));
Reg              1090 lj_asm_x86.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1110 lj_asm_x86.h     Reg dest = ra_dest(as, ir, allow);
Reg              1111 lj_asm_x86.h     Reg tab = ra_alloc1(as, ir->op1, rset_clear(allow, dest));
Reg              1112 lj_asm_x86.h     Reg key = RID_NONE, tmp = RID_NONE;
Reg              1274 lj_asm_x86.h     Reg dest = ra_used(ir) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
Reg              1275 lj_asm_x86.h     Reg node = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1293 lj_asm_x86.h       Reg key = ra_scratch(as, rset_exclude(RSET_GPR, node));
Reg              1347 lj_asm_x86.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1353 lj_asm_x86.h       Reg uv = ra_scratch(as, RSET_GPR);
Reg              1354 lj_asm_x86.h       Reg func = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1371 lj_asm_x86.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1378 lj_asm_x86.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1392 lj_asm_x86.h     Reg dest = ra_dest(as, ir, irt_isfp(ir->t) ? RSET_FPR : RSET_GPR);
Reg              1423 lj_asm_x86.h     Reg src = RID_NONE, osrc = RID_NONE;
Reg              1487 lj_asm_x86.h   static Reg asm_load_lightud64(ASMState *as, IRIns *ir, int typecheck)
Reg              1490 lj_asm_x86.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              1492 lj_asm_x86.h         Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, dest));
Reg              1509 lj_asm_x86.h     Reg tmp = RID_NONE;
Reg              1515 lj_asm_x86.h       Reg dest = asm_load_lightud64(as, ir, 1);
Reg              1525 lj_asm_x86.h       Reg dest = ra_dest(as, ir, allow);
Reg              1593 lj_asm_x86.h       Reg src = ra_alloc1(as, ir->op2, RSET_FPR);
Reg              1598 lj_asm_x86.h       Reg src = ra_alloc1(as, ir->op2, RSET_GPR);
Reg              1621 lj_asm_x86.h       Reg src = RID_NONE;
Reg              1661 lj_asm_x86.h     Reg base;
Reg              1667 lj_asm_x86.h       Reg left = ra_scratch(as, RSET_FPR);
Reg              1674 lj_asm_x86.h       Reg dest = asm_load_lightud64(as, ir, (ir->op2 & IRSLOAD_TYPECHECK));
Reg              1683 lj_asm_x86.h       Reg dest = ra_dest(as, ir, allow);
Reg              1758 lj_asm_x86.h         Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, base));
Reg              1792 lj_asm_x86.h       Reg r64 = sz == 8 ? REX_64 : 0;
Reg              1806 lj_asm_x86.h         Reg r = ra_alloc1(as, ir->op2, allow);
Reg              1819 lj_asm_x86.h   	Reg r = ra_alloc1(as, ir->op2, allow);
Reg              1859 lj_asm_x86.h     Reg tab = ra_alloc1(as, ir->op1, RSET_GPR);
Reg              1860 lj_asm_x86.h     Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, tab));
Reg              1877 lj_asm_x86.h     Reg obj;
Reg              1893 lj_asm_x86.h       Reg val = ra_alloc1(as, ir->op2, rset_exclude(RSET_SCRATCH&RSET_GPR, obj));
Reg              1929 lj_asm_x86.h       Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1930 lj_asm_x86.h       Reg left = asm_fuseload(as, ir->op1, RSET_FPR);
Reg              1934 lj_asm_x86.h         Reg dest = ra_dest(as, ir, RSET_FPR);
Reg              1935 lj_asm_x86.h         Reg left = asm_fuseload(as, ir->op1, RSET_FPR);
Reg              1970 lj_asm_x86.h     Reg dest = ir->r;
Reg              2036 lj_asm_x86.h     Reg dest;
Reg              2037 lj_asm_x86.h     Reg right = IR(rref)->r;
Reg              2060 lj_asm_x86.h     Reg dest, right;
Reg              2095 lj_asm_x86.h       Reg left = asm_fuseloadm(as, lref, RSET_GPR, irt_is64(ir->t));
Reg              2126 lj_asm_x86.h     Reg dest;
Reg              2149 lj_asm_x86.h         Reg idx = ra_alloc1(as, irr->op1, allow);
Reg              2158 lj_asm_x86.h       Reg idx, base = ra_alloc1(as, irl->op1, allow);
Reg              2227 lj_asm_x86.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              2244 lj_asm_x86.h     Reg right, dest = ra_dest(as, ir, RSET_GPR);
Reg              2278 lj_asm_x86.h     Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              2292 lj_asm_x86.h     Reg dest;
Reg              2298 lj_asm_x86.h         Reg left = asm_fuseloadm(as, ir->op1, RSET_GPR, irt_is64(ir->t));
Reg              2311 lj_asm_x86.h       Reg left, right;
Reg              2319 lj_asm_x86.h       Reg right;
Reg              2381 lj_asm_x86.h       Reg left, right;
Reg              2419 lj_asm_x86.h       Reg r64 = REX_64IR(ir, 0);
Reg              2435 lj_asm_x86.h   	Reg right, left = RID_NONE;
Reg              2470 lj_asm_x86.h   	Reg left;
Reg              2524 lj_asm_x86.h         Reg left = ra_alloc1(as, lref, RSET_GPR);
Reg              2525 lj_asm_x86.h         Reg right = asm_fuseloadm(as, rref, rset_exclude(RSET_GPR, left), r64);
Reg              2540 lj_asm_x86.h     Reg lefthi = RID_NONE, leftlo = RID_NONE;
Reg              2541 lj_asm_x86.h     Reg righthi = RID_NONE, rightlo = RID_NONE;
Reg              2643 lj_asm_x86.h       Reg dest = ra_dest(as, ir, RSET_GPR);
Reg              2684 lj_asm_x86.h     Reg pbase = irp ? irp->r : RID_BASE;
Reg              2685 lj_asm_x86.h     Reg r = allow ? rset_pickbot(allow) : RID_EAX;
Reg              2726 lj_asm_x86.h         Reg src = ra_alloc1(as, ref, RSET_FPR);
Reg              2732 lj_asm_x86.h   	Reg src = ra_alloc1(as, ref, rset_exclude(RSET_GPR, RID_BASE));
Reg              2786 lj_asm_x86.h     Reg tmp;
Reg              2863 lj_asm_x86.h     Reg r = ir->r;
Reg              2877 lj_asm_x86.h     Reg r = ir->r;
Reg              2969 lj_asm_x86.h   static Reg asm_setup_call_slots(ASMState *as, IRIns *ir, const CCallInfo *ci)
Reg               125 lj_emit_arm.h      Reg r = rset_picktop(work);
Reg               149 lj_emit_arm.h      Reg r = rset_picktop(work);
Reg               210 lj_emit_arm.h  static Reg ra_allock(ASMState *as, intptr_t k, RegSet allow);
Reg               281 lj_emit_arm.h      Reg r = ra_allock(as, i32ptr(target), RSET_RANGE(RID_R4, RID_R12+1));
Reg               167 lj_emit_arm64.h     Reg r = rset_picktop(work);
Reg               246 lj_emit_arm64.h static Reg ra_allock(ASMState *as, intptr_t k, RegSet allow);
Reg               255 lj_emit_arm64.h     Reg base = RID_GL;  /* Next, try GL + offset. */
Reg               353 lj_emit_arm64.h     Reg r = ra_allock(as, i64ptr(target),
Reg                89 lj_emit_mips.h     Reg r = rset_picktop(work);
Reg               162 lj_emit_mips.h static Reg ra_allock(ASMState *as, intptr_t k, RegSet allow);
Reg               170 lj_emit_mips.h   Reg base;
Reg               184 lj_emit_mips.h   Reg r64 = r;
Reg                64 lj_emit_ppc.h      Reg r = rset_picktop(work);
Reg               101 lj_emit_ppc.h  static Reg ra_allock(ASMState *as, intptr_t k, RegSet allow);
Reg               108 lj_emit_ppc.h    Reg base;
Reg               167 lj_emit_ppc.h      Reg r = ra_allock(as, i32ptr(target), allow);
Reg               171 lj_emit_x86.h    as->mcp = emit_opm(xo, XM_REG, (Reg)(xg & 7) | (rb & REX_64), rb, p, 0);
Reg               186 lj_emit_x86.h    emit_rmro(as, xo, (Reg)(xg & 7), rb, ofs);
Reg               190 lj_emit_x86.h    (emit_i8(as, (i)), emit_rr(as, XO_SHIFTi, (Reg)(xg), (r)))
Reg               249 lj_emit_x86.h    emit_mrm(as, xo, (Reg)(xg & 7) | (rb & REX_64), (rb & ~REX_64));
Reg               347 lj_emit_x86.h      Reg ra = (rr & 15);
Reg               384 lj_emit_x86.h    Reg r64;
Reg               652 lj_snap.c          Reg r = regsp_reg(rs);
Reg               709 lj_snap.c            Reg r = regsp_reg(rs);
Reg                32 lj_target.h    #define ra_gethint(r)		((Reg)((r) & RID_MASK))
Reg                73 lj_target.h    #define rset_picktop(rs)	((Reg)(__builtin_clzll(rs)^63))
Reg                74 lj_target.h    #define rset_pickbot(rs)	((Reg)__builtin_ctzll(rs))
Reg                76 lj_target.h    #define rset_picktop(rs)	((Reg)lj_fls(rs))
Reg                77 lj_target.h    #define rset_pickbot(rs)	((Reg)lj_ffs(rs))