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               210 host/buildvm.c     int32_t ofs = dasm_getpclabel(Dst, i);
ofs               211 host/buildvm.c     if (ofs < 0) return 0x22000000|i;
ofs               212 host/buildvm.c     ctx->bc_ofs[i] = ofs;
ofs               217 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               241 host/buildvm_asm.c     int32_t ofs = ctx->sym[i].ofs;
ofs               242 host/buildvm_asm.c     int32_t next = ctx->sym[i+1].ofs;
ofs               253 host/buildvm_asm.c     emit_asm_label(ctx, ctx->sym[i].name, next - ofs, 1);
ofs               254 host/buildvm_asm.c     while (rel < ctx->nreloc && ctx->reloc[rel].ofs <= next) {
ofs               256 host/buildvm_asm.c       int n = r->ofs - ofs;
ofs               259 host/buildvm_asm.c 	emit_asm_reloc_mach(ctx, ctx->code+ofs, n, ctx->relocsym[r->sym]);
ofs               261 host/buildvm_asm.c 	emit_asm_bytes(ctx, ctx->code+ofs, n);
ofs               264 host/buildvm_asm.c       ofs += n+4;
ofs               266 host/buildvm_asm.c       emit_asm_wordreloc(ctx, ctx->code+ofs, n, ctx->relocsym[r->sym]);
ofs               267 host/buildvm_asm.c       ofs += n;
ofs               272 host/buildvm_asm.c     emit_asm_bytes(ctx, ctx->code+ofs, next-ofs);
ofs               274 host/buildvm_asm.c     emit_asm_words(ctx, ctx->code+ofs, next-ofs);
ofs                37 host/buildvm_peobj.c   uint32_t ofs;
ofs               188 host/buildvm_peobj.c   pesect[PEOBJ_SECT_TEXT].ofs = sofs;
ofs               197 host/buildvm_peobj.c   pesect[PEOBJ_SECT_PDATA].ofs = sofs;
ofs               205 host/buildvm_peobj.c   pesect[PEOBJ_SECT_XDATA].ofs = sofs;
ofs               214 host/buildvm_peobj.c   pesect[PEOBJ_SECT_RDATA_Z].ofs = sofs;
ofs               258 host/buildvm_peobj.c     reloc.vaddr = (uint32_t)ctx->reloc[i].ofs + PEOBJ_RELOC_OFS;
ofs               266 host/buildvm_peobj.c     uint32_t fcofs = (uint32_t)ctx->sym[ctx->nsym-1].ofs;
ofs               343 host/buildvm_peobj.c       emit_peobj_sym(ctx, ctx->sym[i].name, (uint32_t)ctx->sym[i].ofs,
ofs               629 lib_ffi.c        CTSize ofs;
ofs               631 lib_ffi.c          CType *fct = lj_ctype_getfield(cts, ct, name, &ofs);
ofs               633 lib_ffi.c            setintV(L->top-1, ofs);
ofs               320 lib_io.c         int64_t ofs = 0;
ofs               329 lib_io.c             ofs = (int64_t)intV(o);
ofs               331 lib_io.c             ofs = (int64_t)numV(o);
ofs               336 lib_io.c         res = fseeko(fp, ofs, opt);
ofs               338 lib_io.c         res = _fseeki64(fp, ofs, opt);
ofs               340 lib_io.c         res = fseeko64(fp, ofs, opt);
ofs               342 lib_io.c         res = fseek(fp, (long)ofs, opt);
ofs               347 lib_io.c         ofs = ftello(fp);
ofs               349 lib_io.c         ofs = _ftelli64(fp);
ofs               351 lib_io.c         ofs = ftello64(fp);
ofs               353 lib_io.c         ofs = (int64_t)ftell(fp);
ofs               355 lib_io.c         setint64V(L->top-1, ofs);
ofs               162 lj_asm.c       #define FLOFS(name, ofs)	(uint8_t)(ofs),
ofs               395 lj_asm.c           int32_t ofs = ra_spill(as, ir);  /* Force a spill slot. */
ofs               403 lj_asm.c             emit_spload(as, ir, r, ofs);
ofs              1470 lj_asm.c       	int32_t ofs = sps_scale(regsp_spill(rs));
ofs              1472 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               635 lj_asm_arm.h     int32_t ofs = 0;
ofs               650 lj_asm_arm.h         ofs = sps_scale(ir->s);
ofs               666 lj_asm_arm.h         ofs = sps_scale(ir->s);
ofs               671 lj_asm_arm.h   	emit_spload(as, ir, ir->r, ofs);
ofs               686 lj_asm_arm.h     if (ofs == 0)
ofs               689 lj_asm_arm.h       emit_opk(as, ARMI_ADD, tmp, RID_SP, ofs, RSET_GPR);
ofs               752 lj_asm_arm.h       int32_t ofs = asm_fuseabase(as, tab);
ofs               753 lj_asm_arm.h       IRRef refa = ofs ? tab : ir->op1;
ofs               754 lj_asm_arm.h       uint32_t k = emit_isk12(ARMI_ADD, ofs + 8*IR(ir->op2)->i);
ofs               917 lj_asm_arm.h     int32_t ofs = (int32_t)(kslot->op2 * sizeof(Node));
ofs               918 lj_asm_arm.h     int32_t kofs = ofs + (int32_t)offsetof(Node, key);
ofs               919 lj_asm_arm.h     Reg dest = (ra_used(ir) || ofs > 4095) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
ofs               923 lj_asm_arm.h     lua_assert(ofs % sizeof(Node) == 0);
ofs               924 lj_asm_arm.h     if (ofs > 4095) {
ofs               929 lj_asm_arm.h       emit_opk(as, ARMI_ADD, dest, node, ofs, allow);
ofs               959 lj_asm_arm.h     if (ofs > 4095)
ofs               960 lj_asm_arm.h       emit_opk(as, ARMI_ADD, dest, node, ofs, RSET_GPR);
ofs              1070 lj_asm_arm.h     int32_t ofs;
ofs              1072 lj_asm_arm.h       ofs = asm_fuseabase(as, ir->op1);
ofs              1073 lj_asm_arm.h       if (ofs) {  /* Turn the t->array load into an add for colocated arrays. */
ofs              1074 lj_asm_arm.h         emit_dn(as, ARMI_ADD|ARMI_K12|ofs, dest, idx);
ofs              1078 lj_asm_arm.h     ofs = field_ofs[ir->op2];
ofs              1080 lj_asm_arm.h       emit_lso(as, ai, dest, idx, ofs);
ofs              1082 lj_asm_arm.h       emit_lsox(as, ai, dest, idx, ofs);
ofs              1091 lj_asm_arm.h       int32_t ofs = field_ofs[irf->op2];
ofs              1094 lj_asm_arm.h         emit_lso(as, ai, src, idx, ofs);
ofs              1096 lj_asm_arm.h         emit_lsox(as, ai, src, idx, ofs);
ofs              1114 lj_asm_arm.h   		 rset_exclude(RSET_GPR, src), ofs);
ofs              1124 lj_asm_arm.h     int32_t ofs = 0;
ofs              1135 lj_asm_arm.h     idx = asm_fuseahuref(as, ir->op1, &ofs, allow,
ofs              1139 lj_asm_arm.h       if (ofs < 256 && ra_hasreg(dest) && (dest & 1) == 0 &&
ofs              1152 lj_asm_arm.h         emit_vlso(as, ARMI_VLDR_D, dest, idx, ofs);
ofs              1155 lj_asm_arm.h         emit_lso(as, ARMI_LDR, dest, idx, ofs);
ofs              1157 lj_asm_arm.h     emit_lso(as, ARMI_LDR, type, idx, ofs+4);
ofs              1165 lj_asm_arm.h       int32_t ofs = 0;
ofs              1169 lj_asm_arm.h         idx = asm_fuseahuref(as, ir->op1, &ofs, allow, 1024);
ofs              1170 lj_asm_arm.h         emit_vlso(as, ARMI_VSTR_D, src, idx, ofs);
ofs              1183 lj_asm_arm.h         idx = asm_fuseahuref(as, ir->op1, &ofs, rset_exclude(allow, type), 4096);
ofs              1184 lj_asm_arm.h         if (ra_hasreg(src)) emit_lso(as, ARMI_STR, src, idx, ofs);
ofs              1185 lj_asm_arm.h         emit_lso(as, ARMI_STR, type, idx, ofs+4);
ofs              1192 lj_asm_arm.h     int32_t ofs = 8*((int32_t)ir->op1-1) + ((ir->op2 & IRSLOAD_FRAME) ? 4 : 0);
ofs              1240 lj_asm_arm.h         if (ofs < 256 && ra_hasreg(dest) && (dest & 1) == 0 &&
ofs              1254 lj_asm_arm.h         if (ofs < 1024) {
ofs              1255 lj_asm_arm.h   	emit_vlso(as, ARMI_VLDR_D, dest, base, ofs);
ofs              1257 lj_asm_arm.h   	if (ra_hasreg(type)) emit_lso(as, ARMI_LDR, type, base, ofs+4);
ofs              1259 lj_asm_arm.h   	emit_opk(as, ARMI_ADD, RID_TMP, base, ofs, allow);
ofs              1264 lj_asm_arm.h         emit_lso(as, ARMI_LDR, dest, base, ofs);
ofs              1266 lj_asm_arm.h     if (ra_hasreg(type)) emit_lso(as, ARMI_LDR, type, base, ofs+4);
ofs              1296 lj_asm_arm.h       int32_t ofs = sizeof(GCcdata);
ofs              1299 lj_asm_arm.h         ofs += 4; ir++;
ofs              1304 lj_asm_arm.h         emit_lso(as, ARMI_STR, r, RID_RET, ofs);
ofs              1306 lj_asm_arm.h         if (ofs == sizeof(GCcdata)) break;
ofs              1307 lj_asm_arm.h         ofs -= 4; ir--;
ofs              1993 lj_asm_arm.h       int32_t ofs = 8*((int32_t)s-1);
ofs              2005 lj_asm_arm.h         emit_lso(as, ARMI_STR, tmp, RID_BASE, ofs);
ofs              2008 lj_asm_arm.h         emit_lso(as, ARMI_STR, tmp, RID_BASE, ofs+4);
ofs              2011 lj_asm_arm.h         emit_vlso(as, ARMI_VSTR_D, src, RID_BASE, ofs);
ofs              2019 lj_asm_arm.h   	emit_lso(as, ARMI_STR, src, RID_BASE, ofs);
ofs              2032 lj_asm_arm.h         emit_lso(as, ARMI_STR, type, RID_BASE, ofs+4);
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  	int32_t ofs = i32ptr(&gcref(fn->l.uvptr[(ir->op2 >> 8)])->uv.tv);
ofs               170 lj_asm_mips.h  	if ((uint32_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 + IR(ir->op2)->i, checki16(ofs2))) {
ofs               195 lj_asm_mips.h  	ofs = ofs2;
ofs               199 lj_asm_mips.h        lua_assert(ofs == 0);
ofs               200 lj_asm_mips.h        ofs = (int32_t)sizeof(GCstr);
ofs               202 lj_asm_mips.h  	ofs2 = ofs + IR(ir->op2)->i;
ofs               205 lj_asm_mips.h  	ofs2 = ofs + IR(ir->op1)->i;
ofs               212 lj_asm_mips.h  	emit_hsi(as, mi, rt, RID_TMP, ofs);
ofs               216 lj_asm_mips.h        ofs = ofs2;
ofs               220 lj_asm_mips.h    emit_hsi(as, mi, rt, base, ofs);
ofs               229 lj_asm_mips.h    int32_t ofs = 16;
ofs               273 lj_asm_mips.h  	  if (irt_isnum(ir->t)) ofs = (ofs + 4) & ~4;
ofs               274 lj_asm_mips.h  	  emit_spstore(as, ir, r, ofs);
ofs               275 lj_asm_mips.h  	  ofs += irt_isnum(ir->t) ? 8 : 4;
ofs               283 lj_asm_mips.h  	ofs += 4;
ofs               305 lj_asm_mips.h  	int32_t ofs = sps_scale(ir->s);
ofs               313 lj_asm_mips.h  	if (ofs) {
ofs               314 lj_asm_mips.h  	  emit_tsi(as, MIPSI_SW, RID_RETLO, RID_SP, ofs+(LJ_BE?4:0));
ofs               315 lj_asm_mips.h  	  emit_tsi(as, MIPSI_SW, RID_RETHI, RID_SP, ofs+(LJ_BE?0:4));
ofs               606 lj_asm_mips.h      int32_t ofs = asm_fuseabase(as, tab);
ofs               607 lj_asm_mips.h      IRRef refa = ofs ? tab : ir->op1;
ofs               608 lj_asm_mips.h      ofs += 8*IR(ir->op2)->i;
ofs               609 lj_asm_mips.h      if (checki16(ofs)) {
ofs               611 lj_asm_mips.h        emit_tsi(as, MIPSI_ADDIU, dest, base, ofs);
ofs               738 lj_asm_mips.h    int32_t ofs = (int32_t)(kslot->op2 * sizeof(Node));
ofs               739 lj_asm_mips.h    int32_t kofs = ofs + (int32_t)offsetof(Node, key);
ofs               740 lj_asm_mips.h    Reg dest = (ra_used(ir)||ofs > 32736) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
ofs               745 lj_asm_mips.h    lua_assert(ofs % sizeof(Node) == 0);
ofs               746 lj_asm_mips.h    if (ofs > 32736) {
ofs               751 lj_asm_mips.h      emit_tsi(as, MIPSI_ADDIU, dest, node, ofs);
ofs               771 lj_asm_mips.h    if (ofs > 32736)
ofs               772 lj_asm_mips.h      emit_tsi(as, MIPSI_ADDU, dest, node, ra_allock(as, ofs, allow));
ofs               821 lj_asm_mips.h    int32_t ofs = (int32_t)sizeof(GCstr);
ofs               833 lj_asm_mips.h  	       checki16(ofs + IR(irr->op2)->i)) {
ofs               834 lj_asm_mips.h        ofs += IR(irr->op2)->i;
ofs               839 lj_asm_mips.h      emit_tsi(as, MIPSI_ADDIU, dest, dest, ofs);
ofs               844 lj_asm_mips.h    ofs += IR(refk)->i;
ofs               845 lj_asm_mips.h    if (checki16(ofs))
ofs               846 lj_asm_mips.h      emit_tsi(as, MIPSI_ADDIU, dest, r, ofs);
ofs               849 lj_asm_mips.h  	     ra_allock(as, ofs, rset_exclude(RSET_GPR, r)));
ofs               883 lj_asm_mips.h    int32_t ofs;
ofs               885 lj_asm_mips.h      ofs = asm_fuseabase(as, ir->op1);
ofs               886 lj_asm_mips.h      if (ofs) {  /* Turn the t->array load into an add for colocated arrays. */
ofs               887 lj_asm_mips.h        emit_tsi(as, MIPSI_ADDIU, dest, idx, ofs);
ofs               891 lj_asm_mips.h    ofs = field_ofs[ir->op2];
ofs               893 lj_asm_mips.h    emit_tsi(as, mi, dest, idx, ofs);
ofs               902 lj_asm_mips.h      int32_t ofs = field_ofs[irf->op2];
ofs               905 lj_asm_mips.h      emit_tsi(as, mi, src, idx, ofs);
ofs               921 lj_asm_mips.h  		 rset_exclude(RSET_GPR, src), ofs);
ofs               930 lj_asm_mips.h    int32_t ofs = 0;
ofs               936 lj_asm_mips.h    idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
ofs               942 lj_asm_mips.h        emit_hsi(as, MIPSI_LDC1, dest, idx, ofs);
ofs               945 lj_asm_mips.h      if (ra_hasreg(dest)) emit_tsi(as, MIPSI_LW, dest, idx, ofs+(LJ_BE?4:0));
ofs               947 lj_asm_mips.h    emit_tsi(as, MIPSI_LW, type, idx, ofs+(LJ_BE?0:4));
ofs               954 lj_asm_mips.h    int32_t ofs = 0;
ofs               967 lj_asm_mips.h    idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
ofs               969 lj_asm_mips.h      emit_hsi(as, MIPSI_SDC1, src, idx, ofs);
ofs               972 lj_asm_mips.h        emit_tsi(as, MIPSI_SW, src, idx, ofs+(LJ_BE?4:0));
ofs               973 lj_asm_mips.h      emit_tsi(as, MIPSI_SW, type, idx, ofs+(LJ_BE?0:4));
ofs               979 lj_asm_mips.h    int32_t ofs = 8*((int32_t)ir->op1-1) + ((ir->op2 & IRSLOAD_FRAME) ? 4 : 0);
ofs              1022 lj_asm_mips.h      if (ra_hasreg(dest)) emit_hsi(as, MIPSI_LDC1, dest, base, ofs);
ofs              1029 lj_asm_mips.h      if (ra_hasreg(dest)) emit_tsi(as, MIPSI_LW, dest, base, ofs ^ (LJ_BE?4:0));
ofs              1031 lj_asm_mips.h    if (ra_hasreg(type)) emit_tsi(as, MIPSI_LW, type, base, ofs ^ (LJ_BE?0:4));
ofs              1061 lj_asm_mips.h      int32_t ofs = sizeof(GCcdata);
ofs              1064 lj_asm_mips.h        ofs += 4;
ofs              1070 lj_asm_mips.h        emit_tsi(as, MIPSI_SW, r, RID_RET, ofs);
ofs              1072 lj_asm_mips.h        if (ofs == sizeof(GCcdata)) break;
ofs              1073 lj_asm_mips.h        ofs -= 4; if (LJ_BE) ir++; else ir--;
ofs              1636 lj_asm_mips.h      int32_t ofs = 8*((int32_t)s-1);
ofs              1643 lj_asm_mips.h        emit_hsi(as, MIPSI_SDC1, src, RID_BASE, ofs);
ofs              1651 lj_asm_mips.h  	emit_tsi(as, MIPSI_SW, src, RID_BASE, ofs+(LJ_BE?4:0));
ofs              1659 lj_asm_mips.h        emit_tsi(as, MIPSI_SW, type, RID_BASE, ofs+(LJ_BE?0:4));
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               255 lj_asm_ppc.h     int32_t ofs = 8;
ofs               270 lj_asm_ppc.h   	  if (irt_isnum(ir->t)) ofs = (ofs + 4) & ~4;
ofs               271 lj_asm_ppc.h   	  emit_spstore(as, ir, r, ofs);
ofs               272 lj_asm_ppc.h   	  ofs += irt_isnum(ir->t) ? 8 : 4;
ofs               281 lj_asm_ppc.h   	  emit_spstore(as, ir, r, ofs);
ofs               282 lj_asm_ppc.h   	  ofs += 4;
ofs               289 lj_asm_ppc.h   	ofs += 4;
ofs               314 lj_asm_ppc.h   	int32_t ofs = ir->s ? sps_scale(ir->s) : SPOFS_TMP;
ofs               319 lj_asm_ppc.h   	  emit_fai(as, PPCI_LFD, dest, RID_SP, ofs);
ofs               321 lj_asm_ppc.h   	emit_tai(as, PPCI_STW, RID_RETHI, RID_SP, ofs);
ofs               322 lj_asm_ppc.h   	emit_tai(as, PPCI_STW, RID_RETLO, RID_SP, ofs+4);
ofs               542 lj_asm_ppc.h     int32_t ofs;
ofs               552 lj_asm_ppc.h     ofs = ir->s ? sps_scale(ir->s) : SPOFS_TMP;
ofs               553 lj_asm_ppc.h     emit_tai(as, PPCI_ADDI, ra_releasetmp(as, ASMREF_TMP1), RID_SP, ofs);
ofs               606 lj_asm_ppc.h       int32_t ofs = asm_fuseabase(as, tab);
ofs               607 lj_asm_ppc.h       IRRef refa = ofs ? tab : ir->op1;
ofs               608 lj_asm_ppc.h       ofs += 8*IR(ir->op2)->i;
ofs               609 lj_asm_ppc.h       if (checki16(ofs)) {
ofs               611 lj_asm_ppc.h         emit_tai(as, PPCI_ADDI, dest, base, ofs);
ofs               717 lj_asm_ppc.h   	int32_t ofs = ra_spill(as, irkey);
ofs               721 lj_asm_ppc.h   	emit_tai(as, PPCI_LWZ, tmp2, RID_SP, ofs+4);
ofs               722 lj_asm_ppc.h   	emit_tai(as, PPCI_LWZ, tmp1, RID_SP, ofs);
ofs               737 lj_asm_ppc.h     int32_t ofs = (int32_t)(kslot->op2 * sizeof(Node));
ofs               738 lj_asm_ppc.h     int32_t kofs = ofs + (int32_t)offsetof(Node, key);
ofs               739 lj_asm_ppc.h     Reg dest = (ra_used(ir)||ofs > 32736) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
ofs               743 lj_asm_ppc.h     lua_assert(ofs % sizeof(Node) == 0);
ofs               744 lj_asm_ppc.h     if (ofs > 32736) {
ofs               749 lj_asm_ppc.h       emit_tai(as, PPCI_ADDI, dest, node, ofs);
ofs               770 lj_asm_ppc.h     if (ofs > 32736) {
ofs               771 lj_asm_ppc.h       emit_tai(as, PPCI_ADDIS, dest, dest, (ofs + 32768) >> 16);
ofs               772 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               887 lj_asm_ppc.h       ofs = asm_fuseabase(as, ir->op1);
ofs               888 lj_asm_ppc.h       if (ofs) {  /* Turn the t->array load into an add for colocated arrays. */
ofs               889 lj_asm_ppc.h         emit_tai(as, PPCI_ADDI, dest, idx, ofs);
ofs               893 lj_asm_ppc.h     ofs = field_ofs[ir->op2];
ofs               895 lj_asm_ppc.h     emit_tai(as, pi, dest, idx, ofs);
ofs               904 lj_asm_ppc.h       int32_t ofs = field_ofs[irf->op2];
ofs               906 lj_asm_ppc.h       emit_tai(as, pi, src, idx, ofs);
ofs               924 lj_asm_ppc.h     if (ofs == 0 && mayfuse(as, ir->op2) && (irb = IR(ir->op2))->o == IR_BSWAP &&
ofs               932 lj_asm_ppc.h   		 rset_exclude(RSET_GPR, src), ofs);
ofs               941 lj_asm_ppc.h     int32_t ofs = AHUREF_LSX;
ofs               944 lj_asm_ppc.h       if (!irt_isnum(t)) ofs = 0;
ofs               948 lj_asm_ppc.h     idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
ofs               954 lj_asm_ppc.h         if (ofs == AHUREF_LSX) {
ofs               959 lj_asm_ppc.h   	emit_fai(as, PPCI_LFD, dest, idx, ofs);
ofs               965 lj_asm_ppc.h       if (ra_hasreg(dest)) emit_tai(as, PPCI_LWZ, dest, idx, ofs+4);
ofs               967 lj_asm_ppc.h     if (ofs == AHUREF_LSX) {
ofs               971 lj_asm_ppc.h       emit_tai(as, PPCI_LWZ, type, idx, ofs);
ofs               979 lj_asm_ppc.h     int32_t ofs = AHUREF_LSX;
ofs               988 lj_asm_ppc.h         ofs = 0;
ofs               993 lj_asm_ppc.h     idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
ofs               995 lj_asm_ppc.h       if (ofs == AHUREF_LSX) {
ofs               999 lj_asm_ppc.h         emit_fai(as, PPCI_STFD, src, idx, ofs);
ofs              1003 lj_asm_ppc.h         emit_tai(as, PPCI_STW, src, idx, ofs+4);
ofs              1004 lj_asm_ppc.h       if (ofs == AHUREF_LSX) {
ofs              1008 lj_asm_ppc.h         emit_tai(as, PPCI_STW, type, idx, ofs);
ofs              1015 lj_asm_ppc.h     int32_t ofs = 8*((int32_t)ir->op1-1) + ((ir->op2 & IRSLOAD_FRAME) ? 0 : 4);
ofs              1068 lj_asm_ppc.h       if (ra_hasreg(dest)) emit_fai(as, PPCI_LFD, dest, base, ofs-4);
ofs              1075 lj_asm_ppc.h       if (ra_hasreg(dest)) emit_tai(as, PPCI_LWZ, dest, base, ofs);
ofs              1077 lj_asm_ppc.h     if (ra_hasreg(type)) emit_tai(as, PPCI_LWZ, type, base, ofs-4);
ofs              1107 lj_asm_ppc.h       int32_t ofs = sizeof(GCcdata);
ofs              1110 lj_asm_ppc.h         ofs += 4;
ofs              1115 lj_asm_ppc.h         emit_tai(as, PPCI_STW, r, RID_RET, ofs);
ofs              1117 lj_asm_ppc.h         if (ofs == sizeof(GCcdata)) break;
ofs              1118 lj_asm_ppc.h         ofs -= 4; ir++;
ofs              1823 lj_asm_ppc.h       int32_t ofs = 8*((int32_t)s-1);
ofs              1830 lj_asm_ppc.h         emit_fai(as, PPCI_STFD, src, RID_BASE, ofs);
ofs              1838 lj_asm_ppc.h   	emit_tai(as, PPCI_STW, src, RID_BASE, ofs+4);
ofs              1846 lj_asm_ppc.h         emit_tai(as, PPCI_STW, type, RID_BASE, ofs);
ofs               115 lj_asm_x86.h     as->mrm.ofs = 0;
ofs               122 lj_asm_x86.h         as->mrm.ofs = (int32_t)sizeof(GCtab);  /* Ofs to colocated array. */
ofs               127 lj_asm_x86.h       as->mrm.ofs = IR(irb->op2)->i;
ofs               141 lj_asm_x86.h       as->mrm.ofs += 8*irx->i;
ofs               152 lj_asm_x86.h         as->mrm.ofs += 8*IR(irx->op2)->i;
ofs               179 lj_asm_x86.h   	as->mrm.ofs = (int32_t)(IR(ir->op2)->op2 * sizeof(Node));
ofs               188 lj_asm_x86.h   	as->mrm.ofs = ptr2addr(&uv->tv);
ofs               200 lj_asm_x86.h     as->mrm.ofs = 0;
ofs               208 lj_asm_x86.h     as->mrm.ofs = field_ofs[ir->op2];
ofs               211 lj_asm_x86.h       as->mrm.ofs += IR(ir->op1)->i;
ofs               225 lj_asm_x86.h     as->mrm.ofs = sizeof(GCstr);
ofs               227 lj_asm_x86.h       as->mrm.ofs += IR(ir->op1)->i;
ofs               235 lj_asm_x86.h       as->mrm.ofs += irr->i;
ofs               241 lj_asm_x86.h         as->mrm.ofs += IR(irr->op2)->i;
ofs               258 lj_asm_x86.h       as->mrm.ofs = ir->i;
ofs               263 lj_asm_x86.h       as->mrm.ofs = 0;
ofs               269 lj_asm_x86.h         if (asm_isk32(as, ir->op2, &as->mrm.ofs)) {  /* Recognize x+ofs. */
ofs               316 lj_asm_x86.h       as->mrm.ofs = ra_spill(as, ir);
ofs               324 lj_asm_x86.h         as->mrm.ofs = ptr2addr(ir_knum(ir));
ofs               332 lj_asm_x86.h         as->mrm.ofs = ptr2addr(ref == REF_BASE ? (void *)&J2G(as->J)->jit_base : (void *)ir_kint64(ir));
ofs               342 lj_asm_x86.h   	as->mrm.ofs = 8*((int32_t)ir->op1-1) + ((ir->op2&IRSLOAD_FRAME)?4:0);
ofs               429 lj_asm_x86.h     int32_t ofs = STACKARG_OFS;
ofs               504 lj_asm_x86.h         if (LJ_32 && (ofs & 4) && irref_isk(ref)) {
ofs               506 lj_asm_x86.h   	emit_movmroi(as, RID_ESP, ofs, (int32_t)ir_knum(ir)->u32.lo);
ofs               507 lj_asm_x86.h   	emit_movmroi(as, RID_ESP, ofs+4, (int32_t)ir_knum(ir)->u32.hi);
ofs               511 lj_asm_x86.h   		  r, RID_ESP, ofs);
ofs               513 lj_asm_x86.h         ofs += (LJ_32 && irt_isfloat(ir->t)) ? 4 : 8;
ofs               516 lj_asm_x86.h   	emit_movmroi(as, RID_ESP, ofs, ir->i);
ofs               519 lj_asm_x86.h   	emit_movtomro(as, REX_64 + r, RID_ESP, ofs);
ofs               521 lj_asm_x86.h         ofs += sizeof(intptr_t);
ofs               544 lj_asm_x86.h         int32_t ofs = sps_scale(ir->s);  /* Use spill slot or temp slots. */
ofs               553 lj_asm_x86.h   	if (ofs) emit_movtomro(as, RID_RET|REX_64, RID_ESP, ofs);
ofs               564 lj_asm_x86.h   		  dest, RID_ESP, ofs);
ofs               567 lj_asm_x86.h   	emit_movtomro(as, RID_RETLO, RID_ESP, ofs);
ofs               568 lj_asm_x86.h   	emit_movtomro(as, RID_RETHI, RID_ESP, ofs+4);
ofs               571 lj_asm_x86.h   		  irt_isnum(ir->t) ? XOg_FSTPq : XOg_FSTPd, RID_ESP, ofs);
ofs               832 lj_asm_x86.h     int32_t ofs = sps_scale(ir->s);  /* Use spill slot or temp slots. */
ofs               838 lj_asm_x86.h   	      dest, RID_ESP, ofs);
ofs               841 lj_asm_x86.h   	    irt_isnum(ir->t) ? XOg_FSTPq : XOg_FSTPd, RID_ESP, ofs);
ofs               957 lj_asm_x86.h     if (!(as->mrm.idx == RID_NONE && as->mrm.ofs == 0))
ofs              1120 lj_asm_x86.h     int32_t ofs = (int32_t)(kslot->op2 * sizeof(Node));
ofs              1126 lj_asm_x86.h     lua_assert(ofs % sizeof(Node) == 0);
ofs              1128 lj_asm_x86.h       if (ofs != 0) {
ofs              1130 lj_asm_x86.h   	emit_gri(as, XG_ARITHi(XOg_ADD), dest, ofs);
ofs              1132 lj_asm_x86.h   	emit_rmro(as, XO_LEA, dest, node, ofs);
ofs              1142 lj_asm_x86.h   	       ofs + (int32_t)offsetof(Node, key.u64));
ofs              1152 lj_asm_x86.h   	      ofs + (int32_t)offsetof(Node, key.it));
ofs              1159 lj_asm_x86.h   	       ofs + (int32_t)offsetof(Node, key.u32.lo),
ofs              1163 lj_asm_x86.h   	       ofs + (int32_t)offsetof(Node, key.u32.hi),
ofs              1169 lj_asm_x86.h   		 ofs + (int32_t)offsetof(Node, key.gcr),
ofs              1176 lj_asm_x86.h   	      ofs + (int32_t)offsetof(Node, key.it));
ofs              1251 lj_asm_x86.h       emit_loadi(as, dest, as->mrm.ofs);
ofs              1253 lj_asm_x86.h       emit_gri(as, XG_ARITHi(XOg_ADD), dest, as->mrm.ofs);
ofs              1312 lj_asm_x86.h       if (LJ_32 && ir->o == IR_HIOP) as->mrm.ofs += 4;
ofs              1393 lj_asm_x86.h     as->mrm.ofs += 4;
ofs              1435 lj_asm_x86.h       as->mrm.ofs += 4;
ofs              1443 lj_asm_x86.h     int32_t ofs = 8*((int32_t)ir->op1-1) + ((ir->op2 & IRSLOAD_FRAME) ? 4 : 0);
ofs              1454 lj_asm_x86.h       emit_rmro(as, XMM_MOVRM(as), left, base, ofs);
ofs              1461 lj_asm_x86.h         emit_rmro(as, XO_MOV, dest|REX_64, base, ofs);
ofs              1472 lj_asm_x86.h         emit_rmro(as, irt_isint(t) ? XO_CVTSI2SD : XO_CVTSD2SI, dest, base, ofs);
ofs              1474 lj_asm_x86.h         emit_rmro(as, XMM_MOVRM(as), dest, base, ofs);
ofs              1476 lj_asm_x86.h         emit_rmro(as, XO_MOV, dest, base, ofs);
ofs              1489 lj_asm_x86.h         emit_rmro(as, XO_ARITHi, XOg_CMP, base, ofs+4);
ofs              1492 lj_asm_x86.h         emit_rmro(as, XO_ARITHi8, XOg_CMP, base, ofs+4);
ofs              1536 lj_asm_x86.h       int32_t ofs = sizeof(GCcdata);
ofs              1538 lj_asm_x86.h         ofs += 4; ir++;
ofs              1543 lj_asm_x86.h   	emit_movmroi(as, RID_RET, ofs, IR(ir->op2)->i);
ofs              1546 lj_asm_x86.h   	emit_movtomro(as, r, RID_RET, ofs);
ofs              1549 lj_asm_x86.h         if (ofs == sizeof(GCcdata)) break;
ofs              1550 lj_asm_x86.h         ofs -= 4; ir--;
ofs              1703 lj_asm_x86.h       int32_t ofs = sps_scale(ir->s);  /* Use spill slot or temp slots. */
ofs              1708 lj_asm_x86.h         emit_rmro(as, XMM_MOVRM(as), dest, RID_ESP, ofs);
ofs              1710 lj_asm_x86.h       emit_rmro(as, XO_FSTPq, XOg_FSTPq, RID_ESP, ofs);
ofs              1904 lj_asm_x86.h     as->mrm.ofs = 0;
ofs              1916 lj_asm_x86.h   	as->mrm.ofs = irr->i;
ofs              1927 lj_asm_x86.h         as->mrm.ofs = IR(irr->op2)->i;
ofs              1937 lj_asm_x86.h         as->mrm.ofs = irr->i;
ofs              1940 lj_asm_x86.h         as->mrm.ofs = IR(irl->op2)->i;
ofs              2382 lj_asm_x86.h       int32_t ofs = 8*((int32_t)s-1);
ofs              2389 lj_asm_x86.h         emit_rmro(as, XO_MOVSDto, src, RID_BASE, ofs);
ofs              2395 lj_asm_x86.h   	emit_movtomro(as, REX_64IR(ir, src), RID_BASE, ofs);
ofs              2397 lj_asm_x86.h   	emit_movmroi(as, RID_BASE, ofs, ir->i);
ofs              2401 lj_asm_x86.h   	  emit_movmroi(as, RID_BASE, ofs+4, (int32_t)(*flinks--));
ofs              2404 lj_asm_x86.h   	  emit_movmroi(as, RID_BASE, ofs+4, irt_toitype(ir->t));
ofs                43 lj_bc.h          ((uint8_t *)(p))[LJ_ENDIAN_SELECT(ofs, 3-ofs)] = (uint8_t)(x)
ofs                68 lj_carith.c    	CTSize ofs;
ofs                69 lj_carith.c    	CType *cct = lj_ctype_getfield(cts, ct, strV(o), &ofs);
ofs               495 lj_ccall.c           ccall_classify_ct(cts, cct, rcl, ofs+eofs);
ofs               497 lj_ccall.c         ccall_classify_struct(cts, ct, rcl, ofs);
ofs               501 lj_ccall.c         if ((ofs & (ct->size-1))) cl = CCALL_RCL_MEM;  /* Unaligned. */
ofs               502 lj_ccall.c         rcl[(ofs >= 8)] |= cl;
ofs               513 lj_ccall.c         fofs = ofs+ct->size;
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                58 lj_ccallback.c #define CALLBACK_OFS2SLOT(ofs)		(((ofs)-CALLBACK_MCODE_HEAD)/8)
ofs                65 lj_ccallback.c #define CALLBACK_OFS2SLOT(ofs)		(((ofs)-CALLBACK_MCODE_HEAD)/8)
ofs                72 lj_ccallback.c #define CALLBACK_OFS2SLOT(ofs)		(((ofs)-CALLBACK_MCODE_HEAD)/8)
ofs                79 lj_ccallback.c #define CALLBACK_OFS2SLOT(ofs)	(0*(ofs))
ofs                93 lj_ccallback.c   uintptr_t ofs = (uintptr_t)((uint8_t *)p -(uint8_t *)cts->cb.mcode);
ofs                94 lj_ccallback.c   if (ofs < CALLBACK_MCODE_SIZE) {
ofs                95 lj_ccallback.c     MSize slot = CALLBACK_OFS2SLOT((MSize)ofs);
ofs                96 lj_ccallback.c     if (CALLBACK_SLOT2OFS(slot) == (MSize)ofs)
ofs               465 lj_cconv.c       CTSize size = d->size, esize = dc->size, ofs = 0;
ofs               472 lj_cconv.c         if (ofs >= size)
ofs               474 lj_cconv.c         lj_cconv_ct_tv(cts, dc, dp + ofs, tv, flags);
ofs               475 lj_cconv.c         ofs += esize;
ofs               478 lj_cconv.c         if (ofs == esize) {  /* Replicate a single element. */
ofs               479 lj_cconv.c           for (; ofs < size; ofs += esize) memcpy(dp + ofs, dp, esize);
ofs               481 lj_cconv.c           memset(dp + ofs, 0, size - ofs);
ofs               568 lj_cconv.c           CTSize ofs;
ofs               569 lj_cconv.c           CType *cct = lj_ctype_getfield(cts, d, str, &ofs);
ofs               671 lj_cconv.c       CTSize ofs, esize = dc->size;
ofs               675 lj_cconv.c       for (i = 0, ofs = 0; i < len; i++, ofs += esize)
ofs               676 lj_cconv.c         lj_cconv_ct_tv(cts, dc, dp + ofs, o + i, 0);
ofs               677 lj_cconv.c       if (ofs == esize) {  /* Replicate a single element. */
ofs               678 lj_cconv.c         for (; ofs < sz; ofs += esize) memcpy(dp + ofs, dp, esize);
ofs               680 lj_cconv.c         memset(dp + ofs, 0, sz - ofs);
ofs               153 lj_cdata.c           CTSize ofs;
ofs               154 lj_cdata.c           CType *fct = lj_ctype_getfieldq(cts, ct, name, &ofs, qual);
ofs               156 lj_cdata.c     	*pp = p + ofs;
ofs               176 lj_cdata.c     	CTSize ofs;
ofs               177 lj_cdata.c     	CType *fct = lj_ctype_getfield(cts, sct, name, &ofs);
ofs               550 lj_cparse.c          CTSize ofs;
ofs               561 lj_cparse.c    	  !(fct = lj_ctype_getfield(cp->cts, ct, cp->str, &ofs)) ||
ofs               140 lj_crecord.c     CTSize ofs;		/* Offset in bytes. */
ofs               162 lj_crecord.c         ml[mlp].ofs = df->size;
ofs               167 lj_crecord.c   	ml[mlp].ofs = df->size + (cct->size >> 1);
ofs               183 lj_crecord.c     CTSize ofs = 0;
ofs               187 lj_crecord.c       while (ofs + step <= len) {
ofs               189 lj_crecord.c         ml[mlp].ofs = ofs;
ofs               192 lj_crecord.c         ofs += step;
ofs               196 lj_crecord.c     } while (ofs < len);
ofs               209 lj_crecord.c       TRef trofs = lj_ir_kintp(J, ml[i].ofs);
ofs               277 lj_crecord.c     CTSize ofs = 0;
ofs               281 lj_crecord.c       while (ofs + step <= len) {
ofs               283 lj_crecord.c         ml[mlp].ofs = ofs;
ofs               286 lj_crecord.c         ofs += step;
ofs               290 lj_crecord.c     } while (ofs < len);
ofs               303 lj_crecord.c       TRef trofs = lj_ir_kintp(J, ml[i].ofs);
ofs               626 lj_crecord.c         CTSize ofs;
ofs               627 lj_crecord.c         CType *cct = lj_ctype_getfield(cts, d, str, &ofs);
ofs               632 lj_crecord.c   	svisnz = (void *)(intptr_t)(ofs != 0);
ofs               633 lj_crecord.c   	sp = lj_ir_kint(J, (int32_t)ofs);
ofs               733 lj_crecord.c     ptrdiff_t ofs = sizeof(GCcdata);
ofs               744 lj_crecord.c       ofs = 0;
ofs               745 lj_crecord.c       ptr = crec_reassoc_ofs(J, ptr, &ofs, 1);
ofs               758 lj_crecord.c         idx = crec_reassoc_ofs(J, idx, &ofs, sz);
ofs               761 lj_crecord.c         if (LJ_LIKELY(J->flags & JIT_F_OPT_LOOP) && ofs
ofs               766 lj_crecord.c   	ptr = emitir(IRT(IR_ADD, IRT_PTR), ptr, lj_ir_kintp(J, ofs));
ofs               767 lj_crecord.c   	ofs = 0;
ofs               820 lj_crecord.c   	ofs += (ptrdiff_t)fofs;
ofs               828 lj_crecord.c   	if (strdata(name)[0] == 'i') ofs += (ct->size >> 1);
ofs               846 lj_crecord.c     if (ofs)
ofs               847 lj_crecord.c       ptr = emitir(IRT(IR_ADD, IRT_PTR), ptr, lj_ir_kintp(J, ofs));
ofs               915 lj_crecord.c         CTSize ofs, esize = dc->size;
ofs               923 lj_crecord.c         for (i = 1, ofs = 0; ofs < sz; ofs += esize) {
ofs               925 lj_crecord.c   			 lj_ir_kintp(J, ofs + sizeof(GCcdata)));
ofs              1421 lj_crecord.c   	CTSize ofs;
ofs              1422 lj_crecord.c   	CType *cct = lj_ctype_getfield(cts, ct, str, &ofs);
ofs              1427 lj_crecord.c   	  tr = lj_ir_kint(J, (int32_t)ofs);
ofs               243 lj_ctype.c           *ofs = ct->size;
ofs               253 lj_ctype.c           fct = lj_ctype_getfieldq(cts, cct, name, ofs, qual);
ofs               256 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               318 lj_emit_arm.h      emit_vlso(as, irt_isnum(ir->t) ? ARMI_VLDR_D : ARMI_VLDR_S, r, RID_SP, ofs);
ofs               321 lj_emit_arm.h      emit_lso(as, ARMI_LDR, r, RID_SP, ofs);
ofs               331 lj_emit_arm.h      emit_vlso(as, irt_isnum(ir->t) ? ARMI_VSTR_D : ARMI_VSTR_S, r, RID_SP, ofs);
ofs               334 lj_emit_arm.h      emit_lso(as, ARMI_STR, r, RID_SP, ofs);
ofs               351 lj_emit_arm.h    if (ofs)
ofs               352 lj_emit_arm.h      emit_opk(as, ARMI_ADD, r, r, ofs, rset_exclude(RSET_GPR, r));
ofs               355 lj_emit_arm.h  #define emit_spsub(as, ofs)	emit_addptr(as, RID_SP, -(ofs))
ofs               121 lj_emit_mips.h   emit_tsi(as, mi, r, RID_JGL, ofs-32768);
ofs               185 lj_emit_mips.h     emit_tsi(as, MIPSI_LW, r, RID_SP, ofs);
ofs               188 lj_emit_mips.h 	     (r & 31), RID_SP, ofs);
ofs               195 lj_emit_mips.h     emit_tsi(as, MIPSI_SW, r, RID_SP, ofs);
ofs               198 lj_emit_mips.h 	     (r&31), RID_SP, ofs);
ofs               204 lj_emit_mips.h   if (ofs) {
ofs               205 lj_emit_mips.h     lua_assert(checki16(ofs));
ofs               206 lj_emit_mips.h     emit_tsi(as, MIPSI_ADDIU, r, r, ofs);
ofs               210 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, RID_SP, ofs);
ofs               195 lj_emit_ppc.h      emit_fai(as, irt_isnum(ir->t) ? PPCI_LFD : PPCI_LFS, r, RID_SP, ofs);
ofs               202 lj_emit_ppc.h      emit_tai(as, PPCI_STW, r, RID_SP, ofs);
ofs               204 lj_emit_ppc.h      emit_fai(as, irt_isnum(ir->t) ? PPCI_STFD : PPCI_STFS, r, RID_SP, 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               107 lj_emit_x86.h      if (ofs == 0 && (rb&7) != RID_EBP) {
ofs               109 lj_emit_x86.h      } else if (checki8(ofs)) {
ofs               110 lj_emit_x86.h        *--p = (MCode)ofs;
ofs               114 lj_emit_x86.h        *(int32_t *)p = ofs;
ofs               120 lj_emit_x86.h      *(int32_t *)(p-4) = ofs;
ofs               140 lj_emit_x86.h    if (ofs == 0 && (rb&7) != RID_EBP) {
ofs               142 lj_emit_x86.h    } else if (checki8(ofs)) {
ofs               144 lj_emit_x86.h      *--p = (MCode)ofs;
ofs               148 lj_emit_x86.h      *(int32_t *)p = ofs;
ofs               181 lj_emit_x86.h    emit_rmro(as, xo, (Reg)(xg & 7), rb, ofs);
ofs               198 lj_emit_x86.h        *(int32_t *)p = as->mrm.ofs;
ofs               206 lj_emit_x86.h        if (as->mrm.ofs == 0 && (rb&7) != RID_EBP) {
ofs               208 lj_emit_x86.h        } else if (checki8(as->mrm.ofs)) {
ofs               209 lj_emit_x86.h  	*--p = (MCode)as->mrm.ofs;
ofs               213 lj_emit_x86.h  	*(int32_t *)p = as->mrm.ofs;
ofs               252 lj_emit_x86.h    emit_rmro(as, XO_MOVmi, 0, base, ofs);
ofs               257 lj_emit_x86.h    emit_rmro(as, XO_MOVto, (r), (base), (ofs))
ofs               437 lj_emit_x86.h      emit_rmro(as, XO_MOV, REX_64IR(ir, r), RID_ESP, ofs);
ofs               439 lj_emit_x86.h      emit_rmro(as, irt_isnum(ir->t) ? XMM_MOVRM(as) : XO_MOVSS, r, RID_ESP, ofs);
ofs               446 lj_emit_x86.h      emit_rmro(as, XO_MOVto, REX_64IR(ir, r), RID_ESP, ofs);
ofs               448 lj_emit_x86.h      emit_rmro(as, irt_isnum(ir->t) ? XO_MOVSDto : XO_MOVSSto, r, RID_ESP, ofs);
ofs               454 lj_emit_x86.h    if (ofs) {
ofs               456 lj_emit_x86.h        emit_rmro(as, XO_LEA, r, r, ofs);
ofs               458 lj_emit_x86.h        emit_gri(as, XG_ARITHi(XOg_ADD), r, ofs);
ofs               462 lj_emit_x86.h  #define emit_spsub(as, ofs)	emit_addptr(as, RID_ESP|REX_64, -(ofs))
ofs               184 lj_gdbjit.c      uintptr_t ofs;
ofs               416 lj_gdbjit.c      uint32_t ofs = (uint32_t)(p - ctx->startp);
ofs               421 lj_gdbjit.c      return ofs;
ofs               481 lj_gdbjit.c      sect->ofs = 0;
ofs               491 lj_gdbjit.c      sect->ofs = offsetof(GDBJITobj, sym);
ofs               697 lj_gdbjit.c      ctx->obj.sect[sect].ofs = (uintptr_t)((char *)ctx->p - (char *)&ctx->obj);
ofs                95 lj_ir.c            MSize ofs = szins >> 2;
ofs                96 lj_ir.c            memmove(baseir + ofs, baseir, (J->cur.nins - J->irbotlim)*sizeof(IRIns));
ofs                97 lj_ir.c            J->irbotlim -= ofs;
ofs                98 lj_ir.c            J->irtoplim -= ofs;
ofs               103 lj_ir.c            MSize ofs = szins >= 256 ? 128 : (szins >> 1);  /* Limit bottom growth. */
ofs               104 lj_ir.c            memcpy(newbase + ofs, baseir, (J->cur.nins - J->irbotlim)*sizeof(IRIns));
ofs               106 lj_ir.c            J->irbotlim -= ofs;
ofs               539 lj_opt_fold.c    ptrdiff_t ofs = (ptrdiff_t)ir_kint64(fright)->u64;
ofs               541 lj_opt_fold.c    ptrdiff_t ofs = fright->i;
ofs               549 lj_opt_fold.c        return lj_ir_kkptr(J, (char *)o + ofs);
ofs               552 lj_opt_fold.c    return lj_ir_kptr(J, (char *)o + ofs);
ofs               563 lj_opt_fold.c    ptrdiff_t ofs = (ptrdiff_t)ir_kint64(fright)->u64;
ofs               565 lj_opt_fold.c    ptrdiff_t ofs = fright->i;
ofs               567 lj_opt_fold.c    return lj_ir_kptr_(J, fleft->o, (char *)p + ofs);
ofs              1041 lj_opt_fold.c    int64_t ofs = 0;
ofs              1048 lj_opt_fold.c      ofs = (int64_t)IR(fleft->op2)->i;
ofs              1055 lj_opt_fold.c      if (lo && IR(lo)->o == IR_KINT && IR(lo)->i + ofs >= 0) {
ofs               674 lj_opt_mem.c     ptrdiff_t ofs = 0;
ofs               677 lj_opt_mem.c       ofs = (LJ_64 && irk->o == IR_KINT64) ? (ptrdiff_t)ir_k64(irk)->u64 :
ofs               696 lj_opt_mem.c         ofs += (ptrdiff_t)IR(ir2->op2)->i << shift;
ofs               707 lj_opt_mem.c       if (ofs != 0) {
ofs               708 lj_opt_mem.c         IRRef refk = tref_ref(lj_ir_kintp(J, ofs));
ofs               186 lj_opt_split.c   int32_t ofs = 4;
ofs               188 lj_opt_split.c     return lj_ir_kptr(J, (char *)ir_kptr(ir) + ofs);
ofs               191 lj_opt_split.c     ofs += IR(ir->op2)->i;
ofs               193 lj_opt_split.c     if (ofs == 0) return nref;
ofs               195 lj_opt_split.c   return split_emit(J, IRTI(IR_ADD), nref, lj_ir_kint(J, ofs));
ofs              1052 lj_record.c        int32_t ofs = 0;
ofs              1057 lj_record.c          ofs = IR(ofsref)->i;
ofs              1067 lj_record.c          if ((uint64_t)stop + ofs < (uint64_t)asize) {
ofs              1069 lj_record.c    	emitir(IRTG(IR_ABC, IRT_P32), asizeref, ofs == 0 ? J->scev.stop :
ofs              1073 lj_record.c    	      (int64_t)IR(J->scev.start)->i + ofs >= 0))
ofs               170 lj_target_x86.h   int32_t ofs;		/* Offset. */
ofs               114 lj_vm.h        #define makeasmfunc(ofs)	((ASMFunction)(lj_vm_asm_begin + (ofs)))