ofs               143 host/buildvm.c   ctx->reloc[ctx->nreloc].ofs = (int32_t)(addr - ctx->code);
ofs               160 host/buildvm.c     if (ctx->sym[i-1].ofs <= ofs)
ofs               165 host/buildvm.c   ctx->sym[i].ofs = ofs;
ofs               211 host/buildvm.c     int32_t ofs = dasm_getpclabel(Dst, i);
ofs               212 host/buildvm.c     if (ofs < 0) return 0x22000000|i;
ofs               213 host/buildvm.c     ctx->bc_ofs[i] = ofs;
ofs               218 host/buildvm.c       sym_insert(ctx, ofs, LABEL_PREFIX_BC, bc_names[i]);
ofs                55 host/buildvm.h   int32_t ofs;
ofs                62 host/buildvm.h   int32_t ofs;
ofs               288 host/buildvm_asm.c     int32_t ofs = ctx->sym[i].ofs;
ofs               289 host/buildvm_asm.c     int32_t next = ctx->sym[i+1].ofs;
ofs               300 host/buildvm_asm.c     emit_asm_label(ctx, ctx->sym[i].name, next - ofs, 1);
ofs               301 host/buildvm_asm.c     while (rel < ctx->nreloc && ctx->reloc[rel].ofs <= next) {
ofs               303 host/buildvm_asm.c       int n = r->ofs - ofs;
ofs               307 host/buildvm_asm.c 	emit_asm_reloc_text(ctx, ctx->code+ofs, n, ctx->relocsym[r->sym]);
ofs               309 host/buildvm_asm.c 	emit_asm_bytes(ctx, ctx->code+ofs, n);
ofs               312 host/buildvm_asm.c       ofs += n+4;
ofs               314 host/buildvm_asm.c       emit_asm_wordreloc(ctx, ctx->code+ofs, n, ctx->relocsym[r->sym]);
ofs               315 host/buildvm_asm.c       ofs += n;
ofs               320 host/buildvm_asm.c     emit_asm_bytes(ctx, ctx->code+ofs, next-ofs);
ofs               322 host/buildvm_asm.c     emit_asm_words(ctx, ctx->code+ofs, next-ofs);
ofs               196 host/buildvm_lib.c 	int ofs = libbc_map[i].ofs;
ofs               197 host/buildvm_lib.c 	int len = libbc_map[i+1].ofs - ofs;
ofs               201 host/buildvm_lib.c 	memcpy(optr, libbc_code + ofs, len);
ofs                45 host/buildvm_libbc.h static const struct { const char *name; int ofs; } libbc_map[] = {
ofs                37 host/buildvm_peobj.c   uint32_t ofs;
ofs               190 host/buildvm_peobj.c   pesect[PEOBJ_SECT_TEXT].ofs = sofs;
ofs               199 host/buildvm_peobj.c   pesect[PEOBJ_SECT_PDATA].ofs = sofs;
ofs               207 host/buildvm_peobj.c   pesect[PEOBJ_SECT_XDATA].ofs = sofs;
ofs               215 host/buildvm_peobj.c   pesect[PEOBJ_SECT_SXDATA].ofs = sofs;
ofs               223 host/buildvm_peobj.c   pesect[PEOBJ_SECT_RDATA_Z].ofs = sofs;
ofs               267 host/buildvm_peobj.c     reloc.vaddr = (uint32_t)ctx->reloc[i].ofs + PEOBJ_RELOC_OFS;
ofs               275 host/buildvm_peobj.c     uint32_t fcofs = (uint32_t)ctx->sym[ctx->nsym-1].ofs;
ofs               367 host/buildvm_peobj.c       emit_peobj_sym(ctx, ctx->sym[i].name, (uint32_t)ctx->sym[i].ofs,
ofs               652 lib_ffi.c        CTSize ofs;
ofs               654 lib_ffi.c          CType *fct = lj_ctype_getfield(cts, ct, name, &ofs);
ofs               656 lib_ffi.c            setintV(L->top-1, ofs);
ofs               313 lib_io.c         int64_t ofs = 0;
ofs               322 lib_io.c             ofs = (int64_t)intV(o);
ofs               324 lib_io.c             ofs = (int64_t)numV(o);
ofs               329 lib_io.c         res = fseeko(fp, ofs, opt);
ofs               331 lib_io.c         res = _fseeki64(fp, ofs, opt);
ofs               333 lib_io.c         res = fseeko64(fp, ofs, opt);
ofs               335 lib_io.c         res = fseek(fp, (long)ofs, opt);
ofs               340 lib_io.c         ofs = ftello(fp);
ofs               342 lib_io.c         ofs = _ftelli64(fp);
ofs               344 lib_io.c         ofs = ftello64(fp);
ofs               346 lib_io.c         ofs = (int64_t)ftell(fp);
ofs               348 lib_io.c         setint64V(L->top-1, ofs);
ofs               162 lj_asm.c       #define FLOFS(name, ofs)	(uint8_t)(ofs),
ofs               186 lj_asm.c         emit_loadofs(as, ir, (r), RID_SP, (ofs))
ofs               188 lj_asm.c         emit_storeofs(as, ir, (r), RID_SP, (ofs))
ofs               413 lj_asm.c           int32_t ofs = ra_spill(as, ir);  /* Force a spill slot. */
ofs               421 lj_asm.c             emit_spload(as, ir, r, ofs);
ofs              1866 lj_asm.c       	int32_t ofs = sps_scale(regsp_spill(rs));
ofs              1868 lj_asm.c       	emit_spload(as, IR(ref), r, ofs);
ofs               164 lj_asm_arm.h   	  int32_t ofs = asm_fuseabase(as, tab);
ofs               165 lj_asm_arm.h   	  IRRef refa = ofs ? tab : ir->op1;
ofs               166 lj_asm_arm.h   	  ofs += 8*IR(ir->op2)->i;
ofs               167 lj_asm_arm.h   	  if (ofs > -lim && ofs < lim) {
ofs               168 lj_asm_arm.h   	    *ofsp = ofs;
ofs               175 lj_asm_arm.h   	int32_t ofs = (int32_t)(IR(ir->op2)->op2 * sizeof(Node));
ofs               176 lj_asm_arm.h   	if (ofs < lim) {
ofs               177 lj_asm_arm.h   	  *ofsp = ofs;
ofs               184 lj_asm_arm.h   	int32_t ofs = i32ptr(&gcref(fn->l.uvptr[(ir->op2 >> 8)])->uv.tv);
ofs               185 lj_asm_arm.h   	*ofsp = (ofs & 255);  /* Mask out less bits to allow LDRD. */
ofs               186 lj_asm_arm.h   	return ra_allock(as, (ofs & ~255), allow);
ofs               247 lj_asm_arm.h   	  (ofs2 = ofs + IR(ir->op2)->i) > -lim && ofs2 < lim &&
ofs               249 lj_asm_arm.h   	ofs = ofs2;
ofs               251 lj_asm_arm.h         } else if (ofs == 0 && !(!LJ_SOFTFP && (ai & 0x08000000))) {
ofs               272 lj_asm_arm.h         lua_assert(ofs == 0);
ofs               273 lj_asm_arm.h         ofs = (int32_t)sizeof(GCstr);
ofs               275 lj_asm_arm.h   	ofs += IR(ir->op2)->i;
ofs               278 lj_asm_arm.h   	ofs += IR(ir->op1)->i;
ofs               285 lj_asm_arm.h   	  emit_lso(as, ai, rd, rd, ofs);
ofs               287 lj_asm_arm.h   	  emit_lsox(as, ai, rd, rd, ofs);
ofs               291 lj_asm_arm.h         if (ofs <= -lim || ofs >= lim) {
ofs               293 lj_asm_arm.h   	Reg rm = ra_allock(as, ofs, rset_exclude(allow, rn));
ofs               303 lj_asm_arm.h       emit_vlso(as, ai, rd, base, ofs);
ofs               307 lj_asm_arm.h       emit_lso(as, ai, rd, base, ofs);
ofs               309 lj_asm_arm.h       emit_lsox(as, ai, rd, base, ofs);
ofs               342 lj_asm_arm.h     int32_t ofs = 0;
ofs               403 lj_asm_arm.h   	if (irt_isnum(ir->t)) ofs = (ofs + 4) & ~4;
ofs               404 lj_asm_arm.h   	emit_spstore(as, ir, src, ofs);
ofs               405 lj_asm_arm.h   	ofs += irt_isnum(ir->t) ? 8 : 4;
ofs               417 lj_asm_arm.h   	  emit_spstore(as, ir, r, ofs);
ofs               419 lj_asm_arm.h   	ofs += 4;
ofs               601 lj_asm_arm.h     int32_t ofs = 0;
ofs               616 lj_asm_arm.h         ofs = sps_scale(ir->s);
ofs               632 lj_asm_arm.h         ofs = sps_scale(ir->s);
ofs               637 lj_asm_arm.h   	emit_spload(as, ir, ir->r, ofs);
ofs               652 lj_asm_arm.h     if (ofs == 0)
ofs               655 lj_asm_arm.h       emit_opk(as, ARMI_ADD, tmp, RID_SP, ofs, RSET_GPR);
ofs               699 lj_asm_arm.h       int32_t ofs = asm_fuseabase(as, tab);
ofs               700 lj_asm_arm.h       IRRef refa = ofs ? tab : ir->op1;
ofs               701 lj_asm_arm.h       uint32_t k = emit_isk12(ARMI_ADD, ofs + 8*IR(ir->op2)->i);
ofs               864 lj_asm_arm.h     int32_t ofs = (int32_t)(kslot->op2 * sizeof(Node));
ofs               865 lj_asm_arm.h     int32_t kofs = ofs + (int32_t)offsetof(Node, key);
ofs               866 lj_asm_arm.h     Reg dest = (ra_used(ir) || ofs > 4095) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
ofs               870 lj_asm_arm.h     lua_assert(ofs % sizeof(Node) == 0);
ofs               871 lj_asm_arm.h     if (ofs > 4095) {
ofs               876 lj_asm_arm.h       emit_opk(as, ARMI_ADD, dest, node, ofs, allow);
ofs               906 lj_asm_arm.h     if (ofs > 4095)
ofs               907 lj_asm_arm.h       emit_opk(as, ARMI_ADD, dest, node, ofs, RSET_GPR);
ofs              1006 lj_asm_arm.h       int32_t ofs;
ofs              1008 lj_asm_arm.h         ofs = asm_fuseabase(as, ir->op1);
ofs              1009 lj_asm_arm.h         if (ofs) {  /* Turn the t->array load into an add for colocated arrays. */
ofs              1010 lj_asm_arm.h   	emit_dn(as, ARMI_ADD|ARMI_K12|ofs, dest, idx);
ofs              1014 lj_asm_arm.h       ofs = field_ofs[ir->op2];
ofs              1016 lj_asm_arm.h         emit_lso(as, ai, dest, idx, ofs);
ofs              1018 lj_asm_arm.h         emit_lsox(as, ai, dest, idx, ofs);
ofs              1028 lj_asm_arm.h       int32_t ofs = field_ofs[irf->op2];
ofs              1031 lj_asm_arm.h         emit_lso(as, ai, src, idx, ofs);
ofs              1033 lj_asm_arm.h         emit_lsox(as, ai, src, idx, ofs);
ofs              1051 lj_asm_arm.h   		 rset_exclude(RSET_GPR, src), ofs);
ofs              1063 lj_asm_arm.h     int32_t ofs = 0;
ofs              1074 lj_asm_arm.h     idx = asm_fuseahuref(as, ir->op1, &ofs, allow,
ofs              1078 lj_asm_arm.h       if (ofs < 256 && ra_hasreg(dest) && (dest & 1) == 0 &&
ofs              1091 lj_asm_arm.h         emit_vlso(as, ARMI_VLDR_D, dest, idx, ofs);
ofs              1094 lj_asm_arm.h         emit_lso(as, ARMI_LDR, dest, idx, ofs);
ofs              1096 lj_asm_arm.h     emit_lso(as, ARMI_LDR, type, idx, ofs+4);
ofs              1104 lj_asm_arm.h       int32_t ofs = 0;
ofs              1108 lj_asm_arm.h         idx = asm_fuseahuref(as, ir->op1, &ofs, allow, 1024);
ofs              1109 lj_asm_arm.h         emit_vlso(as, ARMI_VSTR_D, src, idx, ofs);
ofs              1122 lj_asm_arm.h         idx = asm_fuseahuref(as, ir->op1, &ofs, rset_exclude(allow, type), 4096);
ofs              1123 lj_asm_arm.h         if (ra_hasreg(src)) emit_lso(as, ARMI_STR, src, idx, ofs);
ofs              1124 lj_asm_arm.h         emit_lso(as, ARMI_STR, type, idx, ofs+4);
ofs              1131 lj_asm_arm.h     int32_t ofs = 8*((int32_t)ir->op1-1) + ((ir->op2 & IRSLOAD_FRAME) ? 4 : 0);
ofs              1179 lj_asm_arm.h         if (ofs < 256 && ra_hasreg(dest) && (dest & 1) == 0 &&
ofs              1193 lj_asm_arm.h         if (ofs < 1024) {
ofs              1194 lj_asm_arm.h   	emit_vlso(as, ARMI_VLDR_D, dest, base, ofs);
ofs              1196 lj_asm_arm.h   	if (ra_hasreg(type)) emit_lso(as, ARMI_LDR, type, base, ofs+4);
ofs              1198 lj_asm_arm.h   	emit_opk(as, ARMI_ADD, RID_TMP, base, ofs, allow);
ofs              1203 lj_asm_arm.h         emit_lso(as, ARMI_LDR, dest, base, ofs);
ofs              1205 lj_asm_arm.h     if (ra_hasreg(type)) emit_lso(as, ARMI_LDR, type, base, ofs+4);
ofs              1232 lj_asm_arm.h       int32_t ofs = sizeof(GCcdata);
ofs              1235 lj_asm_arm.h         ofs += 4; ir++;
ofs              1240 lj_asm_arm.h         emit_lso(as, ARMI_STR, r, RID_RET, ofs);
ofs              1242 lj_asm_arm.h         if (ofs == sizeof(GCcdata)) break;
ofs              1243 lj_asm_arm.h         ofs -= 4; ir--;
ofs              1973 lj_asm_arm.h       int32_t ofs = 8*((int32_t)s-1);
ofs              1985 lj_asm_arm.h         emit_lso(as, ARMI_STR, tmp, RID_BASE, ofs);
ofs              1988 lj_asm_arm.h         emit_lso(as, ARMI_STR, tmp, RID_BASE, ofs+4);
ofs              1991 lj_asm_arm.h         emit_vlso(as, ARMI_VSTR_D, src, RID_BASE, ofs);
ofs              1999 lj_asm_arm.h   	emit_lso(as, ARMI_STR, src, RID_BASE, ofs);
ofs              2012 lj_asm_arm.h         emit_lso(as, ARMI_STR, type, RID_BASE, ofs+4);
ofs               170 lj_asm_arm64.h 	  int32_t ofs = asm_fuseabase(as, tab);
ofs               171 lj_asm_arm64.h 	  IRRef refa = ofs ? tab : ir->op1;
ofs               172 lj_asm_arm64.h 	  ofs += 8*IR(ir->op2)->i;
ofs               173 lj_asm_arm64.h 	  if (emit_checkofs(ins, ofs)) {
ofs               174 lj_asm_arm64.h 	    *ofsp = ofs;
ofs               185 lj_asm_arm64.h 	int32_t ofs = (int32_t)(IR(ir->op2)->op2 * sizeof(Node));
ofs               186 lj_asm_arm64.h 	if (emit_checkofs(ins, ofs)) {
ofs               187 lj_asm_arm64.h 	  *ofsp = ofs;
ofs               195 lj_asm_arm64.h 	int64_t ofs = glofs(as, &uv->tv);
ofs               196 lj_asm_arm64.h 	if (emit_checkofs(ins, ofs)) {
ofs               197 lj_asm_arm64.h 	  *ofsp = (int32_t)ofs;
ofs               257 lj_asm_arm64.h   int32_t ofs = 0;
ofs               260 lj_asm_arm64.h       if (asm_isk32(as, ir->op2, &ofs) && emit_checkofs(ai, ofs)) {
ofs               293 lj_asm_arm64.h       if (asm_isk32(as, ir->op2, &ofs)) {
ofs               295 lj_asm_arm64.h       } else if (asm_isk32(as, ir->op1, &ofs)) {
ofs               303 lj_asm_arm64.h 	  ofs = sizeof(GCstr) + IR(irr->op2)->i;
ofs               304 lj_asm_arm64.h 	  if (emit_checkofs(ai, ofs)) {
ofs               311 lj_asm_arm64.h 	ofs = sizeof(GCstr);
ofs               313 lj_asm_arm64.h 	emit_lso(as, ai, rd, rd, ofs);
ofs               317 lj_asm_arm64.h       ofs += sizeof(GCstr);
ofs               318 lj_asm_arm64.h       if (!emit_checkofs(ai, ofs)) {
ofs               320 lj_asm_arm64.h 	Reg rm = ra_allock(as, ofs, rset_exclude(allow, rn));
ofs               327 lj_asm_arm64.h   emit_lso(as, ai, (rd & 31), base, ofs);
ofs               416 lj_asm_arm64.h   int32_t ofs = 0;
ofs               434 lj_asm_arm64.h 	  emit_spstore(as, ir, r, ofs + ((LJ_BE && !irt_isnum(ir->t)) ? 4 : 0));
ofs               435 lj_asm_arm64.h 	  ofs += 8;
ofs               444 lj_asm_arm64.h 	  emit_spstore(as, ir, r, ofs + ((LJ_BE && !irt_is64(ir->t)) ? 4 : 0));
ofs               445 lj_asm_arm64.h 	  ofs += 8;
ofs               619 lj_asm_arm64.h   int32_t ofs = 0;
ofs               623 lj_asm_arm64.h       ofs = sps_scale(ir->s);
ofs               628 lj_asm_arm64.h 	emit_spload(as, ir, ir->r, ofs);
ofs               641 lj_asm_arm64.h   emit_opk(as, A64I_ADDx, tmp, RID_SP, ofs, RSET_GPR);
ofs               655 lj_asm_arm64.h     emit_lso(as, A64I_STRx, ra_allock(as, k.u64, allow), base, ofs);
ofs               661 lj_asm_arm64.h       emit_lso(as, A64I_STRx, RID_TMP, base, ofs);
ofs               665 lj_asm_arm64.h       emit_lso(as, A64I_STRx, RID_TMP, base, ofs);
ofs               696 lj_asm_arm64.h     int32_t ofs = asm_fuseabase(as, tab);
ofs               697 lj_asm_arm64.h     IRRef refa = ofs ? tab : ir->op1;
ofs               698 lj_asm_arm64.h     uint32_t k = emit_isk12(ofs + 8*IR(ir->op2)->i);
ofs               869 lj_asm_arm64.h   int32_t ofs = (int32_t)(kslot->op2 * sizeof(Node));
ofs               870 lj_asm_arm64.h   int32_t kofs = ofs + (int32_t)offsetof(Node, key);
ofs               871 lj_asm_arm64.h   int bigofs = !emit_checkofs(A64I_LDRx, ofs);
ofs               877 lj_asm_arm64.h   lua_assert(ofs % sizeof(Node) == 0);
ofs               883 lj_asm_arm64.h     emit_opk(as, A64I_ADDx, dest, node, ofs, allow);
ofs               897 lj_asm_arm64.h     emit_opk(as, A64I_ADDx, dest, node, ofs, RSET_GPR);
ofs               936 lj_asm_arm64.h   int32_t ofs = sizeof(GCstr);
ofs               939 lj_asm_arm64.h   if (irref_isk(ir->op2) && (m = emit_isk12(ofs + irr->i))) {
ofs               942 lj_asm_arm64.h     emit_dn(as, (A64I_ADDx^A64I_K12) | A64F_U12(ofs), dest, dest);
ofs               978 lj_asm_arm64.h   int32_t ofs;
ofs               981 lj_asm_arm64.h     ofs = (ir->op2 << 2) - GG_OFS(g);
ofs               985 lj_asm_arm64.h       ofs = asm_fuseabase(as, ir->op1);
ofs               986 lj_asm_arm64.h       if (ofs) {  /* Turn the t->array load into an add for colocated arrays. */
ofs               987 lj_asm_arm64.h 	emit_dn(as, (A64I_ADDx^A64I_K12) | A64F_U12(ofs), dest, idx);
ofs               991 lj_asm_arm64.h     ofs = field_ofs[ir->op2];
ofs               993 lj_asm_arm64.h   emit_lso(as, ai, (dest & 31), idx, ofs);
ofs              1002 lj_asm_arm64.h     int32_t ofs = field_ofs[irf->op2];
ofs              1003 lj_asm_arm64.h     emit_lso(as, asm_fxstoreins(ir), (src & 31), idx, ofs);
ofs              1026 lj_asm_arm64.h   int32_t ofs = 0;
ofs              1044 lj_asm_arm64.h   idx = asm_fuseahuref(as, ir->op1, &ofs, rset_clear(gpr, type), A64I_LDRx);
ofs              1060 lj_asm_arm64.h   if (ofs & FUSE_REG)
ofs              1061 lj_asm_arm64.h     emit_dnm(as, (A64I_LDRx^A64I_LS_R)|A64I_LS_UXTWx|A64I_LS_SH, tmp, idx, (ofs & 31));
ofs              1063 lj_asm_arm64.h     emit_lso(as, A64I_LDRx, tmp, idx, ofs);
ofs              1071 lj_asm_arm64.h     int32_t ofs = 0;
ofs              1074 lj_asm_arm64.h       idx = asm_fuseahuref(as, ir->op1, &ofs, allow, A64I_STRd);
ofs              1075 lj_asm_arm64.h       if (ofs & FUSE_REG)
ofs              1076 lj_asm_arm64.h 	emit_dnm(as, (A64I_STRd^A64I_LS_R)|A64I_LS_UXTWx|A64I_LS_SH, (src & 31), idx, (ofs &31));
ofs              1078 lj_asm_arm64.h 	emit_lso(as, A64I_STRd, (src & 31), idx, ofs);
ofs              1090 lj_asm_arm64.h       idx = asm_fuseahuref(as, ir->op1, &ofs, rset_exclude(allow, type),
ofs              1092 lj_asm_arm64.h       if (ofs & FUSE_REG)
ofs              1093 lj_asm_arm64.h 	emit_dnm(as, (A64I_STRx^A64I_LS_R)|A64I_LS_UXTWx|A64I_LS_SH, tmp, idx, (ofs & 31));
ofs              1095 lj_asm_arm64.h 	emit_lso(as, A64I_STRx, tmp, idx, ofs);
ofs              1109 lj_asm_arm64.h   int32_t ofs = 8*((int32_t)ir->op1-2);
ofs              1176 lj_asm_arm64.h     emit_lso(as, A64I_LDRx, tmp, base, ofs);
ofs              1182 lj_asm_arm64.h 	     ofs ^ ((LJ_BE && irt_isint(t) ? 4 : 0)));
ofs              1204 lj_asm_arm64.h     int32_t ofs = sizeof(GCcdata);
ofs              1207 lj_asm_arm64.h     emit_lso(as, sz == 8 ? A64I_STRx : A64I_STRw, r, RID_RET, ofs);
ofs              1792 lj_asm_arm64.h     int32_t ofs = 8*((int32_t)s-1-LJ_FR2);
ofs              1799 lj_asm_arm64.h       emit_lso(as, A64I_STRd, (src & 31), RID_BASE, ofs);
ofs              1801 lj_asm_arm64.h       asm_tvstore64(as, RID_BASE, ofs, ref);
ofs               148 lj_asm_mips.h  	  int32_t ofs = asm_fuseabase(as, tab);
ofs               149 lj_asm_mips.h  	  IRRef refa = ofs ? tab : ir->op1;
ofs               150 lj_asm_mips.h  	  ofs += 8*IR(ir->op2)->i;
ofs               151 lj_asm_mips.h  	  if (checki16(ofs)) {
ofs               152 lj_asm_mips.h  	    *ofsp = ofs;
ofs               159 lj_asm_mips.h  	int32_t ofs = (int32_t)(IR(ir->op2)->op2 * sizeof(Node));
ofs               160 lj_asm_mips.h  	if (checki16(ofs)) {
ofs               161 lj_asm_mips.h  	  *ofsp = ofs;
ofs               168 lj_asm_mips.h  	intptr_t ofs = (intptr_t)&gcref(fn->l.uvptr[(ir->op2 >> 8)])->uv.tv;
ofs               170 lj_asm_mips.h  	if ((uintptr_t)(ofs-jgl) < 65536) {
ofs               171 lj_asm_mips.h  	  *ofsp = ofs-jgl-32768;
ofs               174 lj_asm_mips.h  	  *ofsp = (int16_t)ofs;
ofs               175 lj_asm_mips.h  	  return ra_allock(as, ofs-(int16_t)ofs, allow);
ofs               193 lj_asm_mips.h        if (irref_isk(ir->op2) && (ofs2 = ofs + get_kval(IR(ir->op2)),
ofs               196 lj_asm_mips.h  	ofs = (int32_t)ofs2;
ofs               200 lj_asm_mips.h        lua_assert(ofs == 0);
ofs               201 lj_asm_mips.h        ofs = (int32_t)sizeof(GCstr);
ofs               203 lj_asm_mips.h  	ofs2 = ofs + get_kval(IR(ir->op2));
ofs               206 lj_asm_mips.h  	ofs2 = ofs + get_kval(IR(ir->op1));
ofs               213 lj_asm_mips.h  	emit_hsi(as, mi, rt, RID_TMP, ofs);
ofs               217 lj_asm_mips.h        ofs = ofs2;
ofs               221 lj_asm_mips.h    emit_hsi(as, mi, rt, base, ofs);
ofs               230 lj_asm_mips.h    int32_t ofs = LJ_32 ? 16 : 0;
ofs               300 lj_asm_mips.h  	  if (irt_isnum(ir->t)) ofs = (ofs + 4) & ~4;
ofs               301 lj_asm_mips.h  	  emit_spstore(as, ir, r, ofs);
ofs               302 lj_asm_mips.h  	  ofs += irt_isnum(ir->t) ? 8 : 4;
ofs               304 lj_asm_mips.h  	  emit_spstore(as, ir, r, ofs + ((LJ_BE && !irt_isfp(ir->t) && !irt_is64(ir->t)) ? 4 : 0));
ofs               305 lj_asm_mips.h  	  ofs += 8;
ofs               319 lj_asm_mips.h  	ofs += LJ_32 ? 4 : 8;
ofs               348 lj_asm_mips.h  	int32_t ofs = sps_scale(ir->s);
ofs               360 lj_asm_mips.h  	if (ofs) {
ofs               362 lj_asm_mips.h  	  emit_tsi(as, MIPSI_SW, RID_RETLO, RID_SP, ofs+(LJ_BE?4:0));
ofs               363 lj_asm_mips.h  	  emit_tsi(as, MIPSI_SW, RID_RETHI, RID_SP, ofs+(LJ_BE?0:4));
ofs               365 lj_asm_mips.h  	  emit_tsi(as, MIPSI_SD, RID_RET, RID_SP, ofs);
ofs               728 lj_asm_mips.h    int32_t ofs = 0;
ofs               743 lj_asm_mips.h        ofs = sps_scale(ir->s & ~1);
ofs               747 lj_asm_mips.h        emit_tsi(as, MIPSI_LW, rhi, RID_SP, ofs+(LJ_BE?0:4));
ofs               748 lj_asm_mips.h        emit_tsi(as, MIPSI_LW, rlo, RID_SP, ofs+(LJ_BE?4:0));
ofs               755 lj_asm_mips.h    ofs = sps_scale(ir->s);
ofs               763 lj_asm_mips.h  	   RID_SP, ofs);
ofs               778 lj_asm_mips.h      emit_tsi(as, MIPSI_SD, ra_allock(as, (int64_t)k.u64, allow), base, ofs);
ofs               783 lj_asm_mips.h      emit_tsi(as, MIPSI_SD, RID_TMP, base, ofs);
ofs               832 lj_asm_mips.h      int32_t ofs = asm_fuseabase(as, tab);
ofs               833 lj_asm_mips.h      IRRef refa = ofs ? tab : ir->op1;
ofs               834 lj_asm_mips.h      ofs += 8*IR(ir->op2)->i;
ofs               835 lj_asm_mips.h      if (checki16(ofs)) {
ofs               837 lj_asm_mips.h        emit_tsi(as, MIPSI_AADDIU, dest, base, ofs);
ofs              1055 lj_asm_mips.h    int32_t ofs = (int32_t)(kslot->op2 * sizeof(Node));
ofs              1056 lj_asm_mips.h    int32_t kofs = ofs + (int32_t)offsetof(Node, key);
ofs              1057 lj_asm_mips.h    Reg dest = (ra_used(ir)||ofs > 32736) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
ofs              1068 lj_asm_mips.h    lua_assert(ofs % sizeof(Node) == 0);
ofs              1069 lj_asm_mips.h    if (ofs > 32736) {
ofs              1074 lj_asm_mips.h      emit_tsi(as, MIPSI_AADDIU, dest, node, ofs);
ofs              1107 lj_asm_mips.h    if (ofs > 32736)
ofs              1108 lj_asm_mips.h      emit_tsi(as, MIPSI_AADDU, dest, node, ra_allock(as, ofs, allow));
ofs              1144 lj_asm_mips.h    int32_t ofs = (int32_t)sizeof(GCstr);
ofs              1156 lj_asm_mips.h  	       checki16(ofs + IR(irr->op2)->i)) {
ofs              1157 lj_asm_mips.h        ofs += IR(irr->op2)->i;
ofs              1162 lj_asm_mips.h      emit_tsi(as, MIPSI_ADDIU, dest, dest, ofs);
ofs              1167 lj_asm_mips.h    ofs += IR(refk)->i;
ofs              1168 lj_asm_mips.h    if (checki16(ofs))
ofs              1169 lj_asm_mips.h      emit_tsi(as, MIPSI_ADDIU, dest, r, ofs);
ofs              1172 lj_asm_mips.h  	     ra_allock(as, ofs, rset_exclude(RSET_GPR, r)));
ofs              1178 lj_asm_mips.h    int32_t ofs = sizeof(GCstr);
ofs              1180 lj_asm_mips.h    if (irref_isk(ir->op2) && checki16(ofs + irr->i)) {
ofs              1181 lj_asm_mips.h      emit_tsi(as, MIPSI_DADDIU, dest, base, ofs + irr->i);
ofs              1183 lj_asm_mips.h      emit_tsi(as, MIPSI_DADDIU, dest, dest, ofs);
ofs              1220 lj_asm_mips.h    int32_t ofs;
ofs              1223 lj_asm_mips.h      ofs = (ir->op2 << 2) - 32768 - GG_OFS(g);
ofs              1227 lj_asm_mips.h        ofs = asm_fuseabase(as, ir->op1);
ofs              1228 lj_asm_mips.h        if (ofs) {  /* Turn the t->array load into an add for colocated arrays. */
ofs              1229 lj_asm_mips.h  	emit_tsi(as, MIPSI_AADDIU, dest, idx, ofs);
ofs              1233 lj_asm_mips.h      ofs = field_ofs[ir->op2];
ofs              1236 lj_asm_mips.h    emit_tsi(as, mi, dest, idx, ofs);
ofs              1245 lj_asm_mips.h      int32_t ofs = field_ofs[irf->op2];
ofs              1248 lj_asm_mips.h      emit_tsi(as, mi, src, idx, ofs);
ofs              1266 lj_asm_mips.h  		 rset_exclude(RSET_GPR, src), ofs);
ofs              1277 lj_asm_mips.h    int32_t ofs = 0;
ofs              1298 lj_asm_mips.h    idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
ofs              1310 lj_asm_mips.h        emit_hsi(as, MIPSI_LDC1, dest, idx, ofs);
ofs              1312 lj_asm_mips.h        emit_tsi(as, MIPSI_LW, dest, idx, ofs+(LJ_BE?4:0));
ofs              1314 lj_asm_mips.h    emit_tsi(as, MIPSI_LW, type, idx, ofs+(LJ_BE?0:4));
ofs              1318 lj_asm_mips.h        emit_hsi(as, MIPSI_LDC1, dest, idx, ofs);
ofs              1325 lj_asm_mips.h    emit_tsi(as, MIPSI_LD, dest, idx, ofs);
ofs              1333 lj_asm_mips.h    int32_t ofs = 0;
ofs              1338 lj_asm_mips.h      idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
ofs              1339 lj_asm_mips.h      emit_hsi(as, LJ_SOFTFP ? MIPSI_SD : MIPSI_SDC1, src, idx, ofs);
ofs              1351 lj_asm_mips.h      idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
ofs              1353 lj_asm_mips.h        emit_tsi(as, MIPSI_SW, src, idx, ofs+(LJ_BE?4:0));
ofs              1354 lj_asm_mips.h      emit_tsi(as, MIPSI_SW, type, idx, ofs+(LJ_BE?0:4));
ofs              1366 lj_asm_mips.h      idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
ofs              1367 lj_asm_mips.h      emit_tsi(as, MIPSI_SD, tmp, idx, ofs);
ofs              1386 lj_asm_mips.h    int32_t ofs = 8*((int32_t)ir->op1-1) + ((ir->op2 & IRSLOAD_FRAME) ? 4 : 0);
ofs              1391 lj_asm_mips.h    int32_t ofs = 8*((int32_t)ir->op1-2);
ofs              1473 lj_asm_mips.h        emit_hsi(as, MIPSI_LDC1, dest, base, ofs);
ofs              1475 lj_asm_mips.h        emit_tsi(as, MIPSI_LW, dest, base, ofs ^ (LJ_BE?4:0));
ofs              1478 lj_asm_mips.h      emit_tsi(as, MIPSI_LW, type, base, ofs ^ (LJ_BE?0:4));
ofs              1490 lj_asm_mips.h  	  emit_hsi(as, MIPSI_LDC1, dest, base, ofs);
ofs              1497 lj_asm_mips.h      emit_tsi(as, MIPSI_LD, type, base, ofs);
ofs              1500 lj_asm_mips.h        emit_hsi(as, MIPSI_LDC1, dest, base, ofs);
ofs              1503 lj_asm_mips.h  	       ofs ^ ((LJ_BE && irt_isint(t)) ? 4 : 0));
ofs              1533 lj_asm_mips.h      int32_t ofs = sizeof(GCcdata);
ofs              1535 lj_asm_mips.h        ofs += 4;
ofs              1541 lj_asm_mips.h        emit_tsi(as, MIPSI_SW, r, RID_RET, ofs);
ofs              1543 lj_asm_mips.h        if (ofs == sizeof(GCcdata)) break;
ofs              1544 lj_asm_mips.h        ofs -= 4; if (LJ_BE) ir++; else ir--;
ofs              2406 lj_asm_mips.h      int32_t ofs = 8*((int32_t)s-1-LJ_FR2);
ofs              2417 lj_asm_mips.h        emit_tsi(as, MIPSI_SW, tmp, RID_BASE, ofs+(LJ_BE?4:0));
ofs              2420 lj_asm_mips.h        emit_tsi(as, MIPSI_SW, tmp, RID_BASE, ofs+(LJ_BE?0:4));
ofs              2423 lj_asm_mips.h        emit_tsi(as, MIPSI_SD, src, RID_BASE, ofs);
ofs              2426 lj_asm_mips.h        emit_hsi(as, MIPSI_SDC1, src, RID_BASE, ofs);
ofs              2436 lj_asm_mips.h  	emit_tsi(as, MIPSI_SW, src, RID_BASE, ofs+(LJ_BE?4:0));
ofs              2448 lj_asm_mips.h        emit_tsi(as, MIPSI_SW, type, RID_BASE, ofs+(LJ_BE?0:4));
ofs              2450 lj_asm_mips.h        asm_tvstore64(as, RID_BASE, ofs, ref);
ofs               124 lj_asm_ppc.h   	  int32_t ofs = asm_fuseabase(as, tab);
ofs               125 lj_asm_ppc.h   	  IRRef refa = ofs ? tab : ir->op1;
ofs               126 lj_asm_ppc.h   	  ofs += 8*IR(ir->op2)->i;
ofs               127 lj_asm_ppc.h   	  if (checki16(ofs)) {
ofs               128 lj_asm_ppc.h   	    *ofsp = ofs;
ofs               140 lj_asm_ppc.h   	int32_t ofs = (int32_t)(IR(ir->op2)->op2 * sizeof(Node));
ofs               141 lj_asm_ppc.h   	if (checki16(ofs)) {
ofs               142 lj_asm_ppc.h   	  *ofsp = ofs;
ofs               149 lj_asm_ppc.h   	int32_t ofs = i32ptr(&gcref(fn->l.uvptr[(ir->op2 >> 8)])->uv.tv);
ofs               151 lj_asm_ppc.h   	if ((uint32_t)(ofs-jgl) < 65536) {
ofs               152 lj_asm_ppc.h   	  *ofsp = ofs-jgl-32768;
ofs               155 lj_asm_ppc.h   	  *ofsp = (int16_t)ofs;
ofs               156 lj_asm_ppc.h   	  return ra_allock(as, ofs-(int16_t)ofs, allow);
ofs               174 lj_asm_ppc.h         if (irref_isk(ir->op2) && (ofs2 = ofs + IR(ir->op2)->i, checki16(ofs2))) {
ofs               175 lj_asm_ppc.h   	ofs = ofs2;
ofs               177 lj_asm_ppc.h         } else if (ofs == 0) {
ofs               184 lj_asm_ppc.h         lua_assert(ofs == 0);
ofs               185 lj_asm_ppc.h         ofs = (int32_t)sizeof(GCstr);
ofs               187 lj_asm_ppc.h   	ofs += IR(ir->op2)->i;
ofs               190 lj_asm_ppc.h   	ofs += IR(ir->op1)->i;
ofs               197 lj_asm_ppc.h   	emit_fai(as, pi, rt, tmp, ofs);
ofs               201 lj_asm_ppc.h         if (!checki16(ofs)) {
ofs               203 lj_asm_ppc.h   	Reg right = ra_allock(as, ofs, rset_exclude(allow, left));
ofs               210 lj_asm_ppc.h     emit_fai(as, pi, rt, base, ofs);
ofs               257 lj_asm_ppc.h     int32_t ofs = 8;
ofs               276 lj_asm_ppc.h   	  if (irt_isnum(ir->t)) ofs = (ofs + 4) & ~4;
ofs               277 lj_asm_ppc.h   	  emit_spstore(as, ir, r, ofs);
ofs               278 lj_asm_ppc.h   	  ofs += irt_isnum(ir->t) ? 8 : 4;
ofs               289 lj_asm_ppc.h   	  emit_spstore(as, ir, r, ofs);
ofs               290 lj_asm_ppc.h   	  ofs += 4;
ofs               297 lj_asm_ppc.h   	ofs += 4;
ofs               326 lj_asm_ppc.h   	int32_t ofs = ir->s ? sps_scale(ir->s) : SPOFS_TMP;
ofs               331 lj_asm_ppc.h   	  emit_fai(as, PPCI_LFD, dest, RID_SP, ofs);
ofs               333 lj_asm_ppc.h   	emit_tai(as, PPCI_STW, RID_RETHI, RID_SP, ofs);
ofs               334 lj_asm_ppc.h   	emit_tai(as, PPCI_STW, RID_RETLO, RID_SP, ofs+4);
ofs               522 lj_asm_ppc.h     int32_t ofs = SPOFS_TMP;
ofs               537 lj_asm_ppc.h         ofs = sps_scale(ir->s & ~1);
ofs               541 lj_asm_ppc.h         emit_tai(as, PPCI_LWZ, rhi, RID_SP, ofs);
ofs               542 lj_asm_ppc.h         emit_tai(as, PPCI_LWZ, rlo, RID_SP, ofs+4);
ofs               549 lj_asm_ppc.h     if (ir->s) ofs = sps_scale(ir->s);
ofs               557 lj_asm_ppc.h     emit_tai(as, PPCI_ADDI, ra_releasetmp(as, ASMREF_TMP1), RID_SP, ofs);
ofs               594 lj_asm_ppc.h       int32_t ofs = asm_fuseabase(as, tab);
ofs               595 lj_asm_ppc.h       IRRef refa = ofs ? tab : ir->op1;
ofs               596 lj_asm_ppc.h       ofs += 8*IR(ir->op2)->i;
ofs               597 lj_asm_ppc.h       if (checki16(ofs)) {
ofs               599 lj_asm_ppc.h         emit_tai(as, PPCI_ADDI, dest, base, ofs);
ofs               730 lj_asm_ppc.h   	int32_t ofs = ra_spill(as, irkey);
ofs               734 lj_asm_ppc.h   	emit_tai(as, PPCI_LWZ, tmp2, RID_SP, ofs+4);
ofs               735 lj_asm_ppc.h   	emit_tai(as, PPCI_LWZ, tmp1, RID_SP, ofs);
ofs               751 lj_asm_ppc.h     int32_t ofs = (int32_t)(kslot->op2 * sizeof(Node));
ofs               752 lj_asm_ppc.h     int32_t kofs = ofs + (int32_t)offsetof(Node, key);
ofs               753 lj_asm_ppc.h     Reg dest = (ra_used(ir)||ofs > 32736) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
ofs               757 lj_asm_ppc.h     lua_assert(ofs % sizeof(Node) == 0);
ofs               758 lj_asm_ppc.h     if (ofs > 32736) {
ofs               763 lj_asm_ppc.h       emit_tai(as, PPCI_ADDI, dest, node, ofs);
ofs               784 lj_asm_ppc.h     if (ofs > 32736) {
ofs               785 lj_asm_ppc.h       emit_tai(as, PPCI_ADDIS, dest, dest, (ofs + 32768) >> 16);
ofs               786 lj_asm_ppc.h       emit_tai(as, PPCI_ADDI, dest, node, ofs);
ofs               823 lj_asm_ppc.h     int32_t ofs = (int32_t)sizeof(GCstr);
ofs               835 lj_asm_ppc.h   	       checki16(ofs + IR(irr->op2)->i)) {
ofs               836 lj_asm_ppc.h         ofs += IR(irr->op2)->i;
ofs               841 lj_asm_ppc.h       emit_tai(as, PPCI_ADDI, dest, dest, ofs);
ofs               846 lj_asm_ppc.h     ofs += IR(refk)->i;
ofs               847 lj_asm_ppc.h     if (checki16(ofs))
ofs               848 lj_asm_ppc.h       emit_tai(as, PPCI_ADDI, dest, r, ofs);
ofs               851 lj_asm_ppc.h   	     ra_allock(as, ofs, rset_exclude(RSET_GPR, r)));
ofs               885 lj_asm_ppc.h     int32_t ofs;
ofs               888 lj_asm_ppc.h       ofs = (ir->op2 << 2) - 32768;
ofs               892 lj_asm_ppc.h         ofs = asm_fuseabase(as, ir->op1);
ofs               893 lj_asm_ppc.h         if (ofs) {  /* Turn the t->array load into an add for colocated arrays. */
ofs               894 lj_asm_ppc.h   	emit_tai(as, PPCI_ADDI, dest, idx, ofs);
ofs               898 lj_asm_ppc.h       ofs = field_ofs[ir->op2];
ofs               901 lj_asm_ppc.h     emit_tai(as, pi, dest, idx, ofs);
ofs               910 lj_asm_ppc.h       int32_t ofs = field_ofs[irf->op2];
ofs               912 lj_asm_ppc.h       emit_tai(as, pi, src, idx, ofs);
ofs               931 lj_asm_ppc.h     if (ofs == 0 && mayfuse(as, ir->op2) && (irb = IR(ir->op2))->o == IR_BSWAP &&
ofs               940 lj_asm_ppc.h   		 rset_exclude(RSET_GPR, src), ofs);
ofs               951 lj_asm_ppc.h     int32_t ofs = AHUREF_LSX;
ofs               958 lj_asm_ppc.h       ofs = 0;
ofs               963 lj_asm_ppc.h       if (LJ_SOFTFP || !irt_isnum(t)) ofs = 0;
ofs               967 lj_asm_ppc.h     idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
ofs               973 lj_asm_ppc.h         if (!LJ_SOFTFP && ofs == AHUREF_LSX) {
ofs               979 lj_asm_ppc.h   		 ofs+4*LJ_SOFTFP);
ofs               985 lj_asm_ppc.h       if (ra_hasreg(dest)) emit_tai(as, PPCI_LWZ, dest, idx, ofs+4);
ofs               987 lj_asm_ppc.h     if (ofs == AHUREF_LSX) {
ofs               991 lj_asm_ppc.h       emit_tai(as, PPCI_LWZ, type, idx, ofs);
ofs               999 lj_asm_ppc.h     int32_t ofs = AHUREF_LSX;
ofs              1008 lj_asm_ppc.h         ofs = 0;
ofs              1016 lj_asm_ppc.h     idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
ofs              1018 lj_asm_ppc.h       if (ofs == AHUREF_LSX) {
ofs              1022 lj_asm_ppc.h         emit_fai(as, PPCI_STFD, src, idx, ofs);
ofs              1026 lj_asm_ppc.h         emit_tai(as, PPCI_STW, src, idx, ofs+4);
ofs              1027 lj_asm_ppc.h       if (ofs == AHUREF_LSX) {
ofs              1031 lj_asm_ppc.h         emit_tai(as, PPCI_STW, type, idx, ofs);
ofs              1038 lj_asm_ppc.h     int32_t ofs = 8*((int32_t)ir->op1-1) + ((ir->op2 & IRSLOAD_FRAME) ? 0 : 4);
ofs              1106 lj_asm_ppc.h   				  base, ofs-(LJ_SOFTFP?0:4));
ofs              1113 lj_asm_ppc.h       if (ra_hasreg(dest)) emit_tai(as, PPCI_LWZ, dest, base, ofs);
ofs              1115 lj_asm_ppc.h     if (ra_hasreg(type)) emit_tai(as, PPCI_LWZ, type, base, ofs-4);
ofs              1142 lj_asm_ppc.h       int32_t ofs = sizeof(GCcdata);
ofs              1145 lj_asm_ppc.h         ofs += 4;
ofs              1150 lj_asm_ppc.h         emit_tai(as, PPCI_STW, r, RID_RET, ofs);
ofs              1152 lj_asm_ppc.h         if (ofs == sizeof(GCcdata)) break;
ofs              1153 lj_asm_ppc.h         ofs -= 4; ir++;
ofs              2013 lj_asm_ppc.h       int32_t ofs = 8*((int32_t)s-1);
ofs              2024 lj_asm_ppc.h         emit_tai(as, PPCI_STW, tmp, RID_BASE, ofs+(LJ_BE?4:0));
ofs              2027 lj_asm_ppc.h         emit_tai(as, PPCI_STW, tmp, RID_BASE, ofs+(LJ_BE?0:4));
ofs              2030 lj_asm_ppc.h         emit_fai(as, PPCI_STFD, src, RID_BASE, ofs);
ofs              2039 lj_asm_ppc.h   	emit_tai(as, PPCI_STW, src, RID_BASE, ofs+4);
ofs              2051 lj_asm_ppc.h         emit_tai(as, PPCI_STW, type, RID_BASE, ofs);
ofs                68 lj_asm_x86.h   	as->mrm.ofs += 2;  /* Fixup RIP offset for pending fused load. */
ofs                74 lj_asm_x86.h       as->mrm.ofs += 6;  /* Fixup RIP offset for pending fused load. */
ofs               131 lj_asm_x86.h     as->mrm.ofs = 0;
ofs               138 lj_asm_x86.h         as->mrm.ofs = (int32_t)sizeof(GCtab);  /* Ofs to colocated array. */
ofs               143 lj_asm_x86.h       as->mrm.ofs = IR(irb->op2)->i;
ofs               157 lj_asm_x86.h       as->mrm.ofs += 8*irx->i;
ofs               168 lj_asm_x86.h         as->mrm.ofs += 8*IR(irx->op2)->i;
ofs               195 lj_asm_x86.h   	as->mrm.ofs = (int32_t)(IR(ir->op2)->op2 * sizeof(Node));
ofs               205 lj_asm_x86.h   	int64_t ofs = dispofs(as, &uv->tv);
ofs               206 lj_asm_x86.h   	if (checki32(ofs) && checki32(ofs+4)) {
ofs               207 lj_asm_x86.h   	  as->mrm.ofs = (int32_t)ofs;
ofs               213 lj_asm_x86.h   	as->mrm.ofs = ptr2addr(&uv->tv);
ofs               226 lj_asm_x86.h     as->mrm.ofs = 0;
ofs               237 lj_asm_x86.h       as->mrm.ofs = (int32_t)(ir->op2 << 2) - GG_OFS(dispatch);
ofs               240 lj_asm_x86.h       as->mrm.ofs = (int32_t)(ir->op2 << 2) + ptr2addr(J2GG(as->J));
ofs               245 lj_asm_x86.h     as->mrm.ofs = field_ofs[ir->op2];
ofs               250 lj_asm_x86.h         as->mrm.ofs -= GG_OFS(dispatch);
ofs               254 lj_asm_x86.h         intptr_t ofs = dispofs(as, ir_kptr(op1));
ofs               255 lj_asm_x86.h         if (checki32(as->mrm.ofs + ofs)) {
ofs               256 lj_asm_x86.h   	as->mrm.ofs += (int32_t)ofs;
ofs               262 lj_asm_x86.h       as->mrm.ofs += op1->i;
ofs               277 lj_asm_x86.h     as->mrm.ofs = sizeof(GCstr);
ofs               279 lj_asm_x86.h       as->mrm.ofs += IR(ir->op1)->i;
ofs               287 lj_asm_x86.h       as->mrm.ofs += irr->i;
ofs               293 lj_asm_x86.h         as->mrm.ofs += IR(irr->op2)->i;
ofs               311 lj_asm_x86.h       intptr_t ofs = dispofs(as, ir_kptr(ir));
ofs               312 lj_asm_x86.h       if (checki32(ofs)) {
ofs               313 lj_asm_x86.h         as->mrm.ofs = (int32_t)ofs;
ofs               319 lj_asm_x86.h       as->mrm.ofs = ir->i;
ofs               325 lj_asm_x86.h       as->mrm.ofs = 0;
ofs               331 lj_asm_x86.h         if (asm_isk32(as, ir->op2, &as->mrm.ofs)) {  /* Recognize x+ofs. */
ofs               371 lj_asm_x86.h       as->mrm.ofs = ptr2addr(k);
ofs               375 lj_asm_x86.h       as->mrm.ofs = (int32_t)dispofs(as, k);
ofs               379 lj_asm_x86.h       as->mrm.ofs = (int32_t)mcpofs(as, k);
ofs               392 lj_asm_x86.h       as->mrm.ofs = (int32_t)mcpofs(as, as->mctop - ir->i);
ofs               417 lj_asm_x86.h       as->mrm.ofs = ra_spill(as, ir);
ofs               432 lj_asm_x86.h   	as->mrm.ofs = (int32_t)dispofs(as, &J2G(as->J)->jit_base);
ofs               435 lj_asm_x86.h   	as->mrm.ofs = ptr2addr(&J2G(as->J)->jit_base);
ofs               451 lj_asm_x86.h   	as->mrm.ofs = 8*((int32_t)ir->op1-1-LJ_FR2) +
ofs               544 lj_asm_x86.h     int32_t ofs = STACKARG_OFS;
ofs               619 lj_asm_x86.h         if (LJ_32 && (ofs & 4) && irref_isk(ref)) {
ofs               621 lj_asm_x86.h   	emit_movmroi(as, RID_ESP, ofs, (int32_t)ir_knum(ir)->u32.lo);
ofs               622 lj_asm_x86.h   	emit_movmroi(as, RID_ESP, ofs+4, (int32_t)ir_knum(ir)->u32.hi);
ofs               626 lj_asm_x86.h   		  r, RID_ESP, ofs);
ofs               628 lj_asm_x86.h         ofs += (LJ_32 && irt_isfloat(ir->t)) ? 4 : 8;
ofs               631 lj_asm_x86.h   	emit_movmroi(as, RID_ESP, ofs, ir->i);
ofs               634 lj_asm_x86.h   	emit_movtomro(as, REX_64 + r, RID_ESP, ofs);
ofs               636 lj_asm_x86.h         ofs += sizeof(intptr_t);
ofs               659 lj_asm_x86.h         int32_t ofs = sps_scale(ir->s);  /* Use spill slot or temp slots. */
ofs               668 lj_asm_x86.h   	if (ofs) emit_movtomro(as, RID_RET|REX_64, RID_ESP, ofs);
ofs               679 lj_asm_x86.h   		  dest, RID_ESP, ofs);
ofs               682 lj_asm_x86.h   	emit_movtomro(as, RID_RETLO, RID_ESP, ofs);
ofs               683 lj_asm_x86.h   	emit_movtomro(as, RID_RETHI, RID_ESP, ofs+4);
ofs               686 lj_asm_x86.h   		  irt_isnum(ir->t) ? XOg_FSTPq : XOg_FSTPd, RID_ESP, ofs);
ofs               940 lj_asm_x86.h     int32_t ofs = sps_scale(ir->s);  /* Use spill slot or temp slots. */
ofs               945 lj_asm_x86.h       emit_rmro(as, irt_isnum(ir->t) ? XO_MOVSD : XO_MOVSS, dest, RID_ESP, ofs);
ofs               948 lj_asm_x86.h   	    irt_isnum(ir->t) ? XOg_FSTPq : XOg_FSTPd, RID_ESP, ofs);
ofs              1092 lj_asm_x86.h     if (!(as->mrm.idx == RID_NONE && as->mrm.ofs == 0))
ofs              1273 lj_asm_x86.h     int32_t ofs = (int32_t)(kslot->op2 * sizeof(Node));
ofs              1279 lj_asm_x86.h     lua_assert(ofs % sizeof(Node) == 0);
ofs              1281 lj_asm_x86.h       if (ofs != 0) {
ofs              1283 lj_asm_x86.h   	emit_gri(as, XG_ARITHi(XOg_ADD), dest|REX_GC64, ofs);
ofs              1285 lj_asm_x86.h   	emit_rmro(as, XO_LEA, dest|REX_GC64, node, ofs);
ofs              1295 lj_asm_x86.h   	       ofs + (int32_t)offsetof(Node, key.u64));
ofs              1311 lj_asm_x86.h   	      ofs + (int32_t)offsetof(Node, key.it));
ofs              1315 lj_asm_x86.h   	      ofs + (int32_t)offsetof(Node, key.it));
ofs              1323 lj_asm_x86.h   	       ofs + (int32_t)offsetof(Node, key.u32.lo),
ofs              1327 lj_asm_x86.h   	       ofs + (int32_t)offsetof(Node, key.u32.hi),
ofs              1333 lj_asm_x86.h   		 ofs + (int32_t)offsetof(Node, key.gcr),
ofs              1340 lj_asm_x86.h   	      ofs + (int32_t)offsetof(Node, key.it));
ofs              1381 lj_asm_x86.h       emit_loadi(as, dest, as->mrm.ofs);
ofs              1383 lj_asm_x86.h       emit_gri(as, XG_ARITHi(XOg_ADD), dest|REX_GC64, as->mrm.ofs);
ofs              1445 lj_asm_x86.h       if (LJ_32 && ir->o == IR_HIOP) as->mrm.ofs += 4;
ofs              1556 lj_asm_x86.h     as->mrm.ofs += 4;
ofs              1568 lj_asm_x86.h       as->mrm.ofs -= 4;
ofs              1574 lj_asm_x86.h       as->mrm.ofs -= 4;
ofs              1613 lj_asm_x86.h         as->mrm.ofs += 4;
ofs              1631 lj_asm_x86.h   	as->mrm.ofs += 4;
ofs              1634 lj_asm_x86.h   	as->mrm.ofs -= 4;
ofs              1645 lj_asm_x86.h       as->mrm.ofs += 4;
ofs              1658 lj_asm_x86.h     int32_t ofs = 8*((int32_t)ir->op1-1-LJ_FR2) +
ofs              1670 lj_asm_x86.h       emit_rmro(as, XO_MOVSD, left, base, ofs);
ofs              1677 lj_asm_x86.h         emit_rmro(as, XO_MOV, dest|REX_64, base, ofs);
ofs              1688 lj_asm_x86.h         emit_rmro(as, irt_isint(t) ? XO_CVTSI2SD : XO_CVTTSD2SI, dest, base, ofs);
ofs              1709 lj_asm_x86.h   	  emit_rmro(as, XV_RORX|VEX_64, dest, base, ofs);
ofs              1715 lj_asm_x86.h   	  emit_rmro(as, XO_MOV, dest|REX_64, base, ofs);
ofs              1720 lj_asm_x86.h         emit_rmro(as, irt_isnum(t) ? XO_MOVSD : XO_MOV, dest, base, ofs);
ofs              1737 lj_asm_x86.h         emit_rmro(as, XO_ARITHi, XOg_CMP, base, ofs+4);
ofs              1746 lj_asm_x86.h         emit_rmro(as, XO_ARITHi8, XOg_CMP|REX_64, base, ofs);
ofs              1749 lj_asm_x86.h         emit_rmro(as, XO_ARITHi, XOg_CMP, base, ofs+4);
ofs              1762 lj_asm_x86.h         emit_rmro(as, XO_MOV, tmp|REX_64, base, ofs);
ofs              1766 lj_asm_x86.h         emit_rmro(as, XO_ARITHi8, XOg_CMP, base, ofs+4);
ofs              1810 lj_asm_x86.h       int32_t ofs = sizeof(GCcdata);
ofs              1812 lj_asm_x86.h         ofs += 4; ir++;
ofs              1817 lj_asm_x86.h   	emit_movmroi(as, RID_RET, ofs, IR(ir->op2)->i);
ofs              1820 lj_asm_x86.h   	emit_movtomro(as, r, RID_RET, ofs);
ofs              1823 lj_asm_x86.h         if (ofs == sizeof(GCcdata)) break;
ofs              1824 lj_asm_x86.h         ofs -= 4; ir--;
ofs              1969 lj_asm_x86.h     int32_t ofs = sps_scale(ir->s);  /* Use spill slot or temp slots. */
ofs              1974 lj_asm_x86.h       emit_rmro(as, XO_MOVSD, dest, RID_ESP, ofs);
ofs              1976 lj_asm_x86.h     emit_rmro(as, XO_FSTPq, XOg_FSTPq, RID_ESP, ofs);
ofs              2129 lj_asm_x86.h     as->mrm.ofs = 0;
ofs              2141 lj_asm_x86.h   	as->mrm.ofs = irr->i;
ofs              2152 lj_asm_x86.h         as->mrm.ofs = IR(irr->op2)->i;
ofs              2162 lj_asm_x86.h         as->mrm.ofs = irr->i;
ofs              2165 lj_asm_x86.h         as->mrm.ofs = IR(irl->op2)->i;
ofs              2720 lj_asm_x86.h       int32_t ofs = 8*((int32_t)s-1-LJ_FR2);
ofs              2727 lj_asm_x86.h         emit_rmro(as, XO_MOVSDto, src, RID_BASE, ofs);
ofs              2737 lj_asm_x86.h   	  emit_rmro(as, XO_ARITHi, XOg_OR, RID_BASE, ofs+4);
ofs              2739 lj_asm_x86.h   	  emit_movmroi(as, RID_BASE, ofs+4, LJ_TISNUM << 15);
ofs              2741 lj_asm_x86.h   	  emit_movmroi(as, RID_BASE, ofs+4, (irt_toitype(ir->t)<<15)|0x7fff);
ofs              2744 lj_asm_x86.h   	emit_movtomro(as, REX_64IR(ir, src), RID_BASE, ofs);
ofs              2751 lj_asm_x86.h   	  emit_rmro(as, XO_MOVmi, REX_64, RID_BASE, ofs);
ofs              2753 lj_asm_x86.h   	  emit_movmroi(as, RID_BASE, ofs+4, k.u32.hi);
ofs              2754 lj_asm_x86.h   	  emit_movmroi(as, RID_BASE, ofs, k.u32.lo);
ofs              2758 lj_asm_x86.h   	emit_movmroi(as, RID_BASE, ofs, ir->i);
ofs              2764 lj_asm_x86.h   	  emit_movmroi(as, RID_BASE, ofs+4, (int32_t)(*flinks--));
ofs              2769 lj_asm_x86.h   	  emit_movmroi(as, RID_BASE, ofs+4, irt_toitype(ir->t));
ofs              3110 lj_asm_x86.h       intptr_t ofs = LJ_GC64 ? (p[0] & 0xf0) == 0x40 : LJ_64;
ofs              3111 lj_asm_x86.h       if (*(uint32_t *)(p+2+ofs) == statei && p[ofs+LJ_GC64-LJ_64] == XI_MOVmi)
ofs                43 lj_bc.h          ((uint8_t *)(p))[LJ_ENDIAN_SELECT(ofs, 3-ofs)] = (uint8_t)(x)
ofs                70 lj_carith.c    	CTSize ofs;
ofs                71 lj_carith.c    	CType *cct = lj_ctype_getfield(cts, ct, strV(o), &ofs);
ofs               639 lj_ccall.c           ccall_classify_ct(cts, cct, rcl, ofs+eofs);
ofs               641 lj_ccall.c         ccall_classify_struct(cts, ct, rcl, ofs);
ofs               645 lj_ccall.c         if ((ofs & (ct->size-1))) cl = CCALL_RCL_MEM;  /* Unaligned. */
ofs               646 lj_ccall.c         rcl[(ofs >= 8)] |= cl;
ofs               657 lj_ccall.c         fofs = ofs+ct->size;
ofs               856 lj_ccall.c         int i, ofs = 0;
ofs               861 lj_ccall.c     	memcpy((uint8_t *)dp + ofs,
ofs               864 lj_ccall.c     	*(float *)((uint8_t *)dp + ofs) = cc->fpr[i].f;
ofs               866 lj_ccall.c     	ofs += 4;
ofs               868 lj_ccall.c     	ofs = (ofs + 7) & ~7;  /* 64 bit alignment. */
ofs               870 lj_ccall.c     	*(intptr_t *)((uint8_t *)dp + ofs) = cc->gpr[2*i];
ofs               872 lj_ccall.c     	*(double *)((uint8_t *)dp + ofs) = cc->fpr[i].d;
ofs               874 lj_ccall.c     	ofs += 8;
ofs                32 lj_ccallback.c #define CALLBACK_OFS2SLOT(ofs)	(0*(ofs))
ofs                46 lj_ccallback.c   ofs -= CALLBACK_MCODE_HEAD;
ofs                47 lj_ccallback.c   group = ofs / (32*4 + CALLBACK_MCODE_GROUP);
ofs                48 lj_ccallback.c   return (ofs % (32*4 + CALLBACK_MCODE_GROUP))/4 + group*32;
ofs                78 lj_ccallback.c #define CALLBACK_OFS2SLOT(ofs)	(0*(ofs))
ofs                85 lj_ccallback.c #define CALLBACK_OFS2SLOT(ofs)		(((ofs)-CALLBACK_MCODE_HEAD)/8)
ofs                98 lj_ccallback.c   uintptr_t ofs = (uintptr_t)((uint8_t *)p -(uint8_t *)cts->cb.mcode);
ofs                99 lj_ccallback.c   if (ofs < CALLBACK_MCODE_SIZE) {
ofs               100 lj_ccallback.c     MSize slot = CALLBACK_OFS2SLOT((MSize)ofs);
ofs               101 lj_ccallback.c     if (CALLBACK_SLOT2OFS(slot) == (MSize)ofs)
ofs               467 lj_cconv.c       CTSize size = d->size, esize = dc->size, ofs = 0;
ofs               474 lj_cconv.c         if (ofs >= size)
ofs               476 lj_cconv.c         lj_cconv_ct_tv(cts, dc, dp + ofs, tv, flags);
ofs               477 lj_cconv.c         ofs += esize;
ofs               480 lj_cconv.c         if (ofs == esize) {  /* Replicate a single element. */
ofs               481 lj_cconv.c           for (; ofs < size; ofs += esize) memcpy(dp + ofs, dp, esize);
ofs               483 lj_cconv.c           memset(dp + ofs, 0, size - ofs);
ofs               570 lj_cconv.c           CTSize ofs;
ofs               571 lj_cconv.c           CType *cct = lj_ctype_getfield(cts, d, str, &ofs);
ofs               673 lj_cconv.c       CTSize ofs, esize = dc->size;
ofs               677 lj_cconv.c       for (i = 0, ofs = 0; i < len; i++, ofs += esize)
ofs               678 lj_cconv.c         lj_cconv_ct_tv(cts, dc, dp + ofs, o + i, 0);
ofs               679 lj_cconv.c       if (ofs == esize) {  /* Replicate a single element. */
ofs               680 lj_cconv.c         for (; ofs < sz; ofs += esize) memcpy(dp + ofs, dp, esize);
ofs               682 lj_cconv.c         memset(dp + ofs, 0, sz - ofs);
ofs               167 lj_cdata.c           CTSize ofs;
ofs               168 lj_cdata.c           CType *fct = lj_ctype_getfieldq(cts, ct, name, &ofs, qual);
ofs               170 lj_cdata.c     	*pp = p + ofs;
ofs               190 lj_cdata.c     	CTSize ofs;
ofs               191 lj_cdata.c     	CType *fct = lj_ctype_getfield(cts, sct, name, &ofs);
ofs               536 lj_cparse.c          CTSize ofs;
ofs               547 lj_cparse.c    	  !(fct = lj_ctype_getfield(cp->cts, ct, cp->str, &ofs)) ||
ofs               141 lj_crecord.c     CTSize ofs;		/* Offset in bytes. */
ofs               163 lj_crecord.c         ml[mlp].ofs = df->size;
ofs               168 lj_crecord.c   	ml[mlp].ofs = df->size + (cct->size >> 1);
ofs               184 lj_crecord.c     CTSize ofs = 0;
ofs               188 lj_crecord.c       while (ofs + step <= len) {
ofs               190 lj_crecord.c         ml[mlp].ofs = ofs;
ofs               193 lj_crecord.c         ofs += step;
ofs               197 lj_crecord.c     } while (ofs < len);
ofs               210 lj_crecord.c       TRef trofs = lj_ir_kintp(J, ml[i].ofs);
ofs               278 lj_crecord.c     CTSize ofs = 0;
ofs               282 lj_crecord.c       while (ofs + step <= len) {
ofs               284 lj_crecord.c         ml[mlp].ofs = ofs;
ofs               287 lj_crecord.c         ofs += step;
ofs               291 lj_crecord.c     } while (ofs < len);
ofs               304 lj_crecord.c       TRef trofs = lj_ir_kintp(J, ml[i].ofs);
ofs               627 lj_crecord.c         CTSize ofs;
ofs               628 lj_crecord.c         CType *cct = lj_ctype_getfield(cts, d, str, &ofs);
ofs               633 lj_crecord.c   	svisnz = (void *)(intptr_t)(ofs != 0);
ofs               634 lj_crecord.c   	sp = lj_ir_kint(J, (int32_t)ofs);
ofs               799 lj_crecord.c     ptrdiff_t ofs = sizeof(GCcdata);
ofs               810 lj_crecord.c       ofs = 0;
ofs               811 lj_crecord.c       ptr = crec_reassoc_ofs(J, ptr, &ofs, 1);
ofs               824 lj_crecord.c         idx = crec_reassoc_ofs(J, idx, &ofs, sz);
ofs               827 lj_crecord.c         if (LJ_LIKELY(J->flags & JIT_F_OPT_LOOP) && ofs
ofs               832 lj_crecord.c   	ptr = emitir(IRT(IR_ADD, IRT_PTR), ptr, lj_ir_kintp(J, ofs));
ofs               833 lj_crecord.c   	ofs = 0;
ofs               870 lj_crecord.c   	ofs += (ptrdiff_t)fofs;
ofs               882 lj_crecord.c   	  if (ofs)
ofs               883 lj_crecord.c   	    ptr = emitir(IRT(IR_ADD, IRT_PTR), ptr, lj_ir_kintp(J, ofs));
ofs               897 lj_crecord.c   	if (strdata(name)[0] == 'i') ofs += (ct->size >> 1);
ofs               915 lj_crecord.c     if (ofs)
ofs               916 lj_crecord.c       ptr = emitir(IRT(IR_ADD, IRT_PTR), ptr, lj_ir_kintp(J, ofs));
ofs              1003 lj_crecord.c         CTSize ofs, esize = dc->size;
ofs              1012 lj_crecord.c         for (i = 1, ofs = 0; ofs < sz; ofs += esize) {
ofs              1014 lj_crecord.c   			 lj_ir_kintp(J, ofs + sizeof(GCcdata)));
ofs              1508 lj_crecord.c   	CTSize ofs;
ofs              1509 lj_crecord.c   	CType *cct = lj_ctype_getfield(cts, ct, str, &ofs);
ofs              1514 lj_crecord.c   	  tr = lj_ir_kint(J, (int32_t)ofs);
ofs               247 lj_ctype.c           *ofs = ct->size;
ofs               257 lj_ctype.c           fct = lj_ctype_getfieldq(cts, cct, name, ofs, qual);
ofs               260 lj_ctype.c     	*ofs += ct->size;
ofs               447 lj_ctype.h       lj_ctype_getfieldq((cts), (ct), (name), (ofs), NULL)
ofs                84 lj_emit_arm.h    lua_assert(ofs >= -255 && ofs <= 255);
ofs                85 lj_emit_arm.h    if (ofs < 0) ofs = -ofs; else ai |= ARMI_LS_U;
ofs                87 lj_emit_arm.h  	       ((ofs & 0xf0) << 4) | (ofs & 0x0f);
ofs                92 lj_emit_arm.h    lua_assert(ofs >= -4095 && ofs <= 4095);
ofs                94 lj_emit_arm.h    if (*as->mcp == (ai|ARMI_LS_P|ARMI_LS_U|ARMF_D(rd^1)|ARMF_N(rn)|(ofs^4)) &&
ofs                96 lj_emit_arm.h        (uint32_t)ofs <= 252 && !(ofs & 3) && !((rd ^ (ofs >>2)) & 1) &&
ofs                99 lj_emit_arm.h      emit_lsox(as, ai == ARMI_LDR ? ARMI_LDRD : ARMI_STRD, rd&~1, rn, ofs&~4);
ofs               102 lj_emit_arm.h    if (ofs < 0) ofs = -ofs; else ai |= ARMI_LS_U;
ofs               103 lj_emit_arm.h    *--as->mcp = ai | ARMI_LS_P | ARMF_D(rd) | ARMF_N(rn) | ofs;
ofs               109 lj_emit_arm.h    lua_assert(ofs >= -1020 && ofs <= 1020 && (ofs&3) == 0);
ofs               110 lj_emit_arm.h    if (ofs < 0) ofs = -ofs; else ai |= ARMI_LS_U;
ofs               111 lj_emit_arm.h    *--as->mcp = ai | ARMI_LS_P | ARMF_D(rd & 15) | ARMF_N(rn) | (ofs >> 2);
ofs               319 lj_emit_arm.h      emit_vlso(as, irt_isnum(ir->t) ? ARMI_VLDR_D : ARMI_VLDR_S, r, base, ofs);
ofs               322 lj_emit_arm.h      emit_lso(as, ARMI_LDR, r, base, ofs);
ofs               332 lj_emit_arm.h      emit_vlso(as, irt_isnum(ir->t) ? ARMI_VSTR_D : ARMI_VSTR_S, r, base, ofs);
ofs               335 lj_emit_arm.h      emit_lso(as, ARMI_STR, r, base, ofs);
ofs               352 lj_emit_arm.h    if (ofs)
ofs               353 lj_emit_arm.h      emit_opk(as, ARMI_ADD, r, r, ofs, rset_exclude(RSET_GPR, r));
ofs               356 lj_emit_arm.h  #define emit_spsub(as, ofs)	emit_addptr(as, RID_SP, -(ofs))
ofs               115 lj_emit_arm64.h   if (ofs < 0 || (ofs & ((1<<scale)-1))) {
ofs               116 lj_emit_arm64.h     return (ofs >= -256 && ofs <= 255) ? -1 : 0;
ofs               118 lj_emit_arm64.h     return (ofs < (4096<<scale)) ? 1 : 0;
ofs               124 lj_emit_arm64.h   int ot = emit_checkofs(ai, ofs), sc = (ai >> 30) & 3;
ofs               131 lj_emit_arm64.h     int ofsm = ofs - (1<<sc), ofsp = ofs + (1<<sc);
ofs               139 lj_emit_arm64.h       ofsm = ofs;
ofs               151 lj_emit_arm64.h     *--as->mcp = ai | A64F_D(rd) | A64F_N(rn) | A64F_U12(ofs >> sc);
ofs               153 lj_emit_arm64.h     *--as->mcp = (ai^A64I_LS_U) | A64F_D(rd) | A64F_N(rn) | A64F_S9(ofs & 0x1ff);
ofs               256 lj_emit_arm64.h     int64_t ofs = glofs(as, p);
ofs               257 lj_emit_arm64.h     if (!emit_checkofs(ai, ofs)) {  /* Else split up into base reg + offset. */
ofs               260 lj_emit_arm64.h       ofs = i64 & 0x7fffull;
ofs               262 lj_emit_arm64.h     emit_lso(as, ai, r, base, ofs);
ofs               270 lj_emit_arm64.h   int64_t ofs;
ofs               278 lj_emit_arm64.h   ofs = glofs(as, k);
ofs               279 lj_emit_arm64.h   if (emit_checkofs(A64I_LDRx, ofs)) {
ofs               281 lj_emit_arm64.h 	     (r & 31), RID_GL, ofs);
ofs               385 lj_emit_arm64.h     emit_lso(as, irt_isnum(ir->t) ? A64I_LDRd : A64I_LDRs, (r & 31), base, ofs);
ofs               387 lj_emit_arm64.h     emit_lso(as, irt_is64(ir->t) ? A64I_LDRx : A64I_LDRw, r, base, ofs);
ofs               394 lj_emit_arm64.h     emit_lso(as, irt_isnum(ir->t) ? A64I_STRd : A64I_STRs, (r & 31), base, ofs);
ofs               396 lj_emit_arm64.h     emit_lso(as, irt_is64(ir->t) ? A64I_STRx : A64I_STRw, r, base, ofs);
ofs               413 lj_emit_arm64.h   if (ofs)
ofs               414 lj_emit_arm64.h     emit_opk(as, ofs < 0 ? A64I_SUBx : A64I_ADDx, r, r,
ofs               415 lj_emit_arm64.h 		 ofs < 0 ? -ofs : ofs, rset_exclude(RSET_GPR, r));
ofs               418 lj_emit_arm64.h #define emit_spsub(as, ofs)	emit_addptr(as, RID_SP, -(ofs))
ofs               202 lj_emit_mips.h   emit_tsi(as, mi, r, RID_JGL, ofs-32768);
ofs               269 lj_emit_mips.h     emit_tsi(as, irt_is64(ir->t) ? MIPSI_LD : MIPSI_LW, r, base, ofs);
ofs               272 lj_emit_mips.h 	     (r & 31), base, ofs);
ofs               279 lj_emit_mips.h     emit_tsi(as, irt_is64(ir->t) ? MIPSI_SD : MIPSI_SW, r, base, ofs);
ofs               282 lj_emit_mips.h 	     (r&31), base, ofs);
ofs               288 lj_emit_mips.h   if (ofs) {
ofs               289 lj_emit_mips.h     lua_assert(checki16(ofs));
ofs               290 lj_emit_mips.h     emit_tsi(as, MIPSI_AADDIU, r, r, ofs);
ofs               294 lj_emit_mips.h #define emit_spsub(as, ofs)	emit_addptr(as, RID_SP, -(ofs))
ofs               124 lj_emit_ppc.h    emit_tai(as, pi, r, RID_JGL, ofs-32768);
ofs               193 lj_emit_ppc.h      emit_tai(as, PPCI_LWZ, r, base, ofs);
ofs               195 lj_emit_ppc.h      emit_fai(as, irt_isnum(ir->t) ? PPCI_LFD : PPCI_LFS, r, base, ofs);
ofs               202 lj_emit_ppc.h      emit_tai(as, PPCI_STW, r, base, ofs);
ofs               204 lj_emit_ppc.h      emit_fai(as, irt_isnum(ir->t) ? PPCI_STFD : PPCI_STFS, r, base, ofs);
ofs               223 lj_emit_ppc.h    if (ofs) {
ofs               224 lj_emit_ppc.h      emit_tai(as, PPCI_ADDI, r, r, ofs);
ofs               225 lj_emit_ppc.h      if (!checki16(ofs))
ofs               226 lj_emit_ppc.h        emit_tai(as, PPCI_ADDIS, r, r, (ofs + 32768) >> 16);
ofs               232 lj_emit_ppc.h    if (ofs) {
ofs               233 lj_emit_ppc.h      emit_tai(as, PPCI_STWU, RID_TMP, RID_SP, -ofs);
ofs               111 lj_emit_x86.h        *(int32_t *)p = ofs;
ofs               112 lj_emit_x86.h      } else if (ofs == 0 && (rb&7) != RID_EBP) {
ofs               114 lj_emit_x86.h      } else if (checki8(ofs)) {
ofs               115 lj_emit_x86.h        *--p = (MCode)ofs;
ofs               119 lj_emit_x86.h        *(int32_t *)p = ofs;
ofs               125 lj_emit_x86.h      *(int32_t *)(p-4) = ofs;
ofs               145 lj_emit_x86.h    if (ofs == 0 && (rb&7) != RID_EBP) {
ofs               147 lj_emit_x86.h    } else if (checki8(ofs)) {
ofs               149 lj_emit_x86.h      *--p = (MCode)ofs;
ofs               153 lj_emit_x86.h      *(int32_t *)p = ofs;
ofs               186 lj_emit_x86.h    emit_rmro(as, xo, (Reg)(xg & 7), rb, ofs);
ofs               203 lj_emit_x86.h        *(int32_t *)p = as->mrm.ofs;
ofs               214 lj_emit_x86.h        *(int32_t *)p = as->mrm.ofs;
ofs               216 lj_emit_x86.h        if (as->mrm.ofs == 0 && (rb&7) != RID_EBP) {
ofs               218 lj_emit_x86.h        } else if (checki8(as->mrm.ofs)) {
ofs               219 lj_emit_x86.h  	*--p = (MCode)as->mrm.ofs;
ofs               223 lj_emit_x86.h  	*(int32_t *)p = as->mrm.ofs;
ofs               258 lj_emit_x86.h    emit_rmro(as, XO_MOVmi, 0, base, ofs);
ofs               263 lj_emit_x86.h    emit_rmro(as, XO_MOVto, (r), (base), (ofs))
ofs               542 lj_emit_x86.h      emit_rmro(as, XO_MOV, REX_64IR(ir, r), base, ofs);
ofs               544 lj_emit_x86.h      emit_rmro(as, irt_isnum(ir->t) ? XO_MOVSD : XO_MOVSS, r, base, ofs);
ofs               551 lj_emit_x86.h      emit_rmro(as, XO_MOVto, REX_64IR(ir, r), base, ofs);
ofs               553 lj_emit_x86.h      emit_rmro(as, irt_isnum(ir->t) ? XO_MOVSDto : XO_MOVSSto, r, base, ofs);
ofs               559 lj_emit_x86.h    if (ofs) {
ofs               561 lj_emit_x86.h        emit_rmro(as, XO_LEA, r|REX_GC64, r, ofs);
ofs               563 lj_emit_x86.h        emit_gri(as, XG_ARITHi(XOg_ADD), r|REX_GC64, ofs);
ofs               567 lj_emit_x86.h  #define emit_spsub(as, ofs)	emit_addptr(as, RID_ESP|REX_64, -(ofs))
ofs               186 lj_gdbjit.c      uintptr_t ofs;
ofs               423 lj_gdbjit.c      uint32_t ofs = (uint32_t)(p - ctx->startp);
ofs               428 lj_gdbjit.c      return ofs;
ofs               478 lj_gdbjit.c      sect->ofs = 0;
ofs               488 lj_gdbjit.c      sect->ofs = offsetof(GDBJITobj, sym);
ofs               701 lj_gdbjit.c      ctx->obj.sect[sect].ofs = (uintptr_t)((char *)ctx->p - (char *)&ctx->obj);
ofs                97 lj_ir.c            MSize ofs = szins >> 2;
ofs                98 lj_ir.c            memmove(baseir + ofs, baseir, (J->cur.nins - J->irbotlim)*sizeof(IRIns));
ofs                99 lj_ir.c            J->irbotlim -= ofs;
ofs               100 lj_ir.c            J->irtoplim -= ofs;
ofs               105 lj_ir.c            MSize ofs = szins >= 256 ? 128 : (szins >> 1);  /* Limit bottom growth. */
ofs               106 lj_ir.c            memcpy(newbase + ofs, baseir, (J->cur.nins - J->irbotlim)*sizeof(IRIns));
ofs               108 lj_ir.c            J->irbotlim -= ofs;
ofs               151 lj_ir.c          lua_assert((ofs & 3) == 0);
ofs               152 lj_ir.c          ofs >>= 2;
ofs               153 lj_ir.c          lua_assert(ofs >= IRFL__MAX && ofs <= 0x3ff);  /* 10 bit FOLD key limit. */
ofs               154 lj_ir.c          lj_ir_set(J, IRT(IR_FLOAD, t), REF_NIL, ofs);
ofs               717 lj_opt_fold.c    ptrdiff_t ofs = (ptrdiff_t)ir_kint64(fright)->u64;
ofs               719 lj_opt_fold.c    ptrdiff_t ofs = fright->i;
ofs               727 lj_opt_fold.c        return lj_ir_kkptr(J, (char *)o + ofs);
ofs               730 lj_opt_fold.c    return lj_ir_kptr(J, (char *)o + ofs);
ofs               741 lj_opt_fold.c    ptrdiff_t ofs = (ptrdiff_t)ir_kint64(fright)->u64;
ofs               743 lj_opt_fold.c    ptrdiff_t ofs = fright->i;
ofs               745 lj_opt_fold.c    return lj_ir_kptr_(J, fleft->o, (char *)p + ofs);
ofs              1216 lj_opt_fold.c    int64_t ofs = 0;
ofs              1223 lj_opt_fold.c      ofs = (int64_t)IR(fleft->op2)->i;
ofs              1230 lj_opt_fold.c      if (lo && IR(lo)->o == IR_KINT && IR(lo)->i + ofs >= 0) {
ofs               689 lj_opt_mem.c     ptrdiff_t ofs = 0;
ofs               692 lj_opt_mem.c       ofs = (LJ_64 && irk->o == IR_KINT64) ? (ptrdiff_t)ir_k64(irk)->u64 :
ofs               711 lj_opt_mem.c         ofs += (ptrdiff_t)IR(ir2->op2)->i << shift;
ofs               722 lj_opt_mem.c       if (ofs != 0) {
ofs               723 lj_opt_mem.c         IRRef refk = tref_ref(lj_ir_kintp(J, ofs));
ofs               187 lj_opt_split.c   int32_t ofs = 4;
ofs               189 lj_opt_split.c     return lj_ir_kptr(J, (char *)ir_kptr(ir) + ofs);
ofs               192 lj_opt_split.c     ofs += IR(ir->op2)->i;
ofs               194 lj_opt_split.c     if (ofs == 0) return nref;
ofs               196 lj_opt_split.c   return split_emit(J, IRT(IR_ADD, IRT_PTR), nref, lj_ir_kint(J, ofs));
ofs              1255 lj_record.c        int32_t ofs = 0;
ofs              1260 lj_record.c          ofs = IR(ofsref)->i;
ofs              1270 lj_record.c          if ((uint64_t)stop + ofs < (uint64_t)asize) {
ofs              1272 lj_record.c    	emitir(IRTG(IR_ABC, IRT_P32), asizeref, ofs == 0 ? J->scev.stop :
ofs              1276 lj_record.c    	      (int64_t)IR(J->scev.start)->i + ofs >= 0))
ofs               178 lj_target_x86.h   int32_t ofs;		/* Offset. */
ofs               118 lj_vm.h        #define makeasmfunc(ofs)	((ASMFunction)(lj_vm_asm_begin + (ofs)))