Consistently use 64 bit constants for 64 bit IR instructions.

Thanks to Peter Cawley. #1084

4 files changed, 24 insertions, 17 deletions

diff --git a/src/lj_asm_x86.h b/src/lj_asm_x86.h
index 9f779bf5..c92de3d8 100644
--- a/src/lj_asm_x86.h
+++ b/src/lj_asm_x86.h
@@ -140,7 +140,8 @@ static IRRef asm_fuseabase(ASMState *as, IRRef ref)
     }
   } else if (irb->o == IR_ADD && irref_isk(irb->op2)) {
     /* Fuse base offset (vararg load). */
-    as->mrm.ofs = IR(irb->op2)->i;
+    IRIns *irk = IR(irb->op2);
+    as->mrm.ofs = irk->o == IR_KINT ? irk->i : (int32_t)ir_kint64(irk)->u64;
     return irb->op1;
   }
   return ref;  /* Otherwise use the given array base. */
diff --git a/src/lj_ffrecord.c b/src/lj_ffrecord.c
index 8ebf4165..1233e5f7 100644
--- a/src/lj_ffrecord.c
+++ b/src/lj_ffrecord.c
@@ -1130,7 +1130,7 @@ static TRef recff_sbufx_check(jit_State *J, RecordFFData *rd, ptrdiff_t arg)
 /* Emit BUFHDR for write to extended string buffer. */
 static TRef recff_sbufx_write(jit_State *J, TRef ud)
 {
-  TRef trbuf = emitir(IRT(IR_ADD, IRT_PGC), ud, lj_ir_kint(J, sizeof(GCudata)));
+  TRef trbuf = emitir(IRT(IR_ADD, IRT_PGC), ud, lj_ir_kintpgc(J, sizeof(GCudata)));
   return emitir(IRT(IR_BUFHDR, IRT_PGC), trbuf, IRBUFHDR_WRITE);
 }
 
@@ -1164,20 +1164,19 @@ static void LJ_FASTCALL recff_buffer_method_reset(jit_State *J, RecordFFData *rd
   SBufExt *sbx = bufV(&rd->argv[0]);
   int iscow = (int)sbufiscow(sbx);
   TRef trl = recff_sbufx_get_L(J, ud);
-  TRef trcow = emitir(IRT(IR_BAND, IRT_IGC), trl, lj_ir_kint(J, SBUF_FLAG_COW));
-  TRef zero = lj_ir_kint(J, 0);
-  emitir(IRTG(iscow ? IR_NE : IR_EQ, IRT_IGC), trcow, zero);
+  TRef trcow = emitir(IRT(IR_BAND, IRT_IGC), trl, lj_ir_kintpgc(J, SBUF_FLAG_COW));
+  TRef zeropgc = lj_ir_kintpgc(J, 0);
+  emitir(IRTG(iscow ? IR_NE : IR_EQ, IRT_IGC), trcow, zeropgc);
   if (iscow) {
-    trl = emitir(IRT(IR_BXOR, IRT_IGC), trl,
-                 LJ_GC64 ? lj_ir_kint64(J, SBUF_FLAG_COW) :
-                           lj_ir_kint(J, SBUF_FLAG_COW));
-    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_W, zero);
-    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_E, zero);
-    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_B, zero);
+    TRef zerop = lj_ir_kintp(J, 0);
+    trl = emitir(IRT(IR_BXOR, IRT_IGC), trl, lj_ir_kintpgc(J, SBUF_FLAG_COW));
+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_W, zerop);
+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_E, zerop);
+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_B, zerop);
     recff_sbufx_set_L(J, ud, trl);
     emitir(IRT(IR_FSTORE, IRT_PGC),
-           emitir(IRT(IR_FREF, IRT_PGC), ud, IRFL_SBUF_REF), zero);
-    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_R, zero);
+           emitir(IRT(IR_FREF, IRT_PGC), ud, IRFL_SBUF_REF), zeropgc);
+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_R, zerop);
   } else {
     TRef trb = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_B);
     recff_sbufx_set_ptr(J, ud, IRFL_SBUF_W, trb);
