Consistently use 64 bit constants for 64 bit IR instructions.

Thanks to Peter Cawley. #1084

diff --git a/src/lj_asm_x86.h b/src/lj_asm_x86.h
index 9f779bf57ac3b2136faecb6fc56e54518e110e53..c92de3d8128a1d2f898ff014a19d0a87dc8c2389 100644 (file)
--- 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 8ebf41654b4b0c9d50a34ca0fdbe388d1acf97f7..1233e5f74e85d1b4f4e7bdde729ecfe92efcad3b 100644 (file)
--- 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 458a5511800b9964c3d7e8521698740ce5d3db2e..a71a717b925c878d9b5ecf3aded67c650c82252e 100644 (file)
--- 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 7a97062835b7e1abb97477906ae4495e04825648..d44f7737a7d8d7149f4267c7d77804141c3a5a2a 100644 (file)
--- 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);