diff --git a/src/lj_iropt.h b/src/lj_iropt.h
index 458a5511..a71a717b 100644
--- a/src/lj_iropt.h
+++ b/src/lj_iropt.h
@@ -56,6 +56,12 @@ LJ_FUNC TRef lj_ir_ktrace(jit_State *J);
 #define lj_ir_kintp(J, k)       lj_ir_kint(J, (int32_t)(k))
 #endif
 
+#if LJ_GC64
+#define lj_ir_kintpgc           lj_ir_kintp
+#else
+#define lj_ir_kintpgc           lj_ir_kint
+#endif
+
 static LJ_AINLINE TRef lj_ir_knum(jit_State *J, lua_Number n)
 {
   TValue tv;
diff --git a/src/lj_record.c b/src/lj_record.c
index 7a970628..d44f7737 100644
--- a/src/lj_record.c
+++ b/src/lj_record.c
@@ -1781,7 +1781,7 @@ noconstify:
         emitir(IRTG(IR_EQ, IRT_PGC),
                REF_BASE,
                emitir(IRT(IR_ADD, IRT_PGC), uref,
-                      lj_ir_kint(J, (slot - 1 - LJ_FR2) * -8)));
+                      lj_ir_kintpgc(J, (slot - 1 - LJ_FR2) * -8)));
         slot -= (int32_t)J->baseslot;  /* Note: slot number may be negative! */
         if (val == 0) {
           return getslot(J, slot);
@@ -1794,7 +1794,7 @@ noconstify:
     }
     emitir(IRTG(IR_UGT, IRT_PGC),
            emitir(IRT(IR_SUB, IRT_PGC), uref, REF_BASE),
-           lj_ir_kint(J, (J->baseslot + J->maxslot) * 8));
+           lj_ir_kintpgc(J, (J->baseslot + J->maxslot) * 8));
   } else {
     needbarrier = 1;
     uref = tref_ref(emitir(IRTG(IR_UREFC, IRT_PGC), fn, uv));
@@ -1972,7 +1972,8 @@ static void rec_varg(jit_State *J, BCReg dst, ptrdiff_t nresults)
           emitir(IRTGI(IR_EQ), fr,
                  lj_ir_kint(J, (int32_t)frame_ftsz(J->L->base-1)));
         vbase = emitir(IRT(IR_SUB, IRT_IGC), REF_BASE, fr);
-        vbase = emitir(IRT(IR_ADD, IRT_PGC), vbase, lj_ir_kint(J, frofs-8*(1+LJ_FR2)));
+        vbase = emitir(IRT(IR_ADD, IRT_PGC), vbase,
+                       lj_ir_kintpgc(J, frofs-8*(1+LJ_FR2)));
         for (i = 0; i < nload; i++) {
           IRType t = itype2irt(&J->L->base[i-1-LJ_FR2-nvararg]);
           J->base[dst+i] = lj_record_vload(J, vbase, (MSize)i, t);
@@ -2023,7 +2024,7 @@ static void rec_varg(jit_State *J, BCReg dst, ptrdiff_t nresults)
         IRType t;
         TRef aref, vbase = emitir(IRT(IR_SUB, IRT_IGC), REF_BASE, fr);
         vbase = emitir(IRT(IR_ADD, IRT_PGC), vbase,
-                       lj_ir_kint(J, frofs-(8<<LJ_FR2)));
+                       lj_ir_kintpgc(J, frofs-(8<<LJ_FR2)));
         t = itype2irt(&J->L->base[idx-2-LJ_FR2-nvararg]);
         aref = emitir(IRT(IR_AREF, IRT_PGC), vbase, tridx);
         tr = lj_record_vload(J, aref, 0, t);