ARM/PPC/MIPS: Fix tailcall from fast function (esp. tostring).

6 files changed, 1041 insertions, 1029 deletions

diff --git a/src/buildvm_arm.dasc b/src/buildvm_arm.dasc
index 3b1b8d7f..6f0e3878 100644
--- a/src/buildvm_arm.dasc
+++ b/src/buildvm_arm.dasc
@@ -1809,6 +1809,7 @@ static void build_subroutines(BuildCtx *ctx)
   |   bic CARG2, PC, #FRAME_TYPEP
   |  ldreq INS, [PC, #-4]
   |  andeq CARG2, MASKR8, INS, lsr #5   // Conditional decode_RA8.
+  |  addeq CARG2, CARG2, #8
   |  sub RB, BASE, CARG2
   |  b ->vm_call_dispatch               // Resolve again for tailcall.
   |
diff --git a/src/buildvm_arm.h b/src/buildvm_arm.h
index ca94ed18..aec421dd 100644
--- a/src/buildvm_arm.h
+++ b/src/buildvm_arm.h
@@ -12,7 +12,7 @@
 #define DASM_SECTION_CODE_OP    0
 #define DASM_SECTION_CODE_SUB   1
 #define DASM_MAXSECTION         2
-static const unsigned int build_actionlist[5777] = {
+static const unsigned int build_actionlist[5784] = {
 0x00010001,
 0x00060014,
 0xe3160000,
@@ -1421,6 +1421,8 @@ static const unsigned int build_actionlist[5777] = {
 0xea000000,
 0x00050049,
 0x0006000c,
+0x2a000000,
+0x00050049,
 0xe1822000,
 0xe1120fc1,
 0x03a00000,
@@ -1484,6 +1486,8 @@ static const unsigned int build_actionlist[5777] = {
 0xea000000,
 0x00050049,
 0x0006000c,
+0x2a000000,
+0x00050049,
 0xe1822000,
 0xe1d22fc1,
 0x03a00000,
@@ -1501,9 +1505,9 @@ static const unsigned int build_actionlist[5777] = {
 0x4a000000,
 0x0005000b,
 0x0006000e,
+0x00000000,
 0xeb000000,
 0x0005005c,
-0x00000000,
 0xea000000,
 0x00050049,
 0x00040007,
@@ -1563,11 +1567,11 @@ static const unsigned int build_actionlist[5777] = {
 0xea000000,
 0x0005000f,
 0x0006005f,
+0x00000000,
 0xe1c900d0,
 0xe35b0008,
 0x3a000000,
 0x00050046,
-0x00000000,
 0xe3710000,
 0x000a0000,
 0x2a000000,
@@ -2711,6 +2715,7 @@ static const unsigned int build_actionlist[5777] = {
 0x0516e004,
 0x00020000,
 0x000412ae,
+0x02811008,
 0xe049c001,
 0xea000000,
 0x00050024,
@@ -2995,6 +3000,7 @@ static const unsigned int build_actionlist[5777] = {
 0xe0c11002,
 0xe12fff1e,
 0x0006000c,
+0x212fff1e,
 0xe1822000,
 0xe1120fc1,
 0xe3a00000,
@@ -3030,6 +3036,7 @@ static const unsigned int build_actionlist[5777] = {
 0xe0c11002,
 0xe12fff1e,
 0x0006000c,
+0x212fff1e,
 0xe1822000,
 0xe1d22fc1,
 0xe3a00000,
@@ -6299,235 +6306,235 @@ static void build_subroutines(BuildCtx *ctx)
   dasm_put(Dst, 1246, Dt8(->upvalue[0].gcr), Dt1(->base), Dt1(->top), Dt1(->status), Dt1(->base), Dt1(->maxstack), Dt1(->cframe), LUA_YIELD, Dt1(->top), Dt1(->top), Dt1(->base), LJ_VMST_INTERP, Dt1(->top), DISPATCH_GL(vmstate), LUA_YIELD);
   dasm_put(Dst, 1302, Dt1(->base), Dt1(->maxstack), Dt1(->top), FRAME_TYPE, Dt1(->cframe), Dt1(->base), CFRAME_RESUME, Dt1(->top));
   dasm_put(Dst, 1361, LUA_YIELD, Dt1(->cframe), Dt1(->status), -LJ_TISNUM, ~LJ_TISNUM, ~LJ_TISNUM);
-  dasm_put(Dst, 1427, -LJ_TISNUM, ~LJ_TISNUM, ~LJ_TISNUM);
-  dasm_put(Dst, 1491, -LJ_TISNUM, (1+1)*8, FRAME_TYPE, ~LJ_TNIL);
+  dasm_put(Dst, 1429, -LJ_TISNUM, ~LJ_TISNUM, ~LJ_TISNUM);
+  dasm_put(Dst, 1493, -LJ_TISNUM, (1+1)*8, FRAME_TYPE, ~LJ_TNIL);
   dasm_put(Dst, 1555, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1560);
+  dasm_put(Dst, 1564);
   }
-  dasm_put(Dst, 1562);
+  dasm_put(Dst, 1566);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1565);
+  dasm_put(Dst, 1569);
   }
-  dasm_put(Dst, 1567, -LJ_TISNUM);
+  dasm_put(Dst, 1571, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1579);
+  dasm_put(Dst, 1583);
   }
-  dasm_put(Dst, 1581);
+  dasm_put(Dst, 1585);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1584);
+  dasm_put(Dst, 1588);
   }
-  dasm_put(Dst, 1586, -LJ_TISNUM);
+  dasm_put(Dst, 1590, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1598);
+  dasm_put(Dst, 1602);
   }
-  dasm_put(Dst, 1600);
+  dasm_put(Dst, 1604);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1603);
+  dasm_put(Dst, 1607);
   }
-  dasm_put(Dst, 1605, -LJ_TISNUM);
+  dasm_put(Dst, 1609, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1617);
+  dasm_put(Dst, 1621);
   }
-  dasm_put(Dst, 1619);
+  dasm_put(Dst, 1623);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1622);
+  dasm_put(Dst, 1626);
   }
-  dasm_put(Dst, 1624, -LJ_TISNUM);
+  dasm_put(Dst, 1628, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1636);
+  dasm_put(Dst, 1640);
   }
-  dasm_put(Dst, 1638);
+  dasm_put(Dst, 1642);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1641);
+  dasm_put(Dst, 1645);
   }
-  dasm_put(Dst, 1643, -LJ_TISNUM);
+  dasm_put(Dst, 1647, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1655);
+  dasm_put(Dst, 1659);
   }
-  dasm_put(Dst, 1657);
+  dasm_put(Dst, 1661);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1660);
+  dasm_put(Dst, 1664);
   }
-  dasm_put(Dst, 1662, -LJ_TISNUM);
+  dasm_put(Dst, 1666, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1674);
+  dasm_put(Dst, 1678);
   }
-  dasm_put(Dst, 1676);
+  dasm_put(Dst, 1680);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1679);
+  dasm_put(Dst, 1683);
   }
-  dasm_put(Dst, 1681, -LJ_TISNUM);
+  dasm_put(Dst, 1685, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1693);
+  dasm_put(Dst, 1697);
   }
-  dasm_put(Dst, 1695);
+  dasm_put(Dst, 1699);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1698);
+  dasm_put(Dst, 1702);
   }
-  dasm_put(Dst, 1700, -LJ_TISNUM);
+  dasm_put(Dst, 1704, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1712);
+  dasm_put(Dst, 1716);
   }
-  dasm_put(Dst, 1714);
+  dasm_put(Dst, 1718);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1717);
+  dasm_put(Dst, 1721);
   }
-  dasm_put(Dst, 1719, -LJ_TISNUM);
+  dasm_put(Dst, 1723, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1731);
+  dasm_put(Dst, 1735);
   }
-  dasm_put(Dst, 1733);
+  dasm_put(Dst, 1737);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1736);
+  dasm_put(Dst, 1740);
   }
-  dasm_put(Dst, 1738, -LJ_TISNUM);
+  dasm_put(Dst, 1742, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1750);
+  dasm_put(Dst, 1754);
   }
-  dasm_put(Dst, 1752);
+  dasm_put(Dst, 1756);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1755);
+  dasm_put(Dst, 1759);
   }
-  dasm_put(Dst, 1757, -LJ_TISNUM);
+  dasm_put(Dst, 1761, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1769);
+  dasm_put(Dst, 1773);
   }
-  dasm_put(Dst, 1771);
+  dasm_put(Dst, 1775);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1774);
+  dasm_put(Dst, 1778);
   }
-  dasm_put(Dst, 1776, -LJ_TISNUM);
+  dasm_put(Dst, 1780, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1788);
+  dasm_put(Dst, 1792);
   }
-  dasm_put(Dst, 1790);
+  dasm_put(Dst, 1794);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1793);
+  dasm_put(Dst, 1797);
   }
-  dasm_put(Dst, 1795, -LJ_TISNUM, -LJ_TISNUM);
+  dasm_put(Dst, 1799, -LJ_TISNUM, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1810);
+  dasm_put(Dst, 1814);
   }
-  dasm_put(Dst, 1812);
+  dasm_put(Dst, 1816);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1815);
+  dasm_put(Dst, 1819);
   }
-  dasm_put(Dst, 1817, -LJ_TISNUM, -LJ_TISNUM);
+  dasm_put(Dst, 1821, -LJ_TISNUM, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1832);
+  dasm_put(Dst, 1836);
   }
-  dasm_put(Dst, 1834);
+  dasm_put(Dst, 1838);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1837);
+  dasm_put(Dst, 1841);
   }
-  dasm_put(Dst, 1839, -LJ_TISNUM, -LJ_TISNUM);
+  dasm_put(Dst, 1843, -LJ_TISNUM, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1854);
+  dasm_put(Dst, 1858);
   }
-  dasm_put(Dst, 1856);
+  dasm_put(Dst, 1860);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1859);
+  dasm_put(Dst, 1863);
   }
-  dasm_put(Dst, 1861, -LJ_TISNUM, Dt8(->upvalue[0]), -LJ_TISNUM, -LJ_TISNUM);
+  dasm_put(Dst, 1865, -LJ_TISNUM, Dt8(->upvalue[0]), -LJ_TISNUM, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1894);
+  dasm_put(Dst, 1898);
   }
-  dasm_put(Dst, 1896);
+  dasm_put(Dst, 1900);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1899);
+  dasm_put(Dst, 1903);
   }
-  dasm_put(Dst, 1901, -LJ_TISNUM);
+  dasm_put(Dst, 1905, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1914);
+  dasm_put(Dst, 1918);
   }
-  dasm_put(Dst, 1916);
+  dasm_put(Dst, 1920);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1919);
+  dasm_put(Dst, 1923);
   }
-  dasm_put(Dst, 1921, ~LJ_TISNUM, (2+1)*8, -LJ_TISNUM);
+  dasm_put(Dst, 1925, ~LJ_TISNUM, (2+1)*8, -LJ_TISNUM);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1943);
+  dasm_put(Dst, 1947);
   }
-  dasm_put(Dst, 1945);
+  dasm_put(Dst, 1949);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 1948);
+  dasm_put(Dst, 1952);
   }
-  dasm_put(Dst, 1950, (2+1)*8, -LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM);
-  dasm_put(Dst, 2001, -LJ_TISNUM, -LJ_TISNUM);
-  dasm_put(Dst, 2055, -LJ_TISNUM, -LJ_TSTR, Dt5(->len), ~LJ_TISNUM, -LJ_TSTR, Dt5(->len), Dt5([1]));
-  dasm_put(Dst, 2109, ~LJ_TISNUM, (0+1)*8, (1+1)*8, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), -LJ_TISNUM, Dt1(->base), Dt1(->base), ~LJ_TSTR, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold));
-  dasm_put(Dst, 2168, -LJ_TISNUM, -LJ_TSTR, Dt5(->len), -LJ_TISNUM, sizeof(GCstr)-1, -DISPATCH_GL(strempty), ~LJ_TSTR, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), -LJ_TSTR, -LJ_TISNUM, Dt5(->len));
-  dasm_put(Dst, 2230, DISPATCH_GL(tmpbuf.sz), DISPATCH_GL(tmpbuf.buf), Dt5([1]), DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), -LJ_TSTR, Dt5(->len), DISPATCH_GL(tmpbuf.sz), DISPATCH_GL(tmpbuf.buf), sizeof(GCstr));
-  dasm_put(Dst, 2283, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), -LJ_TSTR, Dt5(->len), DISPATCH_GL(tmpbuf.sz), DISPATCH_GL(tmpbuf.buf), sizeof(GCstr), DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold));
-  dasm_put(Dst, 2343, -LJ_TSTR, Dt5(->len), DISPATCH_GL(tmpbuf.sz), DISPATCH_GL(tmpbuf.buf), sizeof(GCstr), -LJ_TTAB);
+  dasm_put(Dst, 1954, (2+1)*8, -LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM);
+  dasm_put(Dst, 2005, -LJ_TISNUM, -LJ_TISNUM);
+  dasm_put(Dst, 2059, -LJ_TISNUM, -LJ_TSTR, Dt5(->len), ~LJ_TISNUM, -LJ_TSTR, Dt5(->len), Dt5([1]));
+  dasm_put(Dst, 2113, ~LJ_TISNUM, (0+1)*8, (1+1)*8, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), -LJ_TISNUM, Dt1(->base), Dt1(->base), ~LJ_TSTR, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold));
+  dasm_put(Dst, 2172, -LJ_TISNUM, -LJ_TSTR, Dt5(->len), -LJ_TISNUM, sizeof(GCstr)-1, -DISPATCH_GL(strempty), ~LJ_TSTR, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), -LJ_TSTR, -LJ_TISNUM, Dt5(->len));
+  dasm_put(Dst, 2234, DISPATCH_GL(tmpbuf.sz), DISPATCH_GL(tmpbuf.buf), Dt5([1]), DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), -LJ_TSTR, Dt5(->len), DISPATCH_GL(tmpbuf.sz), DISPATCH_GL(tmpbuf.buf), sizeof(GCstr));
+  dasm_put(Dst, 2287, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), -LJ_TSTR, Dt5(->len), DISPATCH_GL(tmpbuf.sz), DISPATCH_GL(tmpbuf.buf), sizeof(GCstr), DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold));
+  dasm_put(Dst, 2347, -LJ_TSTR, Dt5(->len), DISPATCH_GL(tmpbuf.sz), DISPATCH_GL(tmpbuf.buf), sizeof(GCstr), -LJ_TTAB);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 2381);
+  dasm_put(Dst, 2385);
   }
-  dasm_put(Dst, 2383);
+  dasm_put(Dst, 2387);
   if (LJ_TARGET_OSX) {
-  dasm_put(Dst, 2386);
+  dasm_put(Dst, 2390);
   }
-  dasm_put(Dst, 2388, ~LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM);
-  dasm_put(Dst, 2459, -LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM);
-  dasm_put(Dst, 2519, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM);
-  dasm_put(Dst, 2575, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM);
-  dasm_put(Dst, 2632, -LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM, Dt1(->maxstack), Dt1(->top), Dt8(->f), Dt1(->base), 8*LUA_MINSTACK, Dt1(->base), Dt1(->top), Dt7(->field_pc), FRAME_TYPE, FRAME_TYPEP);
-  dasm_put(Dst, 2695, LUA_MINSTACK, Dt1(->base), Dt1(->base), Dt1(->top), Dt1(->base));
+  dasm_put(Dst, 2392, ~LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM);
+  dasm_put(Dst, 2463, -LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM);
+  dasm_put(Dst, 2523, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM);
+  dasm_put(Dst, 2579, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM);
+  dasm_put(Dst, 2636, -LJ_TISNUM, -LJ_TISNUM, ~LJ_TISNUM, Dt1(->maxstack), Dt1(->top), Dt8(->f), Dt1(->base), 8*LUA_MINSTACK, Dt1(->base), Dt1(->top), Dt7(->field_pc), FRAME_TYPE, FRAME_TYPEP);
+  dasm_put(Dst, 2699, LUA_MINSTACK, Dt1(->base), Dt1(->base), Dt1(->top), Dt1(->base));
 #if LJ_HASJIT
-  dasm_put(Dst, 2729, DISPATCH_GL(hookmask), HOOK_VMEVENT, DISPATCH_GL(hookcount), HOOK_ACTIVE, LUA_MASKLINE|LUA_MASKCOUNT, DISPATCH_GL(hookcount));
+  dasm_put(Dst, 2734, DISPATCH_GL(hookmask), HOOK_VMEVENT, DISPATCH_GL(hookcount), HOOK_ACTIVE, LUA_MASKLINE|LUA_MASKCOUNT, DISPATCH_GL(hookcount));
 #endif
-  dasm_put(Dst, 2749, DISPATCH_GL(hookmask), HOOK_ACTIVE, GG_DISP2STATIC, DISPATCH_GL(hookmask), DISPATCH_GL(hookcount), HOOK_ACTIVE, LUA_MASKLINE|LUA_MASKCOUNT, DISPATCH_GL(hookcount), LUA_MASKLINE, Dt1(->base), Dt1(->base));
-  dasm_put(Dst, 2795, GG_DISP2STATIC);
+  dasm_put(Dst, 2754, DISPATCH_GL(hookmask), HOOK_ACTIVE, GG_DISP2STATIC, DISPATCH_GL(hookmask), DISPATCH_GL(hookcount), HOOK_ACTIVE, LUA_MASKLINE|LUA_MASKCOUNT, DISPATCH_GL(hookcount), LUA_MASKLINE, Dt1(->base), Dt1(->base));
+  dasm_put(Dst, 2800, GG_DISP2STATIC);
 #if LJ_HASJIT
-  dasm_put(Dst, 2811, -GG_DISP2J, Dt7(->field_pc), DISPATCH_J(L), PC2PROTO(framesize), Dt1(->base), Dt1(->top));
+  dasm_put(Dst, 2816, -GG_DISP2J, Dt7(->field_pc), DISPATCH_J(L), PC2PROTO(framesize), Dt1(->base), Dt1(->top));
 #endif
-  dasm_put(Dst, 2832);
+  dasm_put(Dst, 2837);
 #if LJ_HASJIT
-  dasm_put(Dst, 2835);
+  dasm_put(Dst, 2840);
 #endif
-  dasm_put(Dst, 2838);
+  dasm_put(Dst, 2843);
 #if LJ_HASJIT
-  dasm_put(Dst, 2840);
+  dasm_put(Dst, 2845);
 #endif
-  dasm_put(Dst, 2843, Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top));
+  dasm_put(Dst, 2848, Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top));
 #if LJ_HASJIT
-  dasm_put(Dst, 2866, LJ_VMST_EXIT, DISPATCH_GL(vmstate), DISPATCH_GL(jit_L), DISPATCH_GL(jit_base), DISPATCH_J(exitno), DISPATCH_J(L), Dt1(->base), DISPATCH_GL(jit_L), -GG_DISP2J, Dt1(->cframe), Dt1(->base), ~CFRAME_RAWMASK);
+  dasm_put(Dst, 2871, LJ_VMST_EXIT, DISPATCH_GL(vmstate), DISPATCH_GL(jit_L), DISPATCH_GL(jit_base), DISPATCH_J(exitno), DISPATCH_J(L), Dt1(->base), DISPATCH_GL(jit_L), -GG_DISP2J, Dt1(->cframe), Dt1(->base), ~CFRAME_RAWMASK);
 #endif
-  dasm_put(Dst, 2914);
+  dasm_put(Dst, 2919);
 #if LJ_HASJIT
-  dasm_put(Dst, 2916, Dt7(->field_pc), DISPATCH_GL(jit_L), LJ_VMST_INTERP, PC2PROTO(k), DISPATCH_GL(vmstate), BC_FUNCF);
+  dasm_put(Dst, 2921, Dt7(->field_pc), DISPATCH_GL(jit_L), LJ_VMST_INTERP, PC2PROTO(k), DISPATCH_GL(vmstate), BC_FUNCF);
 #endif
-  dasm_put(Dst, 2953);
+  dasm_put(Dst, 2958);
 #if LJ_HASJIT
-  dasm_put(Dst, 3027);
+  dasm_put(Dst, 3034);
 #endif
-  dasm_put(Dst, 3041);
+  dasm_put(Dst, 3048);
   {
     int i;
     for (i = 31; i >= 0; i--) {
-      dasm_put(Dst, 3077, i, i);
+      dasm_put(Dst, 3084, i, i);
     }
   }
-  dasm_put(Dst, 3082);
+  dasm_put(Dst, 3089);
 #if LJ_HASJIT
-  dasm_put(Dst, 3111);
+  dasm_put(Dst, 3118);
 #else
-  dasm_put(Dst, 3136);
+  dasm_put(Dst, 3143);
 #endif
-  dasm_put(Dst, 3138);
+  dasm_put(Dst, 3145);
 #if LJ_HASFFI
 #define DtE(_V) (int)(ptrdiff_t)&(((CTState *)0)_V)
-  dasm_put(Dst, 3140, Dt2(->ctype_state), GG_G2DISP, DtE(->cb.gpr[0]), DtE(->cb.gpr[2]), CFRAME_SIZE, DtE(->cb.stack), DtE(->cb.slot), Dt1(->base), LJ_VMST_INTERP, Dt1(->top), DISPATCH_GL(vmstate), Dt7(->field_pc));
+  dasm_put(Dst, 3147, Dt2(->ctype_state), GG_G2DISP, DtE(->cb.gpr[0]), DtE(->cb.gpr[2]), CFRAME_SIZE, DtE(->cb.stack), DtE(->cb.slot), Dt1(->base), LJ_VMST_INTERP, Dt1(->top), DISPATCH_GL(vmstate), Dt7(->field_pc));
 #endif
-  dasm_put(Dst, 3183);
+  dasm_put(Dst, 3190);
 #if LJ_HASFFI
-  dasm_put(Dst, 3185, DISPATCH_GL(ctype_state), Dt1(->base), Dt1(->top), DtE(->L), DtE(->cb.gpr[0]));
+  dasm_put(Dst, 3192, DISPATCH_GL(ctype_state), Dt1(->base), Dt1(->top), DtE(->L), DtE(->cb.gpr[0]));
 #endif
-  dasm_put(Dst, 3202);
+  dasm_put(Dst, 3209);
 #if LJ_HASFFI
 #define DtF(_V) (int)(ptrdiff_t)&(((CCallState *)0)_V)
-  dasm_put(Dst, 3204, DtF(->spadj), DtF(->nsp), offsetof(CCallState, stack), DtF(->func), DtF(->gpr[0]), DtF(->gpr[1]), DtF(->gpr[2]), DtF(->gpr[3]), DtF(->gpr[0]), DtF(->gpr[1]));
+  dasm_put(Dst, 3211, DtF(->spadj), DtF(->nsp), offsetof(CCallState, stack), DtF(->func), DtF(->gpr[0]), DtF(->gpr[1]), DtF(->gpr[2]), DtF(->gpr[3]), DtF(->gpr[0]), DtF(->gpr[1]));
 #endif
 }
 
@@ -6535,7 +6542,7 @@ static void build_subroutines(BuildCtx *ctx)
 static void build_ins(BuildCtx *ctx, BCOp op, int defop)
 {
   int vk = 0;
-  dasm_put(Dst, 3242, defop);
+  dasm_put(Dst, 3249, defop);
 
   switch (op) {
 
@@ -6544,174 +6551,174 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
   /* Remember: all ops branch for a true comparison, fall through otherwise. */
 
   case BC_ISLT: case BC_ISGE: case BC_ISLE: case BC_ISGT:
-    dasm_put(Dst, 3244, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3251, -LJ_TISNUM, -LJ_TISNUM);
     if (op == BC_ISLT) {
-      dasm_put(Dst, 3260);
+      dasm_put(Dst, 3267);
     } else if (op == BC_ISGE) {
-      dasm_put(Dst, 3262);
+      dasm_put(Dst, 3269);
     } else if (op == BC_ISLE) {
-      dasm_put(Dst, 3264);
+      dasm_put(Dst, 3271);
     } else {
-      dasm_put(Dst, 3266);
+      dasm_put(Dst, 3273);
     }
-    dasm_put(Dst, 3268, -LJ_TISNUM);
+    dasm_put(Dst, 3275, -LJ_TISNUM);
     if (op == BC_ISLT) {
-      dasm_put(Dst, 3304);
+      dasm_put(Dst, 3311);
     } else if (op == BC_ISGE) {
-      dasm_put(Dst, 3306);
+      dasm_put(Dst, 3313);
     } else if (op == BC_ISLE) {
-      dasm_put(Dst, 3308);
+      dasm_put(Dst, 3315);
     } else {
-      dasm_put(Dst, 3310);
+      dasm_put(Dst, 3317);
     }
-    dasm_put(Dst, 3312);
+    dasm_put(Dst, 3319);
     break;
 
   case BC_ISEQV: case BC_ISNEV:
     vk = op == BC_ISEQV;
-    dasm_put(Dst, 3315, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3322, -LJ_TISNUM, -LJ_TISNUM);
     if (vk) {
-      dasm_put(Dst, 3326);
+      dasm_put(Dst, 3333);
     } else {
-      dasm_put(Dst, 3329);
+      dasm_put(Dst, 3336);
     }
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3332, -LJ_TCDATA, -LJ_TCDATA);
+      dasm_put(Dst, 3339, -LJ_TCDATA, -LJ_TCDATA);
     }
-    dasm_put(Dst, 3339, -LJ_TISPRI);
+    dasm_put(Dst, 3346, -LJ_TISPRI);
     if (vk) {
-      dasm_put(Dst, 3348, -LJ_TISTABUD);
+      dasm_put(Dst, 3355, -LJ_TISTABUD);
     } else {
-      dasm_put(Dst, 3365, -LJ_TISTABUD);
+      dasm_put(Dst, 3372, -LJ_TISTABUD);
     }
-    dasm_put(Dst, 3372, Dt6(->metatable));
+    dasm_put(Dst, 3379, Dt6(->metatable));
     if (vk) {
-      dasm_put(Dst, 3376);
+      dasm_put(Dst, 3383);
     } else {
-      dasm_put(Dst, 3379);
+      dasm_put(Dst, 3386);
     }
-    dasm_put(Dst, 3382, Dt6(->nomm), 1-vk, 1<<MM_eq);
+    dasm_put(Dst, 3389, Dt6(->nomm), 1-vk, 1<<MM_eq);
     if (vk) {
-      dasm_put(Dst, 3392);
+      dasm_put(Dst, 3399);
     } else {
-      dasm_put(Dst, 3395);
+      dasm_put(Dst, 3402);
     }
     break;
 
   case BC_ISEQS: case BC_ISNES:
     vk = op == BC_ISEQS;
-    dasm_put(Dst, 3405, -LJ_TSTR);
+    dasm_put(Dst, 3412, -LJ_TSTR);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3414);
+      dasm_put(Dst, 3421);
     } else {
-      dasm_put(Dst, 3418);
+      dasm_put(Dst, 3425);
     }
     if (vk) {
-      dasm_put(Dst, 3420);
+      dasm_put(Dst, 3427);
     } else {
-      dasm_put(Dst, 3423);
+      dasm_put(Dst, 3430);
     }
-    dasm_put(Dst, 3426);
+    dasm_put(Dst, 3433);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3433, -LJ_TCDATA);
+      dasm_put(Dst, 3440, -LJ_TCDATA);
     }
     break;
 
   case BC_ISEQN: case BC_ISNEN:
     vk = op == BC_ISEQN;
-    dasm_put(Dst, 3441);
+    dasm_put(Dst, 3448);
     if (vk) {
-      dasm_put(Dst, 3448);
+      dasm_put(Dst, 3455);
     } else {
-      dasm_put(Dst, 3450);
+      dasm_put(Dst, 3457);
     }
-    dasm_put(Dst, 3452, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3459, -LJ_TISNUM, -LJ_TISNUM);
     if (vk) {
-      dasm_put(Dst, 3462);
+      dasm_put(Dst, 3469);
     } else {
-      dasm_put(Dst, 3465);
+      dasm_put(Dst, 3472);
     }
-    dasm_put(Dst, 3468);
+    dasm_put(Dst, 3475);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3477);
+      dasm_put(Dst, 3484);
     } else {
       if (!vk) {
-        dasm_put(Dst, 3480);
+        dasm_put(Dst, 3487);
       }
-      dasm_put(Dst, 3482);
+      dasm_put(Dst, 3489);
     }
-    dasm_put(Dst, 3485, -LJ_TISNUM);
+    dasm_put(Dst, 3492, -LJ_TISNUM);
     if (vk) {
-      dasm_put(Dst, 3501);
+      dasm_put(Dst, 3508);
     } else {
-      dasm_put(Dst, 3503);
+      dasm_put(Dst, 3510);
     }
-    dasm_put(Dst, 3505);
+    dasm_put(Dst, 3512);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3508, -LJ_TCDATA);
+      dasm_put(Dst, 3515, -LJ_TCDATA);
     }
     break;
 
   case BC_ISEQP: case BC_ISNEP:
     vk = op == BC_ISEQP;
-    dasm_put(Dst, 3516);
+    dasm_put(Dst, 3523);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3522, -LJ_TCDATA);
+      dasm_put(Dst, 3529, -LJ_TCDATA);
     }
-    dasm_put(Dst, 3527);
+    dasm_put(Dst, 3534);
     if (vk) {
-      dasm_put(Dst, 3529);
+      dasm_put(Dst, 3536);
     } else {
-      dasm_put(Dst, 3531);
+      dasm_put(Dst, 3538);
     }
-    dasm_put(Dst, 3533);
+    dasm_put(Dst, 3540);
     break;
 
   /* -- Unary test and copy ops ------------------------------------------- */
 
   case BC_ISTC: case BC_ISFC: case BC_IST: case BC_ISF:
-    dasm_put(Dst, 3540, -LJ_TTRUE);
+    dasm_put(Dst, 3547, -LJ_TTRUE);
     if (op == BC_ISTC || op == BC_IST) {
-      dasm_put(Dst, 3548);
+      dasm_put(Dst, 3555);
       if (op == BC_ISTC) {
-        dasm_put(Dst, 3550);
+        dasm_put(Dst, 3557);
       }
     } else {
-      dasm_put(Dst, 3552);
+      dasm_put(Dst, 3559);
       if (op == BC_ISFC) {
-        dasm_put(Dst, 3554);
+        dasm_put(Dst, 3561);
       }
     }
-    dasm_put(Dst, 3556);
+    dasm_put(Dst, 3563);
     break;
 
   /* -- Unary ops --------------------------------------------------------- */
 
   case BC_MOV:
-    dasm_put(Dst, 3563);
+    dasm_put(Dst, 3570);
     break;
   case BC_NOT:
-    dasm_put(Dst, 3573, -LJ_TTRUE, ~LJ_TFALSE, ~LJ_TTRUE);
+    dasm_put(Dst, 3580, -LJ_TTRUE, ~LJ_TFALSE, ~LJ_TTRUE);
     break;
   case BC_UNM:
-    dasm_put(Dst, 3590, -LJ_TISNUM);
+    dasm_put(Dst, 3597, -LJ_TISNUM);
     break;
   case BC_LEN:
-    dasm_put(Dst, 3616, -LJ_TSTR, Dt5(->len), ~LJ_TISNUM, -LJ_TTAB);
+    dasm_put(Dst, 3623, -LJ_TSTR, Dt5(->len), ~LJ_TISNUM, -LJ_TTAB);
 #ifdef LUAJIT_ENABLE_LUA52COMPAT
-    dasm_put(Dst, 3640, Dt6(->metatable));
+    dasm_put(Dst, 3647, Dt6(->metatable));
 #endif
-    dasm_put(Dst, 3647);
+    dasm_put(Dst, 3654);
     if (LJ_TARGET_OSX) {
-    dasm_put(Dst, 3649);
+    dasm_put(Dst, 3656);
     }
-    dasm_put(Dst, 3651);
+    dasm_put(Dst, 3658);
     if (LJ_TARGET_OSX) {
-    dasm_put(Dst, 3654);
+    dasm_put(Dst, 3661);
     }
-    dasm_put(Dst, 3656);
+    dasm_put(Dst, 3663);
 #ifdef LUAJIT_ENABLE_LUA52COMPAT
-    dasm_put(Dst, 3659, Dt6(->nomm), 1<<MM_len);
+    dasm_put(Dst, 3666, Dt6(->nomm), 1<<MM_len);
 #endif
     break;
 
@@ -6719,403 +6726,403 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
 
 
   case BC_ADDVN: case BC_ADDNV: case BC_ADDVV:
-    dasm_put(Dst, 3669);
+    dasm_put(Dst, 3676);
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 3672);
+    dasm_put(Dst, 3679);
       break;
     case 1:
-    dasm_put(Dst, 3675);
+    dasm_put(Dst, 3682);
       break;
     default:
-    dasm_put(Dst, 3678);
+    dasm_put(Dst, 3685);
       break;
     }
-    dasm_put(Dst, 3681);
+    dasm_put(Dst, 3688);
     if (vk == 1) {
-    dasm_put(Dst, 3683, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3690, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3688, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3695, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3693);
+    dasm_put(Dst, 3700);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 3697);
+    dasm_put(Dst, 3704);
       break;
     case 1:
-    dasm_put(Dst, 3700);
+    dasm_put(Dst, 3707);
       break;
     default:
-    dasm_put(Dst, 3703);
+    dasm_put(Dst, 3710);
       break;
     }
-    dasm_put(Dst, 3706);
+    dasm_put(Dst, 3713);
     switch (vk) {
     case 0:
     if (vk == 1) {
-    dasm_put(Dst, 3715, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3722, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3720, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3727, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3725);
+    dasm_put(Dst, 3732);
       break;
     case 1:
     if (vk == 1) {
-    dasm_put(Dst, 3728, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3735, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3733, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3740, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3738);
+    dasm_put(Dst, 3745);
       break;
     default:
     if (vk == 1) {
-    dasm_put(Dst, 3741, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3748, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3746, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3753, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3751);
+    dasm_put(Dst, 3758);
       break;
     }
-    dasm_put(Dst, 3754);
+    dasm_put(Dst, 3761);
     break;
   case BC_SUBVN: case BC_SUBNV: case BC_SUBVV:
-    dasm_put(Dst, 3760);
+    dasm_put(Dst, 3767);
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 3763);
+    dasm_put(Dst, 3770);
       break;
     case 1:
-    dasm_put(Dst, 3766);
+    dasm_put(Dst, 3773);
       break;
     default:
-    dasm_put(Dst, 3769);
+    dasm_put(Dst, 3776);
       break;
     }
-    dasm_put(Dst, 3772);
+    dasm_put(Dst, 3779);
     if (vk == 1) {
-    dasm_put(Dst, 3774, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3781, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3779, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3786, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3784);
+    dasm_put(Dst, 3791);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 3788);
+    dasm_put(Dst, 3795);
       break;
     case 1:
-    dasm_put(Dst, 3791);
+    dasm_put(Dst, 3798);
       break;
     default:
-    dasm_put(Dst, 3794);
+    dasm_put(Dst, 3801);
       break;
     }
-    dasm_put(Dst, 3797);
+    dasm_put(Dst, 3804);
     switch (vk) {
     case 0:
     if (vk == 1) {
-    dasm_put(Dst, 3806, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3813, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3811, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3818, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3816);
+    dasm_put(Dst, 3823);
       break;
     case 1:
     if (vk == 1) {
-    dasm_put(Dst, 3819, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3826, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3824, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3831, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3829);
+    dasm_put(Dst, 3836);
       break;
     default:
     if (vk == 1) {
-    dasm_put(Dst, 3832, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3839, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3837, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3844, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3842);
+    dasm_put(Dst, 3849);
       break;
     }
-    dasm_put(Dst, 3845);
+    dasm_put(Dst, 3852);
     break;
   case BC_MULVN: case BC_MULNV: case BC_MULVV:
-    dasm_put(Dst, 3851);
+    dasm_put(Dst, 3858);
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 3854);
+    dasm_put(Dst, 3861);
       break;
     case 1:
-    dasm_put(Dst, 3857);
+    dasm_put(Dst, 3864);
       break;
     default:
-    dasm_put(Dst, 3860);
+    dasm_put(Dst, 3867);
       break;
     }
-    dasm_put(Dst, 3863);
+    dasm_put(Dst, 3870);
     if (vk == 1) {
-    dasm_put(Dst, 3865, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3872, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3870, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3877, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3875);
+    dasm_put(Dst, 3882);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 3880);
+    dasm_put(Dst, 3887);
       break;
     case 1:
-    dasm_put(Dst, 3883);
+    dasm_put(Dst, 3890);
       break;
     default:
-    dasm_put(Dst, 3886);
+    dasm_put(Dst, 3893);
       break;
     }
-    dasm_put(Dst, 3889);
+    dasm_put(Dst, 3896);
     switch (vk) {
     case 0:
     if (vk == 1) {
-    dasm_put(Dst, 3898, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3905, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3903, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3910, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3908);
+    dasm_put(Dst, 3915);
       break;
     case 1:
     if (vk == 1) {
-    dasm_put(Dst, 3911, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3918, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3916, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3923, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3921);
+    dasm_put(Dst, 3928);
       break;
     default:
     if (vk == 1) {
-    dasm_put(Dst, 3924, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3931, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3929, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3936, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3934);
+    dasm_put(Dst, 3941);
       break;
     }
-    dasm_put(Dst, 3937);
+    dasm_put(Dst, 3944);
     break;
   case BC_DIVVN: case BC_DIVNV: case BC_DIVVV:
-    dasm_put(Dst, 3943);
+    dasm_put(Dst, 3950);
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 3946);
+    dasm_put(Dst, 3953);
       break;
     case 1:
-    dasm_put(Dst, 3949);
+    dasm_put(Dst, 3956);
       break;
     default:
-    dasm_put(Dst, 3952);
+    dasm_put(Dst, 3959);
       break;
     }
     switch (vk) {
     case 0:
     if (vk == 1) {
-    dasm_put(Dst, 3955, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3962, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3960, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3967, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3965);
+    dasm_put(Dst, 3972);
       break;
     case 1:
     if (vk == 1) {
-    dasm_put(Dst, 3968, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3975, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3973, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3980, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3978);
+    dasm_put(Dst, 3985);
       break;
     default:
     if (vk == 1) {
-    dasm_put(Dst, 3981, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3988, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 3986, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 3993, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 3991);
+    dasm_put(Dst, 3998);
       break;
     }
-    dasm_put(Dst, 3994);
+    dasm_put(Dst, 4001);
     break;
   case BC_MODVN: case BC_MODNV: case BC_MODVV:
-    dasm_put(Dst, 4004);
+    dasm_put(Dst, 4011);
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 4007);
+    dasm_put(Dst, 4014);
       break;
     case 1:
-    dasm_put(Dst, 4010);
+    dasm_put(Dst, 4017);
       break;
     default:
-    dasm_put(Dst, 4013);
+    dasm_put(Dst, 4020);
       break;
     }
     if (vk == 1) {
-    dasm_put(Dst, 4016, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4023, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 4021, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4028, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 4026);
+    dasm_put(Dst, 4033);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 4030);
+    dasm_put(Dst, 4037);
       break;
     case 1:
-    dasm_put(Dst, 4033);
+    dasm_put(Dst, 4040);
       break;
     default:
-    dasm_put(Dst, 4036);
+    dasm_put(Dst, 4043);
       break;
     }
-    dasm_put(Dst, 4039, ~LJ_TISNUM);
+    dasm_put(Dst, 4046, ~LJ_TISNUM);
     switch (vk) {
     case 0:
     if (vk == 1) {
-    dasm_put(Dst, 4053, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4060, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 4058, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4065, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 4063);
+    dasm_put(Dst, 4070);
       break;
     case 1:
     if (vk == 1) {
-    dasm_put(Dst, 4066, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4073, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 4071, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4078, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 4076);
+    dasm_put(Dst, 4083);
       break;
     default:
     if (vk == 1) {
-    dasm_put(Dst, 4079, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4086, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 4084, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4091, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 4089);
+    dasm_put(Dst, 4096);
       break;
     }
-    dasm_put(Dst, 4092);
+    dasm_put(Dst, 4099);
     break;
   case BC_POW:
-    dasm_put(Dst, 4097);
+    dasm_put(Dst, 4104);
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 4100);
+    dasm_put(Dst, 4107);
       break;
     case 1:
-    dasm_put(Dst, 4103);
+    dasm_put(Dst, 4110);
       break;
     default:
-    dasm_put(Dst, 4106);
+    dasm_put(Dst, 4113);
       break;
     }
     switch (vk) {
     case 0:
     if (vk == 1) {
-    dasm_put(Dst, 4109, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4116, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 4114, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4121, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 4119);
+    dasm_put(Dst, 4126);
       break;
     case 1:
     if (vk == 1) {
-    dasm_put(Dst, 4122, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4129, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 4127, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4134, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 4132);
+    dasm_put(Dst, 4139);
       break;
     default:
     if (vk == 1) {
-    dasm_put(Dst, 4135, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4142, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-    dasm_put(Dst, 4140, -LJ_TISNUM, -LJ_TISNUM);
+    dasm_put(Dst, 4147, -LJ_TISNUM, -LJ_TISNUM);
     }
-    dasm_put(Dst, 4145);
+    dasm_put(Dst, 4152);
       break;
     }
     if (LJ_TARGET_OSX) {
-    dasm_put(Dst, 4148);
+    dasm_put(Dst, 4155);
     }
-    dasm_put(Dst, 4150);
+    dasm_put(Dst, 4157);
     if (LJ_TARGET_OSX) {
-    dasm_put(Dst, 4153);
+    dasm_put(Dst, 4160);
     }
-    dasm_put(Dst, 4155);
+    dasm_put(Dst, 4162);
     break;
 
   case BC_CAT:
-    dasm_put(Dst, 4163, Dt1(->base), Dt1(->base));
+    dasm_put(Dst, 4170, Dt1(->base), Dt1(->base));
     break;
 
   /* -- Constant ops ------------------------------------------------------ */
 
   case BC_KSTR:
-    dasm_put(Dst, 4189, ~LJ_TSTR);
+    dasm_put(Dst, 4196, ~LJ_TSTR);
     break;
   case BC_KCDATA:
 #if LJ_HASFFI
-    dasm_put(Dst, 4201, ~LJ_TCDATA);
+    dasm_put(Dst, 4208, ~LJ_TCDATA);
 #endif
     break;
   case BC_KSHORT:
-    dasm_put(Dst, 4213, ~LJ_TISNUM);
+    dasm_put(Dst, 4220, ~LJ_TISNUM);
     break;
   case BC_KNUM:
-    dasm_put(Dst, 4224);
+    dasm_put(Dst, 4231);
     break;
   case BC_KPRI:
-    dasm_put(Dst, 4234);
+    dasm_put(Dst, 4241);
     break;
   case BC_KNIL:
-    dasm_put(Dst, 4244, ~LJ_TNIL);
+    dasm_put(Dst, 4251, ~LJ_TNIL);
     break;
 
   /* -- Upvalue and function ops ------------------------------------------ */
 
   case BC_UGET:
-    dasm_put(Dst, 4263, offsetof(GCfuncL, uvptr), DtA(->v));
+    dasm_put(Dst, 4270, offsetof(GCfuncL, uvptr), DtA(->v));
     break;
   case BC_USETV:
-    dasm_put(Dst, 4279, offsetof(GCfuncL, uvptr), DtA(->marked), DtA(->closed), DtA(->v), LJ_GC_BLACK, -LJ_TISGCV, -(LJ_TISNUM - LJ_TISGCV), Dt4(->gch.marked), -GG_DISP2G, LJ_GC_WHITES);
+    dasm_put(Dst, 4286, offsetof(GCfuncL, uvptr), DtA(->marked), DtA(->closed), DtA(->v), LJ_GC_BLACK, -LJ_TISGCV, -(LJ_TISNUM - LJ_TISGCV), Dt4(->gch.marked), -GG_DISP2G, LJ_GC_WHITES);
     if (LJ_TARGET_OSX) {
-      dasm_put(Dst, 4319);
-    } else {
       dasm_put(Dst, 4326);
+    } else {
+      dasm_put(Dst, 4333);
     }
-    dasm_put(Dst, 4329);
+    dasm_put(Dst, 4336);
     break;
   case BC_USETS:
-    dasm_put(Dst, 4332, offsetof(GCfuncL, uvptr), ~LJ_TSTR, DtA(->marked), DtA(->v), DtA(->closed), LJ_GC_BLACK, Dt5(->marked), LJ_GC_WHITES, -GG_DISP2G);
+    dasm_put(Dst, 4339, offsetof(GCfuncL, uvptr), ~LJ_TSTR, DtA(->marked), DtA(->v), DtA(->closed), LJ_GC_BLACK, Dt5(->marked), LJ_GC_WHITES, -GG_DISP2G);
     if (LJ_TARGET_OSX) {
-      dasm_put(Dst, 4368);
-    } else {
       dasm_put(Dst, 4375);
+    } else {
+      dasm_put(Dst, 4382);
     }
-    dasm_put(Dst, 4378);
+    dasm_put(Dst, 4385);
     break;
   case BC_USETN:
-    dasm_put(Dst, 4381, offsetof(GCfuncL, uvptr), DtA(->v));
+    dasm_put(Dst, 4388, offsetof(GCfuncL, uvptr), DtA(->v));
     break;
   case BC_USETP:
-    dasm_put(Dst, 4398, offsetof(GCfuncL, uvptr), DtA(->v));
+    dasm_put(Dst, 4405, offsetof(GCfuncL, uvptr), DtA(->v));
     break;
 
   case BC_UCLO:
-    dasm_put(Dst, 4414, Dt1(->openupval), Dt1(->base), Dt1(->base));
+    dasm_put(Dst, 4421, Dt1(->openupval), Dt1(->base), Dt1(->base));
     break;
 
   case BC_FNEW:
-    dasm_put(Dst, 4437, Dt1(->base), Dt1(->base), ~LJ_TFUNC);
+    dasm_put(Dst, 4444, Dt1(->base), Dt1(->base), ~LJ_TFUNC);
     break;
 
   /* -- Table ops --------------------------------------------------------- */
@@ -7123,115 +7130,115 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
   case BC_TNEW:
   case BC_TDUP:
     if (op == BC_TDUP) {
-      dasm_put(Dst, 4458);
+      dasm_put(Dst, 4465);
     }
-    dasm_put(Dst, 4460, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), Dt1(->base));
+    dasm_put(Dst, 4467, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), Dt1(->base));
     if (op == BC_TNEW) {
-      dasm_put(Dst, 4473);
+      dasm_put(Dst, 4480);
     } else {
-      dasm_put(Dst, 4482);
+      dasm_put(Dst, 4489);
     }
-    dasm_put(Dst, 4486, Dt1(->base), ~LJ_TTAB);
+    dasm_put(Dst, 4493, Dt1(->base), ~LJ_TTAB);
     break;
 
   case BC_GGET:
   case BC_GSET:
-    dasm_put(Dst, 4504, Dt7(->env));
+    dasm_put(Dst, 4511, Dt7(->env));
     if (op == BC_GGET) {
-      dasm_put(Dst, 4510);
+      dasm_put(Dst, 4517);
     } else {
-      dasm_put(Dst, 4513);
+      dasm_put(Dst, 4520);
     }
     break;
 
   case BC_TGETV:
-    dasm_put(Dst, 4516, -LJ_TTAB, -LJ_TISNUM, Dt6(->array), Dt6(->asize), -LJ_TNIL, Dt6(->metatable), Dt6(->nomm), 1<<MM_index, -LJ_TSTR);
+    dasm_put(Dst, 4523, -LJ_TTAB, -LJ_TISNUM, Dt6(->array), Dt6(->asize), -LJ_TNIL, Dt6(->metatable), Dt6(->nomm), 1<<MM_index, -LJ_TSTR);
     break;
   case BC_TGETS:
-    dasm_put(Dst, 4573, -LJ_TTAB, Dt6(->hmask), Dt5(->hash), Dt6(->node), DtB(->key), DtB(->val), DtB(->next), -LJ_TSTR, -LJ_TNIL, Dt6(->metatable), ~LJ_TNIL, Dt6(->nomm));
-    dasm_put(Dst, 4633, 1<<MM_index);
+    dasm_put(Dst, 4580, -LJ_TTAB, Dt6(->hmask), Dt5(->hash), Dt6(->node), DtB(->key), DtB(->val), DtB(->next), -LJ_TSTR, -LJ_TNIL, Dt6(->metatable), ~LJ_TNIL, Dt6(->nomm));
+    dasm_put(Dst, 4640, 1<<MM_index);
     break;
   case BC_TGETB:
-    dasm_put(Dst, 4640, -LJ_TTAB, Dt6(->asize), Dt6(->array), -LJ_TNIL, Dt6(->metatable), Dt6(->nomm), 1<<MM_index);
+    dasm_put(Dst, 4647, -LJ_TTAB, Dt6(->asize), Dt6(->array), -LJ_TNIL, Dt6(->metatable), Dt6(->nomm), 1<<MM_index);
     break;
 
   case BC_TSETV:
-    dasm_put(Dst, 4683, -LJ_TTAB, -LJ_TISNUM, Dt6(->array), Dt6(->asize), -LJ_TNIL, Dt6(->marked), LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex);
-    dasm_put(Dst, 4743, DISPATCH_GL(gc.grayagain), LJ_GC_BLACK, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist), -LJ_TSTR);
+    dasm_put(Dst, 4690, -LJ_TTAB, -LJ_TISNUM, Dt6(->array), Dt6(->asize), -LJ_TNIL, Dt6(->marked), LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex);
+    dasm_put(Dst, 4750, DISPATCH_GL(gc.grayagain), LJ_GC_BLACK, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist), -LJ_TSTR);
     break;
   case BC_TSETS:
-    dasm_put(Dst, 4764, -LJ_TTAB, Dt6(->hmask), Dt5(->hash), Dt6(->node), Dt6(->nomm), DtB(->key), DtB(->val.it), DtB(->next), -LJ_TSTR, Dt6(->marked), -LJ_TNIL, LJ_GC_BLACK, DtB(->val));
-    dasm_put(Dst, 4822, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, Dt6(->metatable), Dt1(->base), Dt6(->nomm), 1<<MM_newindex, ~LJ_TSTR, Dt1(->base), DISPATCH_GL(gc.grayagain), LJ_GC_BLACK);
-    dasm_put(Dst, 4875, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
+    dasm_put(Dst, 4771, -LJ_TTAB, Dt6(->hmask), Dt5(->hash), Dt6(->node), Dt6(->nomm), DtB(->key), DtB(->val.it), DtB(->next), -LJ_TSTR, Dt6(->marked), -LJ_TNIL, LJ_GC_BLACK, DtB(->val));
+    dasm_put(Dst, 4829, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, Dt6(->metatable), Dt1(->base), Dt6(->nomm), 1<<MM_newindex, ~LJ_TSTR, Dt1(->base), DISPATCH_GL(gc.grayagain), LJ_GC_BLACK);
+    dasm_put(Dst, 4882, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
     break;
   case BC_TSETB:
-    dasm_put(Dst, 4884, -LJ_TTAB, Dt6(->asize), Dt6(->array), -LJ_TNIL, Dt6(->marked), LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, DISPATCH_GL(gc.grayagain), LJ_GC_BLACK);
-    dasm_put(Dst, 4942, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
+    dasm_put(Dst, 4891, -LJ_TTAB, Dt6(->asize), Dt6(->array), -LJ_TNIL, Dt6(->marked), LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, DISPATCH_GL(gc.grayagain), LJ_GC_BLACK);
+    dasm_put(Dst, 4949, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
     break;
 
   case BC_TSETM:
-    dasm_put(Dst, 4951, Dt6(->asize), Dt6(->array), Dt6(->marked), LJ_GC_BLACK, Dt1(->base));
+    dasm_put(Dst, 4958, Dt6(->asize), Dt6(->array), Dt6(->marked), LJ_GC_BLACK, Dt1(->base));
     if (LJ_TARGET_OSX) {
-    dasm_put(Dst, 4996, Dt1(->base));
+    dasm_put(Dst, 5003, Dt1(->base));
     }
-    dasm_put(Dst, 4999, DISPATCH_GL(gc.grayagain), LJ_GC_BLACK, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
+    dasm_put(Dst, 5006, DISPATCH_GL(gc.grayagain), LJ_GC_BLACK, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
     break;
 
   /* -- Calls and vararg handling ----------------------------------------- */
 
   case BC_CALLM:
-    dasm_put(Dst, 5015);
+    dasm_put(Dst, 5022);
     break;
   case BC_CALL:
-    dasm_put(Dst, 5021, -LJ_TFUNC, Dt7(->field_pc));
+    dasm_put(Dst, 5028, -LJ_TFUNC, Dt7(->field_pc));
     break;
 
   case BC_CALLMT:
-    dasm_put(Dst, 5041);
+    dasm_put(Dst, 5048);
     break;
   case BC_CALLT:
-    dasm_put(Dst, 5046, -LJ_TFUNC, Dt7(->ffid), FRAME_TYPE, Dt7(->field_pc), Dt7(->field_pc), PC2PROTO(k), FRAME_VARG, FRAME_TYPEP);
-    dasm_put(Dst, 5107, FRAME_TYPE);
+    dasm_put(Dst, 5053, -LJ_TFUNC, Dt7(->ffid), FRAME_TYPE, Dt7(->field_pc), Dt7(->field_pc), PC2PROTO(k), FRAME_VARG, FRAME_TYPEP);
+    dasm_put(Dst, 5114, FRAME_TYPE);
     break;
 
   case BC_ITERC:
-    dasm_put(Dst, 5118, -LJ_TFUNC, Dt7(->field_pc));
+    dasm_put(Dst, 5125, -LJ_TFUNC, Dt7(->field_pc));
     break;
 
   case BC_ITERN:
 #if LJ_HASJIT
 #endif
-    dasm_put(Dst, 5142, Dt6(->asize), Dt6(->array), -LJ_TNIL, ~LJ_TISNUM, Dt6(->hmask), Dt6(->node), DtB(->val), -LJ_TNIL, DtB(->key));
+    dasm_put(Dst, 5149, Dt6(->asize), Dt6(->array), -LJ_TNIL, ~LJ_TISNUM, Dt6(->hmask), Dt6(->node), DtB(->val), -LJ_TNIL, DtB(->key));
     break;
 
   case BC_ISNEXT:
-    dasm_put(Dst, 5207, -LJ_TFUNC, Dt8(->ffid), -LJ_TTAB, -LJ_TNIL, FF_next_N, BC_JMP, BC_ITERC);
+    dasm_put(Dst, 5214, -LJ_TFUNC, Dt8(->ffid), -LJ_TTAB, -LJ_TNIL, FF_next_N, BC_JMP, BC_ITERC);
     break;
 
   case BC_VARG:
-    dasm_put(Dst, 5246, FRAME_VARG, ~LJ_TNIL, Dt1(->maxstack), Dt1(->top), Dt1(->base), Dt1(->base));
+    dasm_put(Dst, 5253, FRAME_VARG, ~LJ_TNIL, Dt1(->maxstack), Dt1(->top), Dt1(->base), Dt1(->base));
     break;
 
   /* -- Returns ----------------------------------------------------------- */
 
   case BC_RETM:
-    dasm_put(Dst, 5318);
+    dasm_put(Dst, 5325);
     break;
 
   case BC_RET:
-    dasm_put(Dst, 5325, FRAME_TYPE, FRAME_VARG, Dt7(->field_pc), PC2PROTO(k), ~LJ_TNIL, FRAME_TYPEP);
+    dasm_put(Dst, 5332, FRAME_TYPE, FRAME_VARG, Dt7(->field_pc), PC2PROTO(k), ~LJ_TNIL, FRAME_TYPEP);
     break;
 
   case BC_RET0: case BC_RET1:
-    dasm_put(Dst, 5390, FRAME_TYPE, FRAME_VARG);
+    dasm_put(Dst, 5397, FRAME_TYPE, FRAME_VARG);
     if (op == BC_RET1) {
-      dasm_put(Dst, 5401);
+      dasm_put(Dst, 5408);
     }
-    dasm_put(Dst, 5403);
+    dasm_put(Dst, 5410);
     if (op == BC_RET1) {
-      dasm_put(Dst, 5406);
+      dasm_put(Dst, 5413);
     }
-    dasm_put(Dst, 5408, Dt7(->field_pc), PC2PROTO(k), ~LJ_TNIL);
+    dasm_put(Dst, 5415, Dt7(->field_pc), PC2PROTO(k), ~LJ_TNIL);
     break;
 
   /* -- Loops and branches ------------------------------------------------ */
@@ -7239,7 +7246,7 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
 
   case BC_FORL:
 #if LJ_HASJIT
-    dasm_put(Dst, 5434, -GG_DISP2HOT, HOTCOUNT_LOOP);
+    dasm_put(Dst, 5441, -GG_DISP2HOT, HOTCOUNT_LOOP);
 #endif
     break;
 
@@ -7251,68 +7258,68 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
   case BC_FORI:
   case BC_IFORL:
     vk = (op == BC_IFORL || op == BC_JFORL);
-    dasm_put(Dst, 5445);
+    dasm_put(Dst, 5452);
     if (op != BC_JFORL) {
-      dasm_put(Dst, 5447);
+      dasm_put(Dst, 5454);
     }
     if (!vk) {
-      dasm_put(Dst, 5449, -LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM);
+      dasm_put(Dst, 5456, -LJ_TISNUM, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-      dasm_put(Dst, 5467, -LJ_TISNUM);
+      dasm_put(Dst, 5474, -LJ_TISNUM);
       if (op == BC_IFORL) {
-        dasm_put(Dst, 5475);
+        dasm_put(Dst, 5482);
       } else {
-        dasm_put(Dst, 5477);
+        dasm_put(Dst, 5484);
       }
-      dasm_put(Dst, 5480);
+      dasm_put(Dst, 5487);
     }
-    dasm_put(Dst, 5485);
+    dasm_put(Dst, 5492);
     if (op == BC_FORI) {
-      dasm_put(Dst, 5487);
+      dasm_put(Dst, 5494);
     } else if (op == BC_JFORI) {
-      dasm_put(Dst, 5489);
+      dasm_put(Dst, 5496);
     } else if (op == BC_IFORL) {
-      dasm_put(Dst, 5492);
+      dasm_put(Dst, 5499);
     }
     if (vk) {
-      dasm_put(Dst, 5494);
+      dasm_put(Dst, 5501);
     }
-    dasm_put(Dst, 5496);
+    dasm_put(Dst, 5503);
     if (op == BC_JFORI || op == BC_JFORL) {
-      dasm_put(Dst, 5501, BC_JLOOP);
+      dasm_put(Dst, 5508, BC_JLOOP);
     }
-    dasm_put(Dst, 5504);
+    dasm_put(Dst, 5511);
     if (!vk) {
-      dasm_put(Dst, 5511);
+      dasm_put(Dst, 5518);
     } else {
-      dasm_put(Dst, 5513);
+      dasm_put(Dst, 5520);
     }
-    dasm_put(Dst, 5515);
+    dasm_put(Dst, 5522);
     if (!vk) {
-      dasm_put(Dst, 5519, -LJ_TISNUM, -LJ_TISNUM);
+      dasm_put(Dst, 5526, -LJ_TISNUM, -LJ_TISNUM);
     } else {
-      dasm_put(Dst, 5531);
+      dasm_put(Dst, 5538);
     }
-    dasm_put(Dst, 5540);
+    dasm_put(Dst, 5547);
     if (op == BC_FORI) {
-      dasm_put(Dst, 5544);
+      dasm_put(Dst, 5551);
     } else if (op == BC_JFORI) {
-      dasm_put(Dst, 5546, BC_JLOOP);
+      dasm_put(Dst, 5553, BC_JLOOP);
     } else if (op == BC_IFORL) {
-      dasm_put(Dst, 5551);
+      dasm_put(Dst, 5558);
     } else {
-      dasm_put(Dst, 5553, BC_JLOOP);
+      dasm_put(Dst, 5560, BC_JLOOP);
     }
-    dasm_put(Dst, 5556);
+    dasm_put(Dst, 5563);
     if (vk) {
-      dasm_put(Dst, 5562);
+      dasm_put(Dst, 5569);
     }
-    dasm_put(Dst, 5567);
+    dasm_put(Dst, 5574);
     break;
 
   case BC_ITERL:
 #if LJ_HASJIT
-    dasm_put(Dst, 5573, -GG_DISP2HOT, HOTCOUNT_LOOP);
+    dasm_put(Dst, 5580, -GG_DISP2HOT, HOTCOUNT_LOOP);
 #endif
     break;
 
@@ -7321,40 +7328,40 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
     break;
 #endif
   case BC_IITERL:
-    dasm_put(Dst, 5584);
+    dasm_put(Dst, 5591);
     if (op == BC_JITERL) {
-      dasm_put(Dst, 5586, -LJ_TNIL, BC_JLOOP);
+      dasm_put(Dst, 5593, -LJ_TNIL, BC_JLOOP);
     } else {
-      dasm_put(Dst, 5592, -LJ_TNIL);
+      dasm_put(Dst, 5599, -LJ_TNIL);
     }
-    dasm_put(Dst, 5598);
+    dasm_put(Dst, 5605);
     break;
 
   case BC_LOOP:
 #if LJ_HASJIT
-    dasm_put(Dst, 5605, -GG_DISP2HOT, HOTCOUNT_LOOP);
+    dasm_put(Dst, 5612, -GG_DISP2HOT, HOTCOUNT_LOOP);
 #endif
     break;
 
   case BC_ILOOP:
-    dasm_put(Dst, 5616);
+    dasm_put(Dst, 5623);
     break;
 
   case BC_JLOOP:
 #if LJ_HASJIT
-    dasm_put(Dst, 5623, DISPATCH_J(trace), DISPATCH_GL(vmstate), DtD(->mcode), DISPATCH_GL(jit_base), DISPATCH_GL(jit_L));
+    dasm_put(Dst, 5630, DISPATCH_J(trace), DISPATCH_GL(vmstate), DtD(->mcode), DISPATCH_GL(jit_base), DISPATCH_GL(jit_L));
 #endif
     break;
 
   case BC_JMP:
-    dasm_put(Dst, 5637);
+    dasm_put(Dst, 5644);
     break;
 
   /* -- Function headers -------------------------------------------------- */
 
   case BC_FUNCF:
 #if LJ_HASJIT
-    dasm_put(Dst, 5646, -GG_DISP2HOT, HOTCOUNT_CALL);
+    dasm_put(Dst, 5653, -GG_DISP2HOT, HOTCOUNT_CALL);
 #endif
   case BC_FUNCV:  /* NYI: compiled vararg functions. */
     break;
@@ -7364,42 +7371,42 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
     break;
 #endif
   case BC_IFUNCF:
-    dasm_put(Dst, 5657, Dt1(->maxstack), -4+PC2PROTO(numparams), -4+PC2PROTO(k));
+    dasm_put(Dst, 5664, Dt1(->maxstack), -4+PC2PROTO(numparams), -4+PC2PROTO(k));
     if (op != BC_JFUNCF) {
-      dasm_put(Dst, 5667);
+      dasm_put(Dst, 5674);
     }
-    dasm_put(Dst, 5670, ~LJ_TNIL);
+    dasm_put(Dst, 5677, ~LJ_TNIL);
     if (op == BC_JFUNCF) {
-      dasm_put(Dst, 5677, BC_JLOOP);
+      dasm_put(Dst, 5684, BC_JLOOP);
     } else {
-      dasm_put(Dst, 5681);
+      dasm_put(Dst, 5688);
     }
-    dasm_put(Dst, 5686);
+    dasm_put(Dst, 5693);
     break;
 
   case BC_JFUNCV:
 #if !LJ_HASJIT
     break;
 #endif
-    dasm_put(Dst, 5692);
+    dasm_put(Dst, 5699);
     break;  /* NYI: compiled vararg functions. */
 
   case BC_IFUNCV:
-    dasm_put(Dst, 5694, Dt1(->maxstack), 8+FRAME_VARG, -4+PC2PROTO(k), -4+PC2PROTO(numparams), ~LJ_TNIL);
+    dasm_put(Dst, 5701, Dt1(->maxstack), 8+FRAME_VARG, -4+PC2PROTO(k), -4+PC2PROTO(numparams), ~LJ_TNIL);
     break;
 
   case BC_FUNCC:
   case BC_FUNCCW:
     if (op == BC_FUNCC) {
-      dasm_put(Dst, 5735, Dt8(->f));
+      dasm_put(Dst, 5742, Dt8(->f));
     } else {
-      dasm_put(Dst, 5738, DISPATCH_GL(wrapf));
+      dasm_put(Dst, 5745, DISPATCH_GL(wrapf));
     }
-    dasm_put(Dst, 5741, Dt1(->maxstack), Dt1(->base), Dt1(->top));
+    dasm_put(Dst, 5748, Dt1(->maxstack), Dt1(->base), Dt1(->top));
     if (op == BC_FUNCCW) {
-      dasm_put(Dst, 5751, Dt8(->f));
+      dasm_put(Dst, 5758, Dt8(->f));
     }
-    dasm_put(Dst, 5754, LJ_VMST_C, DISPATCH_GL(vmstate), Dt1(->base), LJ_VMST_INTERP, Dt1(->top), DISPATCH_GL(vmstate));
+    dasm_put(Dst, 5761, LJ_VMST_C, DISPATCH_GL(vmstate), Dt1(->base), LJ_VMST_INTERP, Dt1(->top), DISPATCH_GL(vmstate));
     break;
 
   /* ---------------------------------------------------------------------- */
@@ -7419,7 +7426,7 @@ static int build_backend(BuildCtx *ctx)
 
   build_subroutines(ctx);
 
-  dasm_put(Dst, 5776);
+  dasm_put(Dst, 5783);
   for (op = 0; op < BC__MAX; op++)
     build_ins(ctx, (BCOp)op, op);
 
diff --git a/src/buildvm_mips.dasc b/src/buildvm_mips.dasc
index 9e984189..a7c3b4ae 100644
--- a/src/buildvm_mips.dasc
+++ b/src/buildvm_mips.dasc
@@ -1900,6 +1900,7 @@ static void build_subroutines(BuildCtx *ctx)
   |.  and TMP1, PC, AT
   |  lbu TMP1, OFS_RA(PC)
   |  sll TMP1, TMP1, 3
+  |  addiu TMP1, TMP1, 8
   |3:
   |  b ->vm_call_dispatch               // Resolve again for tailcall.
   |.  subu TMP2, BASE, TMP1
diff --git a/src/buildvm_mips.h b/src/buildvm_mips.h
index 7c0f90bf..bab93343 100644
--- a/src/buildvm_mips.h
+++ b/src/buildvm_mips.h
@@ -12,7 +12,7 @@
 #define DASM_SECTION_CODE_OP    0
 #define DASM_SECTION_CODE_SUB   1
 #define DASM_MAXSECTION         2
-static const unsigned int build_actionlist[6323] = {
+static const unsigned int build_actionlist[6324] = {
 0xff010001,
 0xff060014,
 0x32410000,
@@ -2930,6 +2930,7 @@ static const unsigned int build_actionlist[6323] = {
 0x924d0000,
 0xff098200,
 0x000d68c0,
+0x25ad0008,
 0xff06000d,
 0x10000000,
 0xff050824,
@@ -6736,51 +6737,51 @@ static void build_subroutines(BuildCtx *ctx)
   dasm_put(Dst, 2719, 8+LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, LJ_ENDIAN_SELECT(4,0), 8+LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, LJ_ENDIAN_SELECT(4,0), 8+LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, LJ_ENDIAN_SELECT(4,0));
   dasm_put(Dst, 2790, 8+LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, LJ_ENDIAN_SELECT(4,0), 8+LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, Dt8(->f));
   dasm_put(Dst, 2863, LJ_ENDIAN_SELECT(-4,-8), 8*LUA_MINSTACK, Dt1(->maxstack), Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top), LJ_ENDIAN_SELECT(-8,-4), Dt7(->pc), FRAME_TYPE, LJ_ENDIAN_SELECT(1,2), DISPATCH_GOT(lj_state_growstack), LUA_MINSTACK, Dt1(->base));
-  dasm_put(Dst, 2931, DISPATCH_GOT(lj_gc_step), Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top), LJ_ENDIAN_SELECT(-8,-4));
+  dasm_put(Dst, 2932, DISPATCH_GOT(lj_gc_step), Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top), LJ_ENDIAN_SELECT(-8,-4));
 #if LJ_HASJIT
-  dasm_put(Dst, 2957, DISPATCH_GL(hookmask), HOOK_VMEVENT, DISPATCH_GL(hookcount), HOOK_ACTIVE, LUA_MASKLINE|LUA_MASKCOUNT, DISPATCH_GL(hookcount));
+  dasm_put(Dst, 2958, DISPATCH_GL(hookmask), HOOK_VMEVENT, DISPATCH_GL(hookcount), HOOK_ACTIVE, LUA_MASKLINE|LUA_MASKCOUNT, DISPATCH_GL(hookcount));
 #endif
-  dasm_put(Dst, 2980, DISPATCH_GL(hookmask), HOOK_ACTIVE, GG_DISP2STATIC, DISPATCH_GL(hookmask), DISPATCH_GL(hookcount), HOOK_ACTIVE, LUA_MASKLINE|LUA_MASKCOUNT, DISPATCH_GL(hookcount), LUA_MASKLINE, DISPATCH_GOT(lj_dispatch_ins), Dt1(->base), Dt1(->base));
-  dasm_put(Dst, 3028, GG_DISP2STATIC, -24+LJ_ENDIAN_SELECT(0,4));
+  dasm_put(Dst, 2981, DISPATCH_GL(hookmask), HOOK_ACTIVE, GG_DISP2STATIC, DISPATCH_GL(hookmask), DISPATCH_GL(hookcount), HOOK_ACTIVE, LUA_MASKLINE|LUA_MASKCOUNT, DISPATCH_GL(hookcount), LUA_MASKLINE, DISPATCH_GOT(lj_dispatch_ins), Dt1(->base), Dt1(->base));
+  dasm_put(Dst, 3029, GG_DISP2STATIC, -24+LJ_ENDIAN_SELECT(0,4));
 #if LJ_HASJIT
-  dasm_put(Dst, 3047, LJ_ENDIAN_SELECT(-8,-4), GG_DISP2J, Dt7(->pc), DISPATCH_J(L), PC2PROTO(framesize), DISPATCH_GOT(lj_trace_hot), Dt1(->base), Dt1(->top));
+  dasm_put(Dst, 3048, LJ_ENDIAN_SELECT(-8,-4), GG_DISP2J, Dt7(->pc), DISPATCH_J(L), PC2PROTO(framesize), DISPATCH_GOT(lj_trace_hot), Dt1(->base), Dt1(->top));
 #endif
-  dasm_put(Dst, 3072);
+  dasm_put(Dst, 3073);
 #if LJ_HASJIT
-  dasm_put(Dst, 3074);
+  dasm_put(Dst, 3075);
 #endif
-  dasm_put(Dst, 3077);
+  dasm_put(Dst, 3078);
 #if LJ_HASJIT
-  dasm_put(Dst, 3080);
+  dasm_put(Dst, 3081);
 #endif
-  dasm_put(Dst, 3083, DISPATCH_GOT(lj_dispatch_call), Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top), LJ_ENDIAN_SELECT(-8,-4));
+  dasm_put(Dst, 3084, DISPATCH_GOT(lj_dispatch_call), Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top), LJ_ENDIAN_SELECT(-8,-4));
 #if LJ_HASJIT
-  dasm_put(Dst, 3107, -(16+32*8+32*4), 16+0*8, 16+32*8+0*4, 16+32*8+1*4, 16+2*8, 16+32*8+2*4, 16+32*8+3*4, 16+4*8, 16+32*8+4*4, 16+32*8+5*4, 16+6*8, 16+32*8+6*4, 16+32*8+7*4, 16+8*8, 16+32*8+8*4, 16+32*8+9*4, 16+10*8, 16+32*8+10*4, 16+32*8+11*4, 16+12*8, 16+32*8+12*4, 16+32*8+13*4, 16+14*8);
-  dasm_put(Dst, 3154, 16+32*8+14*4, 16+32*8+15*4, 16+16*8, 16+32*8+16*4, 16+32*8+17*4, 16+18*8, 16+32*8+18*4, 16+32*8+19*4, 16+20*8, 16+32*8+20*4, 16+32*8+21*4, 16+22*8, 16+32*8+22*4, 16+32*8+23*4, 16+24*8, 16+32*8+24*4, 16+32*8+25*4, 16+26*8, 16+32*8+26*4, 16+32*8+27*4, 16+28*8, 16+32*8+28*4, 16+30*8);
-  dasm_put(Dst, 3201, 16+32*8+30*4, 16+32*8+31*4, ~LJ_VMST_EXIT, 16+32*8+32*4, -GG_DISP2G-32768, DISPATCH_GL(vmstate), 16+32*8+29*4, DISPATCH_GL(jit_L), DISPATCH_GL(jit_base), DISPATCH_GOT(lj_trace_exit), DISPATCH_J(L), DISPATCH_J(parent), DISPATCH_J(exitno), GG_DISP2J, Dt1(->base), Dt1(->cframe), Dt1(->base));
+  dasm_put(Dst, 3108, -(16+32*8+32*4), 16+0*8, 16+32*8+0*4, 16+32*8+1*4, 16+2*8, 16+32*8+2*4, 16+32*8+3*4, 16+4*8, 16+32*8+4*4, 16+32*8+5*4, 16+6*8, 16+32*8+6*4, 16+32*8+7*4, 16+8*8, 16+32*8+8*4, 16+32*8+9*4, 16+10*8, 16+32*8+10*4, 16+32*8+11*4, 16+12*8, 16+32*8+12*4, 16+32*8+13*4, 16+14*8);
+  dasm_put(Dst, 3155, 16+32*8+14*4, 16+32*8+15*4, 16+16*8, 16+32*8+16*4, 16+32*8+17*4, 16+18*8, 16+32*8+18*4, 16+32*8+19*4, 16+20*8, 16+32*8+20*4, 16+32*8+21*4, 16+22*8, 16+32*8+22*4, 16+32*8+23*4, 16+24*8, 16+32*8+24*4, 16+32*8+25*4, 16+26*8, 16+32*8+26*4, 16+32*8+27*4, 16+28*8, 16+32*8+28*4, 16+30*8);
+  dasm_put(Dst, 3202, 16+32*8+30*4, 16+32*8+31*4, ~LJ_VMST_EXIT, 16+32*8+32*4, -GG_DISP2G-32768, DISPATCH_GL(vmstate), 16+32*8+29*4, DISPATCH_GL(jit_L), DISPATCH_GL(jit_base), DISPATCH_GOT(lj_trace_exit), DISPATCH_J(L), DISPATCH_J(parent), DISPATCH_J(exitno), GG_DISP2J, Dt1(->base), Dt1(->cframe), Dt1(->base));
 #endif
-  dasm_put(Dst, 3245);
+  dasm_put(Dst, 3246);
 #if LJ_HASJIT
-  dasm_put(Dst, 3247, -GG_DISP2G-32768, LJ_ENDIAN_SELECT(-8,-4), LJ_TNIL, Dt7(->pc), DISPATCH_GL(jit_L), PC2PROTO(k), DISPATCH_GL(vmstate), BC_FUNCF*4, DISPATCH_GOT(lj_err_throw));
+  dasm_put(Dst, 3248, -GG_DISP2G-32768, LJ_ENDIAN_SELECT(-8,-4), LJ_TNIL, Dt7(->pc), DISPATCH_GL(jit_L), PC2PROTO(k), DISPATCH_GL(vmstate), BC_FUNCF*4, DISPATCH_GOT(lj_err_throw));
 #endif
-  dasm_put(Dst, 3296);
+  dasm_put(Dst, 3297);
 #if LJ_HASJIT
-  dasm_put(Dst, 3344);
+  dasm_put(Dst, 3345);
 #endif
-  dasm_put(Dst, 3367);
+  dasm_put(Dst, 3368);
 #if LJ_HASFFI
 #define DtE(_V) (int)(ptrdiff_t)&(((CTState *)0)_V)
-  dasm_put(Dst, 3369, 72+9*4, 72+8*4, 24+5*8, 72+7*4, 72+6*4, 24+4*8, 72+5*4, 72+4*4, 24+3*8, 72+3*4, 72+2*4, 24+2*8, 72+1*4, 72+0*4, 24+1*8, 24+0*8, Dt2(->ctype_state), GG_G2DISP, DISPATCH_GOT(lj_ccallback_enter), DtE(->cb.slot), DtE(->cb.gpr[0]), DtE(->cb.gpr[1]), DtE(->cb.fpr[0]));
-  dasm_put(Dst, 3417, DtE(->cb.gpr[2]), DtE(->cb.gpr[3]), DtE(->cb.fpr[1]), 112+16, DtE(->cb.stack), Dt1(->base), Dt1(->top), LJ_ENDIAN_SELECT(-8,-4), ~LJ_VMST_INTERP, LJ_TNIL, DISPATCH_GL(vmstate), Dt7(->pc));
+  dasm_put(Dst, 3370, 72+9*4, 72+8*4, 24+5*8, 72+7*4, 72+6*4, 24+4*8, 72+5*4, 72+4*4, 24+3*8, 72+3*4, 72+2*4, 24+2*8, 72+1*4, 72+0*4, 24+1*8, 24+0*8, Dt2(->ctype_state), GG_G2DISP, DISPATCH_GOT(lj_ccallback_enter), DtE(->cb.slot), DtE(->cb.gpr[0]), DtE(->cb.gpr[1]), DtE(->cb.fpr[0]));
+  dasm_put(Dst, 3418, DtE(->cb.gpr[2]), DtE(->cb.gpr[3]), DtE(->cb.fpr[1]), 112+16, DtE(->cb.stack), Dt1(->base), Dt1(->top), LJ_ENDIAN_SELECT(-8,-4), ~LJ_VMST_INTERP, LJ_TNIL, DISPATCH_GL(vmstate), Dt7(->pc));
 #endif
-  dasm_put(Dst, 3461);
+  dasm_put(Dst, 3462);
 #if LJ_HASFFI
-  dasm_put(Dst, 3463, DISPATCH_GOT(lj_ccallback_leave), DISPATCH_GL(ctype_state), Dt1(->base), Dt1(->top), DtE(->L), DtE(->cb.gpr[0]), DtE(->cb.fpr[0]), DtE(->cb.gpr[1]), DtE(->cb.fpr[1]));
+  dasm_put(Dst, 3464, DISPATCH_GOT(lj_ccallback_leave), DISPATCH_GL(ctype_state), Dt1(->base), Dt1(->top), DtE(->L), DtE(->cb.gpr[0]), DtE(->cb.fpr[0]), DtE(->cb.gpr[1]), DtE(->cb.fpr[1]));
 #endif
-  dasm_put(Dst, 3487);
+  dasm_put(Dst, 3488);
 #if LJ_HASFFI
 #define DtF(_V) (int)(ptrdiff_t)&(((CCallState *)0)_V)
-  dasm_put(Dst, 3489, DtF(->spadj), DtF(->nsp), offsetof(CCallState, stack), DtF(->func), DtF(->gpr[1]), DtF(->gpr[2]), DtF(->gpr[3]), DtF(->fpr[0]), DtF(->fpr[1]), DtF(->gpr[0]), DtF(->gpr[0]), DtF(->gpr[1]), DtF(->fpr[0]), DtF(->fpr[1]));
+  dasm_put(Dst, 3490, DtF(->spadj), DtF(->nsp), offsetof(CCallState, stack), DtF(->func), DtF(->gpr[1]), DtF(->gpr[2]), DtF(->gpr[3]), DtF(->fpr[0]), DtF(->fpr[1]), DtF(->gpr[0]), DtF(->gpr[0]), DtF(->gpr[1]), DtF(->fpr[0]), DtF(->fpr[1]));
 #endif
 }
 
@@ -6788,7 +6789,7 @@ static void build_subroutines(BuildCtx *ctx)
 static void build_ins(BuildCtx *ctx, BCOp op, int defop)
 {
   int vk = 0;
-  dasm_put(Dst, 3545, defop);
+  dasm_put(Dst, 3546, defop);
 
   switch (op) {
 
@@ -6797,138 +6798,138 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
   /* Remember: all ops branch for a true comparison, fall through otherwise. */
 
   case BC_ISLT: case BC_ISGE: case BC_ISLE: case BC_ISGT:
-    dasm_put(Dst, 3547, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, LJ_ENDIAN_SELECT(2,0), (-(BCBIAS_J*4 >> 16) & 65535));
+    dasm_put(Dst, 3548, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, LJ_ENDIAN_SELECT(2,0), (-(BCBIAS_J*4 >> 16) & 65535));
     if (op == BC_ISLT || op == BC_ISGE) {
-      dasm_put(Dst, 3570);
+      dasm_put(Dst, 3571);
     } else {
-      dasm_put(Dst, 3572);
+      dasm_put(Dst, 3573);
     }
     if (op == BC_ISLT || op == BC_ISLE) {
-      dasm_put(Dst, 3574);
+      dasm_put(Dst, 3575);
     } else {
-      dasm_put(Dst, 3576);
+      dasm_put(Dst, 3577);
     }
-    dasm_put(Dst, 3578);
+    dasm_put(Dst, 3579);
     break;
 
   case BC_ISEQV: case BC_ISNEV:
     vk = op == BC_ISEQV;
-    dasm_put(Dst, 3592, LJ_ENDIAN_SELECT(4,0), -4+LJ_ENDIAN_SELECT(2,0), LJ_ENDIAN_SELECT(4,0), (-(BCBIAS_J*4 >> 16) & 65535), LJ_TISNUM, LJ_TISNUM);
+    dasm_put(Dst, 3593, LJ_ENDIAN_SELECT(4,0), -4+LJ_ENDIAN_SELECT(2,0), LJ_ENDIAN_SELECT(4,0), (-(BCBIAS_J*4 >> 16) & 65535), LJ_TISNUM, LJ_TISNUM);
     if (vk) {
-      dasm_put(Dst, 3616);
+      dasm_put(Dst, 3617);
     } else {
-      dasm_put(Dst, 3618);
+      dasm_put(Dst, 3619);
     }
-    dasm_put(Dst, 3620, LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(0,4));
+    dasm_put(Dst, 3621, LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(0,4));
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3639, LJ_TCDATA);
+      dasm_put(Dst, 3640, LJ_TCDATA);
     }
-    dasm_put(Dst, 3644, LJ_TISPRI);
+    dasm_put(Dst, 3645, LJ_TISPRI);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3647);
+      dasm_put(Dst, 3648);
     }
-    dasm_put(Dst, 3650, LJ_TISTABUD+1);
+    dasm_put(Dst, 3651, LJ_TISTABUD+1);
     if (vk) {
-      dasm_put(Dst, 3661);
+      dasm_put(Dst, 3662);
     } else {
-      dasm_put(Dst, 3663);
+      dasm_put(Dst, 3664);
     }
-    dasm_put(Dst, 3665, Dt6(->metatable), Dt6(->nomm), 1<<MM_eq, 1-vk);
+    dasm_put(Dst, 3666, Dt6(->metatable), Dt6(->nomm), 1<<MM_eq, 1-vk);
     break;
 
   case BC_ISEQS: case BC_ISNES:
     vk = op == BC_ISEQS;
-    dasm_put(Dst, 3682, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), -4+LJ_ENDIAN_SELECT(2,0));
+    dasm_put(Dst, 3683, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), -4+LJ_ENDIAN_SELECT(2,0));
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3693, LJ_TCDATA);
+      dasm_put(Dst, 3694, LJ_TCDATA);
     }
-    dasm_put(Dst, 3698, -LJ_TSTR, (-(BCBIAS_J*4 >> 16) & 65535));
+    dasm_put(Dst, 3699, -LJ_TSTR, (-(BCBIAS_J*4 >> 16) & 65535));
     if (vk) {
-      dasm_put(Dst, 3708);
+      dasm_put(Dst, 3709);
     } else {
-      dasm_put(Dst, 3710);
+      dasm_put(Dst, 3711);
     }
-    dasm_put(Dst, 3712);
+    dasm_put(Dst, 3713);
     break;
 
   case BC_ISEQN: case BC_ISNEN:
     vk = op == BC_ISEQN;
-    dasm_put(Dst, 3725, LJ_ENDIAN_SELECT(4,0), -4+LJ_ENDIAN_SELECT(2,0), (-(BCBIAS_J*4 >> 16) & 65535), LJ_TISNUM);
+    dasm_put(Dst, 3726, LJ_ENDIAN_SELECT(4,0), -4+LJ_ENDIAN_SELECT(2,0), (-(BCBIAS_J*4 >> 16) & 65535), LJ_TISNUM);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3740);
+      dasm_put(Dst, 3741);
     } else {
-      dasm_put(Dst, 3743);
+      dasm_put(Dst, 3744);
     }
-    dasm_put(Dst, 3746);
+    dasm_put(Dst, 3747);
     if (vk) {
-      dasm_put(Dst, 3749);
+      dasm_put(Dst, 3750);
     } else {
-      dasm_put(Dst, 3753);
+      dasm_put(Dst, 3754);
     }
-    dasm_put(Dst, 3757);
+    dasm_put(Dst, 3758);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3769, LJ_TCDATA);
+      dasm_put(Dst, 3770, LJ_TCDATA);
     }
     break;
 
   case BC_ISEQP: case BC_ISNEP:
     vk = op == BC_ISEQP;
-    dasm_put(Dst, 3779, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(2,0));
+    dasm_put(Dst, 3780, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(2,0));
     if (LJ_HASFFI) {
-      dasm_put(Dst, 3788, LJ_TCDATA);
+      dasm_put(Dst, 3789, LJ_TCDATA);
     }
-    dasm_put(Dst, 3793, (-(BCBIAS_J*4 >> 16) & 65535));
+    dasm_put(Dst, 3794, (-(BCBIAS_J*4 >> 16) & 65535));
     if (vk) {
-      dasm_put(Dst, 3799);
+      dasm_put(Dst, 3800);
     } else {
-      dasm_put(Dst, 3801);
+      dasm_put(Dst, 3802);
     }
-    dasm_put(Dst, 3803);
+    dasm_put(Dst, 3804);
     break;
 
   /* -- Unary test and copy ops ------------------------------------------- */
 
   case BC_ISTC: case BC_ISFC: case BC_IST: case BC_ISF:
-    dasm_put(Dst, 3816, LJ_ENDIAN_SELECT(2,0), LJ_ENDIAN_SELECT(4,0));
+    dasm_put(Dst, 3817, LJ_ENDIAN_SELECT(2,0), LJ_ENDIAN_SELECT(4,0));
     if (op == BC_IST || op == BC_ISF) {
-      dasm_put(Dst, 3823, LJ_TISTRUECOND, (-(BCBIAS_J*4 >> 16) & 65535));
+      dasm_put(Dst, 3824, LJ_TISTRUECOND, (-(BCBIAS_J*4 >> 16) & 65535));
       if (op == BC_IST) {
-        dasm_put(Dst, 3830);
+        dasm_put(Dst, 3831);
       } else {
-        dasm_put(Dst, 3832);
+        dasm_put(Dst, 3833);
       }
-      dasm_put(Dst, 3834);
+      dasm_put(Dst, 3835);
     } else {
-      dasm_put(Dst, 3836, LJ_TISTRUECOND);
+      dasm_put(Dst, 3837, LJ_TISTRUECOND);
       if (op == BC_ISTC) {
-        dasm_put(Dst, 3840);
+        dasm_put(Dst, 3841);
       } else {
-        dasm_put(Dst, 3843);
+        dasm_put(Dst, 3844);
       }
-      dasm_put(Dst, 3846, (-(BCBIAS_J*4 >> 16) & 65535));
+      dasm_put(Dst, 3847, (-(BCBIAS_J*4 >> 16) & 65535));
     }
-    dasm_put(Dst, 3855);
+    dasm_put(Dst, 3856);
     break;
 
   /* -- Unary ops --------------------------------------------------------- */
 
   case BC_MOV:
-    dasm_put(Dst, 3867);
+    dasm_put(Dst, 3868);
     break;
   case BC_NOT:
-    dasm_put(Dst, 3883, LJ_ENDIAN_SELECT(4,0), LJ_TFALSE, LJ_TISTRUECOND, LJ_TTRUE, LJ_ENDIAN_SELECT(4,0));
+    dasm_put(Dst, 3884, LJ_ENDIAN_SELECT(4,0), LJ_TFALSE, LJ_TISTRUECOND, LJ_TTRUE, LJ_ENDIAN_SELECT(4,0));
     break;
   case BC_UNM:
-    dasm_put(Dst, 3907, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 3908, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
     break;
   case BC_LEN:
-    dasm_put(Dst, 3930, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_TSTR, LJ_TTAB, Dt5(->len));
+    dasm_put(Dst, 3931, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_TSTR, LJ_TTAB, Dt5(->len));
 #ifdef LUAJIT_ENABLE_LUA52COMPAT
-    dasm_put(Dst, 3964, Dt6(->metatable));
+    dasm_put(Dst, 3965, Dt6(->metatable));
 #endif
-    dasm_put(Dst, 3971, DISPATCH_GOT(lj_tab_len));
+    dasm_put(Dst, 3972, DISPATCH_GOT(lj_tab_len));
 #ifdef LUAJIT_ENABLE_LUA52COMPAT
-    dasm_put(Dst, 3980, Dt6(->nomm), 1<<MM_len);
+    dasm_put(Dst, 3981, Dt6(->nomm), 1<<MM_len);
 #endif
     break;
 
@@ -6937,273 +6938,273 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
 
   case BC_ADDVN: case BC_ADDNV: case BC_ADDVV:
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
-    dasm_put(Dst, 3992);
+    dasm_put(Dst, 3993);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 3996, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 3997, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     case 1:
-    dasm_put(Dst, 4005, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4006, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     default:
-    dasm_put(Dst, 4014, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
+    dasm_put(Dst, 4015, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
       break;
     }
-    dasm_put(Dst, 4028);
+    dasm_put(Dst, 4029);
     break;
   case BC_SUBVN: case BC_SUBNV: case BC_SUBVV:
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
-    dasm_put(Dst, 4045);
+    dasm_put(Dst, 4046);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 4049, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4050, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     case 1:
-    dasm_put(Dst, 4058, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4059, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     default:
-    dasm_put(Dst, 4067, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
+    dasm_put(Dst, 4068, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
       break;
     }
-    dasm_put(Dst, 4081);
+    dasm_put(Dst, 4082);
     break;
   case BC_MULVN: case BC_MULNV: case BC_MULVV:
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
-    dasm_put(Dst, 4098);
+    dasm_put(Dst, 4099);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 4102, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4103, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     case 1:
-    dasm_put(Dst, 4111, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4112, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     default:
-    dasm_put(Dst, 4120, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
+    dasm_put(Dst, 4121, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
       break;
     }
-    dasm_put(Dst, 4134);
+    dasm_put(Dst, 4135);
     break;
   case BC_DIVVN: case BC_DIVNV: case BC_DIVVV:
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
-    dasm_put(Dst, 4151);
+    dasm_put(Dst, 4152);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 4155, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4156, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     case 1:
-    dasm_put(Dst, 4164, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4165, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     default:
-    dasm_put(Dst, 4173, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
+    dasm_put(Dst, 4174, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
       break;
     }
-    dasm_put(Dst, 4187);
+    dasm_put(Dst, 4188);
     break;
   case BC_MODVN:
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
-    dasm_put(Dst, 4204);
+    dasm_put(Dst, 4205);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 4208, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4209, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     case 1:
-    dasm_put(Dst, 4217, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4218, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     default:
-    dasm_put(Dst, 4226, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
+    dasm_put(Dst, 4227, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
       break;
     }
-    dasm_put(Dst, 4240);
+    dasm_put(Dst, 4241);
     break;
   case BC_MODNV: case BC_MODVV:
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
-    dasm_put(Dst, 4262);
+    dasm_put(Dst, 4263);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 4266, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4267, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     case 1:
-    dasm_put(Dst, 4275, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
+    dasm_put(Dst, 4276, LJ_ENDIAN_SELECT(4,0), LJ_TISNUM);
       break;
     default:
-    dasm_put(Dst, 4284, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
+    dasm_put(Dst, 4285, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM);
       break;
     }
-    dasm_put(Dst, 4298);
+    dasm_put(Dst, 4299);
     break;
   case BC_POW:
-    dasm_put(Dst, 4305, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, DISPATCH_GOT(pow));
+    dasm_put(Dst, 4306, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, DISPATCH_GOT(pow));
     break;
 
   case BC_CAT:
-    dasm_put(Dst, 4341, Dt1(->base), DISPATCH_GOT(lj_meta_cat), Dt1(->base));
+    dasm_put(Dst, 4342, Dt1(->base), DISPATCH_GOT(lj_meta_cat), Dt1(->base));
     break;
 
   /* -- Constant ops ------------------------------------------------------ */
 
   case BC_KSTR:
-    dasm_put(Dst, 4376, LJ_TSTR, LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0));
+    dasm_put(Dst, 4377, LJ_TSTR, LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0));
     break;
   case BC_KCDATA:
 #if LJ_HASFFI
-    dasm_put(Dst, 4398, LJ_TCDATA, LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0));
+    dasm_put(Dst, 4399, LJ_TCDATA, LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0));
 #endif
     break;
   case BC_KSHORT:
-    dasm_put(Dst, 4420);
+    dasm_put(Dst, 4421);
     break;
   case BC_KNUM:
-    dasm_put(Dst, 4437);
+    dasm_put(Dst, 4438);
     break;
   case BC_KPRI:
-    dasm_put(Dst, 4453, LJ_ENDIAN_SELECT(4,0));
+    dasm_put(Dst, 4454, LJ_ENDIAN_SELECT(4,0));
     break;
   case BC_KNIL:
-    dasm_put(Dst, 4470, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0));
+    dasm_put(Dst, 4471, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0));
     break;
 
   /* -- Upvalue and function ops ------------------------------------------ */
 
   case BC_UGET:
-    dasm_put(Dst, 4494, LJ_ENDIAN_SELECT(-8,-4), Dt7(->uvptr), DtA(->v));
+    dasm_put(Dst, 4495, LJ_ENDIAN_SELECT(-8,-4), Dt7(->uvptr), DtA(->v));
     break;
   case BC_USETV:
-    dasm_put(Dst, 4517, LJ_ENDIAN_SELECT(-8,-4), Dt7(->uvptr), DtA(->marked), DtA(->v), LJ_GC_BLACK, DtA(->closed), LJ_ENDIAN_SELECT(4,0), LJ_GC_BLACK|1, -(LJ_TISNUM+1), LJ_TISGCV - (LJ_TISNUM+1), LJ_ENDIAN_SELECT(0,4), Dt4(->gch.marked), LJ_GC_WHITES, DISPATCH_GOT(lj_gc_barrieruv), GG_DISP2G);
+    dasm_put(Dst, 4518, LJ_ENDIAN_SELECT(-8,-4), Dt7(->uvptr), DtA(->marked), DtA(->v), LJ_GC_BLACK, DtA(->closed), LJ_ENDIAN_SELECT(4,0), LJ_GC_BLACK|1, -(LJ_TISNUM+1), LJ_TISGCV - (LJ_TISNUM+1), LJ_ENDIAN_SELECT(0,4), Dt4(->gch.marked), LJ_GC_WHITES, DISPATCH_GOT(lj_gc_barrieruv), GG_DISP2G);
     break;
   case BC_USETS:
-    dasm_put(Dst, 4577, LJ_ENDIAN_SELECT(-8,-4), Dt7(->uvptr), DtA(->marked), DtA(->v), Dt5(->marked), LJ_GC_BLACK, DtA(->closed), LJ_TSTR, LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), LJ_GC_WHITES, DISPATCH_GOT(lj_gc_barrieruv), GG_DISP2G);
+    dasm_put(Dst, 4578, LJ_ENDIAN_SELECT(-8,-4), Dt7(->uvptr), DtA(->marked), DtA(->v), Dt5(->marked), LJ_GC_BLACK, DtA(->closed), LJ_TSTR, LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), LJ_GC_WHITES, DISPATCH_GOT(lj_gc_barrieruv), GG_DISP2G);
     break;
   case BC_USETN:
-    dasm_put(Dst, 4632, LJ_ENDIAN_SELECT(-8,-4), Dt7(->uvptr), DtA(->v));
+    dasm_put(Dst, 4633, LJ_ENDIAN_SELECT(-8,-4), Dt7(->uvptr), DtA(->v));
     break;
   case BC_USETP:
-    dasm_put(Dst, 4655, LJ_ENDIAN_SELECT(-8,-4), Dt7(->uvptr), DtA(->v), LJ_ENDIAN_SELECT(4,0));
+    dasm_put(Dst, 4656, LJ_ENDIAN_SELECT(-8,-4), Dt7(->uvptr), DtA(->v), LJ_ENDIAN_SELECT(4,0));
     break;
 
   case BC_UCLO:
-    dasm_put(Dst, 4679, Dt1(->openupval), (-(BCBIAS_J*4 >> 16) & 65535), DISPATCH_GOT(lj_func_closeuv), Dt1(->base), Dt1(->base));
+    dasm_put(Dst, 4680, Dt1(->openupval), (-(BCBIAS_J*4 >> 16) & 65535), DISPATCH_GOT(lj_func_closeuv), Dt1(->base), Dt1(->base));
     break;
 
   case BC_FNEW:
-    dasm_put(Dst, 4710, DISPATCH_GOT(lj_func_newL_gc), LJ_ENDIAN_SELECT(-8,-4), Dt1(->base), Dt1(->base), LJ_TFUNC, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4));
+    dasm_put(Dst, 4711, DISPATCH_GOT(lj_func_newL_gc), LJ_ENDIAN_SELECT(-8,-4), Dt1(->base), Dt1(->base), LJ_TFUNC, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4));
     break;
 
   /* -- Table ops --------------------------------------------------------- */
 
   case BC_TNEW:
   case BC_TDUP:
-    dasm_put(Dst, 4743, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), Dt1(->base));
+    dasm_put(Dst, 4744, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), Dt1(->base));
     if (op == BC_TNEW) {
-      dasm_put(Dst, 4755, DISPATCH_GOT(lj_tab_new));
+      dasm_put(Dst, 4756, DISPATCH_GOT(lj_tab_new));
     } else {
-      dasm_put(Dst, 4766, DISPATCH_GOT(lj_tab_dup));
+      dasm_put(Dst, 4767, DISPATCH_GOT(lj_tab_dup));
     }
-    dasm_put(Dst, 4774, Dt1(->base), LJ_TTAB, LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), DISPATCH_GOT(lj_gc_step_fixtop));
+    dasm_put(Dst, 4775, Dt1(->base), LJ_TTAB, LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), DISPATCH_GOT(lj_gc_step_fixtop));
     break;
 
   case BC_GGET:
   case BC_GSET:
-    dasm_put(Dst, 4804, LJ_ENDIAN_SELECT(-8,-4), Dt7(->env));
+    dasm_put(Dst, 4805, LJ_ENDIAN_SELECT(-8,-4), Dt7(->env));
     if (op == BC_GGET) {
-      dasm_put(Dst, 4812);
+      dasm_put(Dst, 4813);
     } else {
-      dasm_put(Dst, 4815);
+      dasm_put(Dst, 4816);
     }
-    dasm_put(Dst, 4818);
+    dasm_put(Dst, 4819);
     break;
 
   case BC_TGETV:
-    dasm_put(Dst, 4820, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_TTAB, LJ_TISNUM, LJ_TSTR, Dt6(->asize), Dt6(->array), LJ_ENDIAN_SELECT(4,0), Dt6(->metatable), Dt6(->nomm), 1<<MM_index);
-    dasm_put(Dst, 4895, LJ_ENDIAN_SELECT(0,4));
+    dasm_put(Dst, 4821, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_TTAB, LJ_TISNUM, LJ_TSTR, Dt6(->asize), Dt6(->array), LJ_ENDIAN_SELECT(4,0), Dt6(->metatable), Dt6(->nomm), 1<<MM_index);
+    dasm_put(Dst, 4896, LJ_ENDIAN_SELECT(0,4));
     break;
   case BC_TGETS:
-    dasm_put(Dst, 4901, LJ_ENDIAN_SELECT(4,0), LJ_TTAB, LJ_ENDIAN_SELECT(0,4), Dt6(->hmask), Dt5(->hash), Dt6(->node), offsetof(Node, key)+LJ_ENDIAN_SELECT(4,0), offsetof(Node, key)+LJ_ENDIAN_SELECT(0,4), DtB(->next), offsetof(Node, val)+LJ_ENDIAN_SELECT(4,0), -LJ_TSTR, Dt6(->metatable), offsetof(Node, val)+LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4));
-    dasm_put(Dst, 4970, LJ_TNIL, Dt6(->nomm), 1<<MM_index);
+    dasm_put(Dst, 4902, LJ_ENDIAN_SELECT(4,0), LJ_TTAB, LJ_ENDIAN_SELECT(0,4), Dt6(->hmask), Dt5(->hash), Dt6(->node), offsetof(Node, key)+LJ_ENDIAN_SELECT(4,0), offsetof(Node, key)+LJ_ENDIAN_SELECT(0,4), DtB(->next), offsetof(Node, val)+LJ_ENDIAN_SELECT(4,0), -LJ_TSTR, Dt6(->metatable), offsetof(Node, val)+LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4));
+    dasm_put(Dst, 4971, LJ_TNIL, Dt6(->nomm), 1<<MM_index);
     break;
   case BC_TGETB:
-    dasm_put(Dst, 4987, LJ_ENDIAN_SELECT(4,0), LJ_TTAB, LJ_ENDIAN_SELECT(0,4), Dt6(->asize), Dt6(->array), LJ_ENDIAN_SELECT(4,0), Dt6(->metatable), Dt6(->nomm), 1<<MM_index);
+    dasm_put(Dst, 4988, LJ_ENDIAN_SELECT(4,0), LJ_TTAB, LJ_ENDIAN_SELECT(0,4), Dt6(->asize), Dt6(->array), LJ_ENDIAN_SELECT(4,0), Dt6(->metatable), Dt6(->nomm), 1<<MM_index);
     break;
 
   case BC_TSETV:
-    dasm_put(Dst, 5044, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_TTAB, LJ_TISNUM, LJ_TSTR, Dt6(->asize), Dt6(->array), Dt6(->marked), LJ_ENDIAN_SELECT(4,0), LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex);
-    dasm_put(Dst, 5117, LJ_ENDIAN_SELECT(0,4), DISPATCH_GL(gc.grayagain), ~LJ_GC_BLACK & 255, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
+    dasm_put(Dst, 5045, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_TTAB, LJ_TISNUM, LJ_TSTR, Dt6(->asize), Dt6(->array), Dt6(->marked), LJ_ENDIAN_SELECT(4,0), LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex);
+    dasm_put(Dst, 5118, LJ_ENDIAN_SELECT(0,4), DISPATCH_GL(gc.grayagain), ~LJ_GC_BLACK & 255, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
     break;
   case BC_TSETS:
-    dasm_put(Dst, 5145, LJ_ENDIAN_SELECT(4,0), LJ_TTAB, LJ_ENDIAN_SELECT(0,4), Dt6(->hmask), Dt5(->hash), Dt6(->node), Dt6(->nomm), offsetof(Node, key)+LJ_ENDIAN_SELECT(4,0), offsetof(Node, key)+LJ_ENDIAN_SELECT(0,4), LJ_TSTR, DtB(->next), offsetof(Node, val)+LJ_ENDIAN_SELECT(4,0), Dt6(->marked), Dt6(->metatable), LJ_GC_BLACK);
-    dasm_put(Dst, 5203, DtB(->val), Dt6(->nomm), 1<<MM_newindex, Dt6(->metatable), DISPATCH_GL(tmptv), Dt6(->nomm), 1<<MM_newindex, LJ_TSTR, DISPATCH_GOT(lj_tab_newkey), LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), Dt1(->base), Dt1(->base));
-    dasm_put(Dst, 5265, DISPATCH_GL(gc.grayagain), ~LJ_GC_BLACK & 255, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
+    dasm_put(Dst, 5146, LJ_ENDIAN_SELECT(4,0), LJ_TTAB, LJ_ENDIAN_SELECT(0,4), Dt6(->hmask), Dt5(->hash), Dt6(->node), Dt6(->nomm), offsetof(Node, key)+LJ_ENDIAN_SELECT(4,0), offsetof(Node, key)+LJ_ENDIAN_SELECT(0,4), LJ_TSTR, DtB(->next), offsetof(Node, val)+LJ_ENDIAN_SELECT(4,0), Dt6(->marked), Dt6(->metatable), LJ_GC_BLACK);
+    dasm_put(Dst, 5204, DtB(->val), Dt6(->nomm), 1<<MM_newindex, Dt6(->metatable), DISPATCH_GL(tmptv), Dt6(->nomm), 1<<MM_newindex, LJ_TSTR, DISPATCH_GOT(lj_tab_newkey), LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), Dt1(->base), Dt1(->base));
+    dasm_put(Dst, 5266, DISPATCH_GL(gc.grayagain), ~LJ_GC_BLACK & 255, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
     break;
   case BC_TSETB:
-    dasm_put(Dst, 5282, LJ_ENDIAN_SELECT(4,0), LJ_TTAB, LJ_ENDIAN_SELECT(0,4), Dt6(->asize), Dt6(->array), LJ_ENDIAN_SELECT(4,0), Dt6(->marked), LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, DISPATCH_GL(gc.grayagain));
-    dasm_put(Dst, 5349, ~LJ_GC_BLACK & 255, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
+    dasm_put(Dst, 5283, LJ_ENDIAN_SELECT(4,0), LJ_TTAB, LJ_ENDIAN_SELECT(0,4), Dt6(->asize), Dt6(->array), LJ_ENDIAN_SELECT(4,0), Dt6(->marked), LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, DISPATCH_GL(gc.grayagain));
+    dasm_put(Dst, 5350, ~LJ_GC_BLACK & 255, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
     break;
 
   case BC_TSETM:
-    dasm_put(Dst, 5360, -8+LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(0,4), Dt6(->asize), Dt6(->marked), Dt6(->array), LJ_GC_BLACK, DISPATCH_GOT(lj_tab_reasize), Dt1(->base), Dt1(->base), DISPATCH_GL(gc.grayagain), ~LJ_GC_BLACK & 255, DISPATCH_GL(gc.grayagain), Dt6(->marked));
-    dasm_put(Dst, 5433, Dt6(->gclist));
+    dasm_put(Dst, 5361, -8+LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(0,4), Dt6(->asize), Dt6(->marked), Dt6(->array), LJ_GC_BLACK, DISPATCH_GOT(lj_tab_reasize), Dt1(->base), Dt1(->base), DISPATCH_GL(gc.grayagain), ~LJ_GC_BLACK & 255, DISPATCH_GL(gc.grayagain), Dt6(->marked));
+    dasm_put(Dst, 5434, Dt6(->gclist));
     break;
 
   /* -- Calls and vararg handling ----------------------------------------- */
 
   case BC_CALLM:
-    dasm_put(Dst, 5438);
+    dasm_put(Dst, 5439);
     break;
   case BC_CALL:
-    dasm_put(Dst, 5443, LJ_TFUNC, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(-4,-8), Dt7(->pc));
+    dasm_put(Dst, 5444, LJ_TFUNC, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(-4,-8), Dt7(->pc));
     break;
 
   case BC_CALLMT:
-    dasm_put(Dst, 5472);
+    dasm_put(Dst, 5473);
     break;
   case BC_CALLT:
-    dasm_put(Dst, 5474, LJ_TFUNC, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(-4,-8), FRAME_TYPE, Dt7(->ffid), FRAME_VARG, LJ_ENDIAN_SELECT(-8,-4), Dt7(->pc), -8+LJ_ENDIAN_SELECT(-8,-4), Dt7(->pc));
-    dasm_put(Dst, 5543, PC2PROTO(k), FRAME_TYPEP, LJ_ENDIAN_SELECT(-4,-8), FRAME_TYPE);
+    dasm_put(Dst, 5475, LJ_TFUNC, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(-4,-8), FRAME_TYPE, Dt7(->ffid), FRAME_VARG, LJ_ENDIAN_SELECT(-8,-4), Dt7(->pc), -8+LJ_ENDIAN_SELECT(-8,-4), Dt7(->pc));
+    dasm_put(Dst, 5544, PC2PROTO(k), FRAME_TYPEP, LJ_ENDIAN_SELECT(-4,-8), FRAME_TYPE);
     break;
 
   case BC_ITERC:
-    dasm_put(Dst, 5559, LJ_TFUNC, -24+LJ_ENDIAN_SELECT(4,0), -24+LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(-4,-8), Dt7(->pc));
+    dasm_put(Dst, 5560, LJ_TFUNC, -24+LJ_ENDIAN_SELECT(4,0), -24+LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(-4,-8), Dt7(->pc));
     break;
 
   case BC_ITERN:
 #if LJ_HASJIT
 #endif
-    dasm_put(Dst, 5594, -16+LJ_ENDIAN_SELECT(0,4), -8+LJ_ENDIAN_SELECT(0,4), Dt6(->asize), Dt6(->array), LJ_ENDIAN_SELECT(4,0), -4+LJ_ENDIAN_SELECT(2,0), (-(BCBIAS_J*4 >> 16) & 65535), -8+LJ_ENDIAN_SELECT(0,4), Dt6(->hmask), Dt6(->node), LJ_ENDIAN_SELECT(4,0), -4+LJ_ENDIAN_SELECT(2,0), DtB(->key), (-(BCBIAS_J*4 >> 16) & 65535));
-    dasm_put(Dst, 5676, -8+LJ_ENDIAN_SELECT(0,4));
+    dasm_put(Dst, 5595, -16+LJ_ENDIAN_SELECT(0,4), -8+LJ_ENDIAN_SELECT(0,4), Dt6(->asize), Dt6(->array), LJ_ENDIAN_SELECT(4,0), -4+LJ_ENDIAN_SELECT(2,0), (-(BCBIAS_J*4 >> 16) & 65535), -8+LJ_ENDIAN_SELECT(0,4), Dt6(->hmask), Dt6(->node), LJ_ENDIAN_SELECT(4,0), -4+LJ_ENDIAN_SELECT(2,0), DtB(->key), (-(BCBIAS_J*4 >> 16) & 65535));
+    dasm_put(Dst, 5677, -8+LJ_ENDIAN_SELECT(0,4));
     break;
 
   case BC_ISNEXT:
-    dasm_put(Dst, 5679, -24+LJ_ENDIAN_SELECT(4,0), -24+LJ_ENDIAN_SELECT(0,4), -16+LJ_ENDIAN_SELECT(4,0), -8+LJ_ENDIAN_SELECT(4,0), LJ_TFUNC, -LJ_TTAB, Dt8(->ffid), -LJ_TNIL, -FF_next_N, (-(BCBIAS_J*4 >> 16) & 65535), -8+LJ_ENDIAN_SELECT(0,4), BC_JMP, BC_ITERC, -4+LJ_ENDIAN_SELECT(0,3), LJ_ENDIAN_SELECT(0,3));
+    dasm_put(Dst, 5680, -24+LJ_ENDIAN_SELECT(4,0), -24+LJ_ENDIAN_SELECT(0,4), -16+LJ_ENDIAN_SELECT(4,0), -8+LJ_ENDIAN_SELECT(4,0), LJ_TFUNC, -LJ_TTAB, Dt8(->ffid), -LJ_TNIL, -FF_next_N, (-(BCBIAS_J*4 >> 16) & 65535), -8+LJ_ENDIAN_SELECT(0,4), BC_JMP, BC_ITERC, -4+LJ_ENDIAN_SELECT(0,3), LJ_ENDIAN_SELECT(0,3));
     break;
 
   case BC_VARG:
-    dasm_put(Dst, 5736, LJ_ENDIAN_SELECT(-4,-8), FRAME_VARG, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), Dt1(->maxstack), DISPATCH_GOT(lj_state_growstack), Dt1(->top), Dt1(->base), Dt1(->base));
-    dasm_put(Dst, 5823);
+    dasm_put(Dst, 5737, LJ_ENDIAN_SELECT(-4,-8), FRAME_VARG, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), Dt1(->maxstack), DISPATCH_GOT(lj_state_growstack), Dt1(->top), Dt1(->base), Dt1(->base));
+    dasm_put(Dst, 5824);
     break;
 
   /* -- Returns ----------------------------------------------------------- */
 
   case BC_RETM:
-    dasm_put(Dst, 5825);
+    dasm_put(Dst, 5826);
     break;
 
   case BC_RET:
-    dasm_put(Dst, 5827, LJ_ENDIAN_SELECT(-4,-8), FRAME_TYPE, FRAME_VARG, LJ_ENDIAN_SELECT(-8,-4), Dt7(->pc), PC2PROTO(k), LJ_ENDIAN_SELECT(4,0), FRAME_TYPEP, LJ_ENDIAN_SELECT(-4,-8));
+    dasm_put(Dst, 5828, LJ_ENDIAN_SELECT(-4,-8), FRAME_TYPE, FRAME_VARG, LJ_ENDIAN_SELECT(-8,-4), Dt7(->pc), PC2PROTO(k), LJ_ENDIAN_SELECT(4,0), FRAME_TYPEP, LJ_ENDIAN_SELECT(-4,-8));
     break;
 
   case BC_RET0: case BC_RET1:
-    dasm_put(Dst, 5899, LJ_ENDIAN_SELECT(-4,-8), FRAME_TYPE, FRAME_VARG);
+    dasm_put(Dst, 5900, LJ_ENDIAN_SELECT(-4,-8), FRAME_TYPE, FRAME_VARG);
     if (op == BC_RET1) {
-      dasm_put(Dst, 5912);
+      dasm_put(Dst, 5913);
     }
-    dasm_put(Dst, 5914);
+    dasm_put(Dst, 5915);
     if (op == BC_RET1) {
-      dasm_put(Dst, 5919);
+      dasm_put(Dst, 5920);
     }
-    dasm_put(Dst, 5921, LJ_ENDIAN_SELECT(-8,-4), Dt7(->pc), PC2PROTO(k));
+    dasm_put(Dst, 5922, LJ_ENDIAN_SELECT(-8,-4), Dt7(->pc), PC2PROTO(k));
     if (op == BC_RET1) {
-      dasm_put(Dst, 5949, LJ_ENDIAN_SELECT(4,0));
+      dasm_put(Dst, 5950, LJ_ENDIAN_SELECT(4,0));
     } else {
-      dasm_put(Dst, 5952, -8+LJ_ENDIAN_SELECT(4,0));
+      dasm_put(Dst, 5953, -8+LJ_ENDIAN_SELECT(4,0));
     }
     break;
 
@@ -7211,7 +7212,7 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
 
   case BC_FORL:
 #if LJ_HASJIT
-    dasm_put(Dst, 5955, GG_DISP2HOT, -HOTCOUNT_LOOP, GG_DISP2HOT);
+    dasm_put(Dst, 5956, GG_DISP2HOT, -HOTCOUNT_LOOP, GG_DISP2HOT);
 #endif
     break;
 
@@ -7223,35 +7224,35 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
   case BC_FORI:
   case BC_IFORL:
     vk = (op == BC_IFORL || op == BC_JFORL);
-    dasm_put(Dst, 5967);
+    dasm_put(Dst, 5968);
     if (vk) {
-      dasm_put(Dst, 5969, FORL_IDX*8, FORL_STEP*8, FORL_STOP*8, FORL_STEP*8+LJ_ENDIAN_SELECT(4,0), FORL_IDX*8);
+      dasm_put(Dst, 5970, FORL_IDX*8, FORL_STEP*8, FORL_STOP*8, FORL_STEP*8+LJ_ENDIAN_SELECT(4,0), FORL_IDX*8);
     } else {
-      dasm_put(Dst, 5981, FORL_IDX*8+LJ_ENDIAN_SELECT(4,0), FORL_STEP*8+LJ_ENDIAN_SELECT(4,0), FORL_STOP*8+LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, LJ_TISNUM, FORL_IDX*8, FORL_STOP*8);
+      dasm_put(Dst, 5982, FORL_IDX*8+LJ_ENDIAN_SELECT(4,0), FORL_STEP*8+LJ_ENDIAN_SELECT(4,0), FORL_STOP*8+LJ_ENDIAN_SELECT(4,0), LJ_TISNUM, LJ_TISNUM, LJ_TISNUM, FORL_IDX*8, FORL_STOP*8);
     }
     if (op != BC_JFORL) {
-      dasm_put(Dst, 6002, (-(BCBIAS_J*4 >> 16) & 65535));
+      dasm_put(Dst, 6003, (-(BCBIAS_J*4 >> 16) & 65535));
     }
-    dasm_put(Dst, 6006, FORL_EXT*8);
+    dasm_put(Dst, 6007, FORL_EXT*8);
     if (op == BC_JFORI) {
-      dasm_put(Dst, 6011, -4+LJ_ENDIAN_SELECT(2,0), BC_JLOOP);
+      dasm_put(Dst, 6012, -4+LJ_ENDIAN_SELECT(2,0), BC_JLOOP);
     } else if (op == BC_JFORL) {
-      dasm_put(Dst, 6025, BC_JLOOP);
+      dasm_put(Dst, 6026, BC_JLOOP);
     } else {
-      dasm_put(Dst, 6035);
+      dasm_put(Dst, 6036);
       if (op == BC_FORI) {
-        dasm_put(Dst, 6039);
+        dasm_put(Dst, 6040);
       } else {
-        dasm_put(Dst, 6042);
+        dasm_put(Dst, 6043);
       }
-      dasm_put(Dst, 6045);
+      dasm_put(Dst, 6046);
     }
-    dasm_put(Dst, 6048);
+    dasm_put(Dst, 6049);
     break;
 
   case BC_ITERL:
 #if LJ_HASJIT
-    dasm_put(Dst, 6060, GG_DISP2HOT, -HOTCOUNT_LOOP, GG_DISP2HOT);
+    dasm_put(Dst, 6061, GG_DISP2HOT, -HOTCOUNT_LOOP, GG_DISP2HOT);
 #endif
     break;
 
@@ -7260,40 +7261,40 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
     break;
 #endif
   case BC_IITERL:
-    dasm_put(Dst, 6072, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4));
+    dasm_put(Dst, 6073, LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4));
     if (op == BC_JITERL) {
-      dasm_put(Dst, 6080, -8+LJ_ENDIAN_SELECT(4,0), BC_JLOOP, -8+LJ_ENDIAN_SELECT(0,4));
+      dasm_put(Dst, 6081, -8+LJ_ENDIAN_SELECT(4,0), BC_JLOOP, -8+LJ_ENDIAN_SELECT(0,4));
     } else {
-      dasm_put(Dst, 6087, (-(BCBIAS_J*4 >> 16) & 65535), -8+LJ_ENDIAN_SELECT(4,0), -8+LJ_ENDIAN_SELECT(0,4));
+      dasm_put(Dst, 6088, (-(BCBIAS_J*4 >> 16) & 65535), -8+LJ_ENDIAN_SELECT(4,0), -8+LJ_ENDIAN_SELECT(0,4));
     }
-    dasm_put(Dst, 6097);
+    dasm_put(Dst, 6098);
     break;
 
   case BC_LOOP:
 #if LJ_HASJIT
-    dasm_put(Dst, 6110, GG_DISP2HOT, -HOTCOUNT_LOOP, GG_DISP2HOT);
+    dasm_put(Dst, 6111, GG_DISP2HOT, -HOTCOUNT_LOOP, GG_DISP2HOT);
 #endif
     break;
 
   case BC_ILOOP:
-    dasm_put(Dst, 6122);
+    dasm_put(Dst, 6123);
     break;
 
   case BC_JLOOP:
 #if LJ_HASJIT
-    dasm_put(Dst, 6134, DISPATCH_J(trace), DISPATCH_GL(vmstate), DISPATCH_GL(jit_base), DISPATCH_GL(jit_L), DtD(->mcode), GG_DISP2G+32768);
+    dasm_put(Dst, 6135, DISPATCH_J(trace), DISPATCH_GL(vmstate), DISPATCH_GL(jit_base), DISPATCH_GL(jit_L), DtD(->mcode), GG_DISP2G+32768);
 #endif
     break;
 
   case BC_JMP:
-    dasm_put(Dst, 6152, (-(BCBIAS_J*4 >> 16) & 65535));
+    dasm_put(Dst, 6153, (-(BCBIAS_J*4 >> 16) & 65535));
     break;
 
   /* -- Function headers -------------------------------------------------- */
 
   case BC_FUNCF:
 #if LJ_HASJIT
-    dasm_put(Dst, 6169, GG_DISP2HOT, -HOTCOUNT_CALL, GG_DISP2HOT);
+    dasm_put(Dst, 6170, GG_DISP2HOT, -HOTCOUNT_CALL, GG_DISP2HOT);
 #endif
   case BC_FUNCV:  /* NYI: compiled vararg functions. */
     break;
@@ -7303,42 +7304,42 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
     break;
 #endif
   case BC_IFUNCF:
-    dasm_put(Dst, 6181, Dt1(->maxstack), -4+PC2PROTO(numparams), -4+PC2PROTO(k));
+    dasm_put(Dst, 6182, Dt1(->maxstack), -4+PC2PROTO(numparams), -4+PC2PROTO(k));
     if (op != BC_JFUNCF) {
-      dasm_put(Dst, 6192);
+      dasm_put(Dst, 6193);
     }
-    dasm_put(Dst, 6195);
+    dasm_put(Dst, 6196);
     if (op == BC_JFUNCF) {
-      dasm_put(Dst, 6201, BC_JLOOP);
+      dasm_put(Dst, 6202, BC_JLOOP);
     } else {
-      dasm_put(Dst, 6206);
+      dasm_put(Dst, 6207);
     }
-    dasm_put(Dst, 6216, LJ_ENDIAN_SELECT(4,0));
+    dasm_put(Dst, 6217, LJ_ENDIAN_SELECT(4,0));
     break;
 
   case BC_JFUNCV:
 #if !LJ_HASJIT
     break;
 #endif
-    dasm_put(Dst, 6223);
+    dasm_put(Dst, 6224);
     break;  /* NYI: compiled vararg functions. */
 
   case BC_IFUNCV:
-    dasm_put(Dst, 6225, Dt1(->maxstack), LJ_ENDIAN_SELECT(0,4), 8+FRAME_VARG, -4+PC2PROTO(k), LJ_ENDIAN_SELECT(4,0), -4+PC2PROTO(numparams), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), 8+LJ_ENDIAN_SELECT(0,4), 8+LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0));
+    dasm_put(Dst, 6226, Dt1(->maxstack), LJ_ENDIAN_SELECT(0,4), 8+FRAME_VARG, -4+PC2PROTO(k), LJ_ENDIAN_SELECT(4,0), -4+PC2PROTO(numparams), LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(0,4), 8+LJ_ENDIAN_SELECT(0,4), 8+LJ_ENDIAN_SELECT(4,0), LJ_ENDIAN_SELECT(4,0));
     break;
 
   case BC_FUNCC:
   case BC_FUNCCW:
     if (op == BC_FUNCC) {
-      dasm_put(Dst, 6280, Dt8(->f));
+      dasm_put(Dst, 6281, Dt8(->f));
     } else {
-      dasm_put(Dst, 6283, DISPATCH_GL(wrapf));
+      dasm_put(Dst, 6284, DISPATCH_GL(wrapf));
     }
-    dasm_put(Dst, 6286, Dt1(->maxstack), Dt1(->base), Dt1(->top), ~LJ_VMST_C);
+    dasm_put(Dst, 6287, Dt1(->maxstack), Dt1(->base), Dt1(->top), ~LJ_VMST_C);
     if (op == BC_FUNCCW) {
-      dasm_put(Dst, 6298, Dt8(->f));
+      dasm_put(Dst, 6299, Dt8(->f));
     }
-    dasm_put(Dst, 6301, DISPATCH_GL(vmstate), Dt1(->base), Dt1(->top), ~LJ_VMST_INTERP, LJ_ENDIAN_SELECT(-4,-8), DISPATCH_GL(vmstate));
+    dasm_put(Dst, 6302, DISPATCH_GL(vmstate), Dt1(->base), Dt1(->top), ~LJ_VMST_INTERP, LJ_ENDIAN_SELECT(-4,-8), DISPATCH_GL(vmstate));
     break;
 
   /* ---------------------------------------------------------------------- */
@@ -7358,7 +7359,7 @@ static int build_backend(BuildCtx *ctx)
 
   build_subroutines(ctx);
 
-  dasm_put(Dst, 6322);
+  dasm_put(Dst, 6323);
   for (op = 0; op < BC__MAX; op++)
     build_ins(ctx, (BCOp)op, op);
 
diff --git a/src/buildvm_ppc.dasc b/src/buildvm_ppc.dasc
index 027e75b0..49f92d0a 100644
--- a/src/buildvm_ppc.dasc
+++ b/src/buildvm_ppc.dasc
@@ -2189,6 +2189,7 @@ static void build_subroutines(BuildCtx *ctx)
   |  bne >3
   |  lwz INS, -4(PC)
   |  decode_RA8 TMP1, INS
+  |  addi TMP1, TMP1, 8
   |3:
   |  sub TMP2, BASE, TMP1
   |  b ->vm_call_dispatch               // Resolve again for tailcall.
diff --git a/src/buildvm_ppc.h b/src/buildvm_ppc.h
index 81285d63..ce0941ec 100644
--- a/src/buildvm_ppc.h
+++ b/src/buildvm_ppc.h
@@ -12,7 +12,7 @@
 #define DASM_SECTION_CODE_OP    0
 #define DASM_SECTION_CODE_SUB   1
 #define DASM_MAXSECTION         2
-static const unsigned int build_actionlist[7762] = {
+static const unsigned int build_actionlist[7763] = {
 0x00010001,
 0x00060014,
 0x72000000,
@@ -3624,6 +3624,7 @@ static const unsigned int build_actionlist[7762] = {
 0x00050803,
 0x80f0fffc,
 0x54e8dd78,
+0x39080008,
 0x0006000d,
 0x7d287050,
 0x48000000,
@@ -8512,59 +8513,59 @@ static void build_subroutines(BuildCtx *ctx)
     dasm_put(Dst, 3550);
   }
   dasm_put(Dst, 3558, Dt8(->f), 8*LUA_MINSTACK, Dt1(->maxstack), Dt1(->base), Dt1(->top), Dt1(->base), 31-3, Dt1(->top), Dt7(->pc), FRAME_TYPE, LUA_MINSTACK);
-  dasm_put(Dst, 3621, Dt1(->base), Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top));
+  dasm_put(Dst, 3622, Dt1(->base), Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top));
 #if LJ_HASJIT
-  dasm_put(Dst, 3647, DISPATCH_GL(hookmask), HOOK_VMEVENT, DISPATCH_GL(hookcount), HOOK_ACTIVE, LUA_MASKLINE|LUA_MASKCOUNT, DISPATCH_GL(hookcount));
+  dasm_put(Dst, 3648, DISPATCH_GL(hookmask), HOOK_VMEVENT, DISPATCH_GL(hookcount), HOOK_ACTIVE, LUA_MASKLINE|LUA_MASKCOUNT, DISPATCH_GL(hookcount));
 #endif
-  dasm_put(Dst, 3669, DISPATCH_GL(hookmask), HOOK_ACTIVE, GG_DISP2STATIC, DISPATCH_GL(hookmask), DISPATCH_GL(hookcount), HOOK_ACTIVE, 31-LUA_HOOKLINE, DISPATCH_GL(hookcount), Dt1(->base), Dt1(->base));
-  dasm_put(Dst, 3716, GG_DISP2STATIC);
+  dasm_put(Dst, 3670, DISPATCH_GL(hookmask), HOOK_ACTIVE, GG_DISP2STATIC, DISPATCH_GL(hookmask), DISPATCH_GL(hookcount), HOOK_ACTIVE, 31-LUA_HOOKLINE, DISPATCH_GL(hookcount), Dt1(->base), Dt1(->base));
+  dasm_put(Dst, 3717, GG_DISP2STATIC);
 #if LJ_HASJIT
-  dasm_put(Dst, 3734, GG_DISP2J, Dt7(->pc), DISPATCH_J(L), PC2PROTO(framesize), Dt1(->base), 31-3, Dt1(->top));
+  dasm_put(Dst, 3735, GG_DISP2J, Dt7(->pc), DISPATCH_J(L), PC2PROTO(framesize), Dt1(->base), 31-3, Dt1(->top));
 #endif
-  dasm_put(Dst, 3757);
+  dasm_put(Dst, 3758);
 #if LJ_HASJIT
-  dasm_put(Dst, 3760);
+  dasm_put(Dst, 3761);
 #endif
-  dasm_put(Dst, 3763);
+  dasm_put(Dst, 3764);
 #if LJ_HASJIT
-  dasm_put(Dst, 3765);
+  dasm_put(Dst, 3766);
 #endif
-  dasm_put(Dst, 3768, Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top));
+  dasm_put(Dst, 3769, Dt1(->base), Dt1(->top), Dt1(->base), Dt1(->top));
 #if LJ_HASJIT
-  dasm_put(Dst, 3791, -(16+32*8+32*4), 16+32*8+2*4, -GG_DISP2G-32768, ~LJ_VMST_EXIT, 16+32*8+32*4, DISPATCH_GL(vmstate), 16+0*8, 16+1*8, 16+2*8, 16+3*8, 16+4*8, 16+5*8, 16+6*8, 16+7*8, 16+32*8+32*4, 16+8*8, 16+9*8, 16+10*8, 16+11*8, 16+32*8+1*4, 16+12*8, 16+13*8);
-  dasm_put(Dst, 3838, 16+14*8, 16+15*8, 16+16*8, 16+17*8, 16+18*8, 16+19*8, 16+32*8+0*4, 16+20*8, 16+21*8, 16+22*8, 16+23*8, 16+24*8, 16+25*8, 16+26*8, 16+27*8, DISPATCH_GL(jit_L), 16+28*8, 16+29*8, 16+30*8, 16+31*8, DISPATCH_GL(jit_base), 32-2);
-  dasm_put(Dst, 3887, DISPATCH_J(L), DISPATCH_GL(jit_L), DISPATCH_J(parent), Dt1(->base), GG_DISP2J, DISPATCH_J(exitno), Dt1(->cframe), Dt1(->base));
+  dasm_put(Dst, 3792, -(16+32*8+32*4), 16+32*8+2*4, -GG_DISP2G-32768, ~LJ_VMST_EXIT, 16+32*8+32*4, DISPATCH_GL(vmstate), 16+0*8, 16+1*8, 16+2*8, 16+3*8, 16+4*8, 16+5*8, 16+6*8, 16+7*8, 16+32*8+32*4, 16+8*8, 16+9*8, 16+10*8, 16+11*8, 16+32*8+1*4, 16+12*8, 16+13*8);
+  dasm_put(Dst, 3839, 16+14*8, 16+15*8, 16+16*8, 16+17*8, 16+18*8, 16+19*8, 16+32*8+0*4, 16+20*8, 16+21*8, 16+22*8, 16+23*8, 16+24*8, 16+25*8, 16+26*8, 16+27*8, DISPATCH_GL(jit_L), 16+28*8, 16+29*8, 16+30*8, 16+31*8, DISPATCH_GL(jit_base), 32-2);
+  dasm_put(Dst, 3888, DISPATCH_J(L), DISPATCH_GL(jit_L), DISPATCH_J(parent), Dt1(->base), GG_DISP2J, DISPATCH_J(exitno), Dt1(->cframe), Dt1(->base));
 #endif
-  dasm_put(Dst, 3915);
+  dasm_put(Dst, 3916);
 #if LJ_HASJIT
-  dasm_put(Dst, 3917, -GG_DISP2G-32768, 31-3, Dt7(->pc), DISPATCH_GL(jit_L), PC2PROTO(k), LJ_TISNUM, LJ_TNIL, DISPATCH_GL(vmstate), BC_FUNCF*4);
+  dasm_put(Dst, 3918, -GG_DISP2G-32768, 31-3, Dt7(->pc), DISPATCH_GL(jit_L), PC2PROTO(k), LJ_TISNUM, LJ_TNIL, DISPATCH_GL(vmstate), BC_FUNCF*4);
 #endif
-  dasm_put(Dst, 3974);
+  dasm_put(Dst, 3975);
 #if LJ_HASJIT
-  dasm_put(Dst, 3982);
+  dasm_put(Dst, 3983);
 #endif
-  dasm_put(Dst, 3985);
+  dasm_put(Dst, 3986);
 #if LJ_HASJIT
-  dasm_put(Dst, 4065);
+  dasm_put(Dst, 4066);
 #else
-  dasm_put(Dst, 4087);
+  dasm_put(Dst, 4088);
 #endif
-  dasm_put(Dst, 4089);
+  dasm_put(Dst, 4090);
 #if LJ_HASFFI
 #define DtE(_V) (int)(ptrdiff_t)&(((CTState *)0)_V)
-  dasm_put(Dst, 4113, 56+(14-14)*4, 128+(14-14)*8, 56+(15-14)*4, 128+(15-14)*8, 56+(16-14)*4, 128+(16-14)*8, 56+(17-14)*4, 128+(17-14)*8, 56+(18-14)*4, 128+(18-14)*8, 56+(19-14)*4, 128+(19-14)*8, 56+(20-14)*4, 128+(20-14)*8, 56+(21-14)*4, 128+(21-14)*8, 56+(22-14)*4, 128+(22-14)*8, 56+(23-14)*4, 128+(23-14)*8, 56+(24-14)*4, 128+(24-14)*8);
-  dasm_put(Dst, 4161, 56+(25-14)*4, 128+(25-14)*8, 56+(26-14)*4, 128+(26-14)*8, 56+(27-14)*4, 128+(27-14)*8, 56+(28-14)*4, 128+(28-14)*8, 56+(29-14)*4, 128+(29-14)*8, 56+(30-14)*4, 128+(30-14)*8, 56+(31-14)*4, 128+(31-14)*8, Dt2(->ctype_state), GG_G2DISP, DtE(->cb.slot), DtE(->cb.gpr[0]), DtE(->cb.fpr[0]), DtE(->cb.gpr[1]), DtE(->cb.fpr[1]), DtE(->cb.gpr[2]));
-  dasm_put(Dst, 4208, DtE(->cb.fpr[2]), DtE(->cb.gpr[3]), DtE(->cb.fpr[3]), DtE(->cb.gpr[4]), DtE(->cb.fpr[4]), DtE(->cb.gpr[5]), DtE(->cb.fpr[5]), DtE(->cb.gpr[6]), DtE(->cb.fpr[6]), DtE(->cb.gpr[7]), DtE(->cb.fpr[7]), 272+8, DtE(->cb.stack), Dt1(->base), LJ_TISNUM, Dt1(->top), LJ_TNIL, ~LJ_VMST_INTERP, DISPATCH_GL(vmstate), Dt7(->pc));
+  dasm_put(Dst, 4114, 56+(14-14)*4, 128+(14-14)*8, 56+(15-14)*4, 128+(15-14)*8, 56+(16-14)*4, 128+(16-14)*8, 56+(17-14)*4, 128+(17-14)*8, 56+(18-14)*4, 128+(18-14)*8, 56+(19-14)*4, 128+(19-14)*8, 56+(20-14)*4, 128+(20-14)*8, 56+(21-14)*4, 128+(21-14)*8, 56+(22-14)*4, 128+(22-14)*8, 56+(23-14)*4, 128+(23-14)*8, 56+(24-14)*4, 128+(24-14)*8);
+  dasm_put(Dst, 4162, 56+(25-14)*4, 128+(25-14)*8, 56+(26-14)*4, 128+(26-14)*8, 56+(27-14)*4, 128+(27-14)*8, 56+(28-14)*4, 128+(28-14)*8, 56+(29-14)*4, 128+(29-14)*8, 56+(30-14)*4, 128+(30-14)*8, 56+(31-14)*4, 128+(31-14)*8, Dt2(->ctype_state), GG_G2DISP, DtE(->cb.slot), DtE(->cb.gpr[0]), DtE(->cb.fpr[0]), DtE(->cb.gpr[1]), DtE(->cb.fpr[1]), DtE(->cb.gpr[2]));
+  dasm_put(Dst, 4209, DtE(->cb.fpr[2]), DtE(->cb.gpr[3]), DtE(->cb.fpr[3]), DtE(->cb.gpr[4]), DtE(->cb.fpr[4]), DtE(->cb.gpr[5]), DtE(->cb.fpr[5]), DtE(->cb.gpr[6]), DtE(->cb.fpr[6]), DtE(->cb.gpr[7]), DtE(->cb.fpr[7]), 272+8, DtE(->cb.stack), Dt1(->base), LJ_TISNUM, Dt1(->top), LJ_TNIL, ~LJ_VMST_INTERP, DISPATCH_GL(vmstate), Dt7(->pc));
 #endif
-  dasm_put(Dst, 4272);
+  dasm_put(Dst, 4273);
 #if LJ_HASFFI
-  dasm_put(Dst, 4274, DISPATCH_GL(ctype_state), Dt1(->base), Dt1(->top), DtE(->L), DtE(->cb.gpr[0]), DtE(->cb.fpr[0]), DtE(->cb.gpr[1]));
+  dasm_put(Dst, 4275, DISPATCH_GL(ctype_state), Dt1(->base), Dt1(->top), DtE(->L), DtE(->cb.gpr[0]), DtE(->cb.fpr[0]), DtE(->cb.gpr[1]));
 #endif
-  dasm_put(Dst, 4295);
+  dasm_put(Dst, 4296);
 #if LJ_HASFFI
 #define DtF(_V) (int)(ptrdiff_t)&(((CCallState *)0)_V)
-  dasm_put(Dst, 4297, DtF(->spadj), DtF(->nsp), DtF(->nfpr), DtF(->stack), 31-2, DtF(->fpr[0]), DtF(->fpr[1]), DtF(->fpr[2]), DtF(->fpr[3]), DtF(->fpr[4]), DtF(->fpr[5]), DtF(->fpr[6]), DtF(->fpr[7]), DtF(->func), DtF(->gpr[1]), DtF(->gpr[2]));
-  dasm_put(Dst, 4354, DtF(->gpr[3]), DtF(->gpr[4]), DtF(->gpr[5]), DtF(->gpr[6]), DtF(->gpr[7]), DtF(->gpr[0]), DtF(->gpr[0]), DtF(->fpr[0]), DtF(->gpr[1]), DtF(->gpr[2]), DtF(->gpr[3]));
+  dasm_put(Dst, 4298, DtF(->spadj), DtF(->nsp), DtF(->nfpr), DtF(->stack), 31-2, DtF(->fpr[0]), DtF(->fpr[1]), DtF(->fpr[2]), DtF(->fpr[3]), DtF(->fpr[4]), DtF(->fpr[5]), DtF(->fpr[6]), DtF(->fpr[7]), DtF(->func), DtF(->gpr[1]), DtF(->gpr[2]));
+  dasm_put(Dst, 4355, DtF(->gpr[3]), DtF(->gpr[4]), DtF(->gpr[5]), DtF(->gpr[6]), DtF(->gpr[7]), DtF(->gpr[0]), DtF(->gpr[0]), DtF(->fpr[0]), DtF(->gpr[1]), DtF(->gpr[2]), DtF(->gpr[3]));
 #endif
 }
 
@@ -8572,7 +8573,7 @@ static void build_subroutines(BuildCtx *ctx)
 static void build_ins(BuildCtx *ctx, BCOp op, int defop)
 {
   int vk = 0;
-  dasm_put(Dst, 4386, defop);
+  dasm_put(Dst, 4387, defop);
 
   switch (op) {
 
@@ -8582,224 +8583,224 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
 
   case BC_ISLT: case BC_ISGE: case BC_ISLE: case BC_ISGT:
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 4388, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 4389, -(BCBIAS_J*4 >> 16));
       if (op == BC_ISLT) {
-        dasm_put(Dst, 4405);
+        dasm_put(Dst, 4406);
       } else if (op == BC_ISGE) {
-        dasm_put(Dst, 4408);
+        dasm_put(Dst, 4409);
       } else if (op == BC_ISLE) {
-        dasm_put(Dst, 4411);
+        dasm_put(Dst, 4412);
       } else {
-        dasm_put(Dst, 4414);
+        dasm_put(Dst, 4415);
       }
-      dasm_put(Dst, 4417);
+      dasm_put(Dst, 4418);
       if (op == BC_ISLT) {
-        dasm_put(Dst, 4456);
+        dasm_put(Dst, 4457);
       } else if (op == BC_ISGE) {
-        dasm_put(Dst, 4459);
+        dasm_put(Dst, 4460);
       } else if (op == BC_ISLE) {
-        dasm_put(Dst, 4462);
+        dasm_put(Dst, 4463);
       } else {
-        dasm_put(Dst, 4466);
+        dasm_put(Dst, 4467);
       }
-      dasm_put(Dst, 4470);
+      dasm_put(Dst, 4471);
     } else {
-      dasm_put(Dst, 4473, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 4474, -(BCBIAS_J*4 >> 16));
       if (op == BC_ISLT) {
-        dasm_put(Dst, 4490);
+        dasm_put(Dst, 4491);
       } else if (op == BC_ISGE) {
-        dasm_put(Dst, 4493);
+        dasm_put(Dst, 4494);
       } else if (op == BC_ISLE) {
-        dasm_put(Dst, 4496);
+        dasm_put(Dst, 4497);
       } else {
-        dasm_put(Dst, 4500);
+        dasm_put(Dst, 4501);
       }
-      dasm_put(Dst, 4504);
+      dasm_put(Dst, 4505);
     }
     break;
 
   case BC_ISEQV: case BC_ISNEV:
     vk = op == BC_ISEQV;
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 4517, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 4518, -(BCBIAS_J*4 >> 16));
       if (vk) {
-        dasm_put(Dst, 4530);
+        dasm_put(Dst, 4531);
       } else {
-        dasm_put(Dst, 4533);
+        dasm_put(Dst, 4534);
       }
     } else {
-      dasm_put(Dst, 4536, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 4537, -(BCBIAS_J*4 >> 16));
       if (vk) {
-        dasm_put(Dst, 4553);
+        dasm_put(Dst, 4554);
       } else {
-        dasm_put(Dst, 4557);
+        dasm_put(Dst, 4558);
       }
-      dasm_put(Dst, 4561);
+      dasm_put(Dst, 4562);
     }
-    dasm_put(Dst, 4573);
+    dasm_put(Dst, 4574);
     if (!LJ_DUALNUM) {
-      dasm_put(Dst, 4575);
+      dasm_put(Dst, 4576);
     }
     if (LJ_HASFFI) {
-      dasm_put(Dst, 4578, LJ_TCDATA, LJ_TCDATA);
+      dasm_put(Dst, 4579, LJ_TCDATA, LJ_TCDATA);
     }
-    dasm_put(Dst, 4583, ~LJ_TISPRI);
+    dasm_put(Dst, 4584, ~LJ_TISPRI);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 4588);
+      dasm_put(Dst, 4589);
     }
-    dasm_put(Dst, 4590, ~LJ_TISTABUD);
+    dasm_put(Dst, 4591, ~LJ_TISTABUD);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 4593);
+      dasm_put(Dst, 4594);
     }
-    dasm_put(Dst, 4596);
+    dasm_put(Dst, 4597);
     if (vk) {
-      dasm_put(Dst, 4604);
+      dasm_put(Dst, 4605);
     } else {
-      dasm_put(Dst, 4609);
+      dasm_put(Dst, 4610);
     }
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 4614);
+      dasm_put(Dst, 4615);
     } else {
-      dasm_put(Dst, 4629);
+      dasm_put(Dst, 4630);
     }
-    dasm_put(Dst, 4632, Dt6(->metatable), 1-vk, Dt6(->nomm), 1<<MM_eq);
+    dasm_put(Dst, 4633, Dt6(->metatable), 1-vk, Dt6(->nomm), 1<<MM_eq);
     break;
 
   case BC_ISEQS: case BC_ISNES:
     vk = op == BC_ISEQS;
-    dasm_put(Dst, 4651, 32-1);
+    dasm_put(Dst, 4652, 32-1);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 4659, LJ_TCDATA);
+      dasm_put(Dst, 4660, LJ_TCDATA);
     }
-    dasm_put(Dst, 4662, LJ_TSTR);
+    dasm_put(Dst, 4663, LJ_TSTR);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 4666);
+      dasm_put(Dst, 4667);
     }
-    dasm_put(Dst, 4669, -(BCBIAS_J*4 >> 16));
+    dasm_put(Dst, 4670, -(BCBIAS_J*4 >> 16));
     if (vk) {
-      dasm_put(Dst, 4677);
+      dasm_put(Dst, 4678);
     } else {
-      dasm_put(Dst, 4679);
+      dasm_put(Dst, 4680);
     }
-    dasm_put(Dst, 4681);
+    dasm_put(Dst, 4682);
     break;
 
   case BC_ISEQN: case BC_ISNEN:
     vk = op == BC_ISEQN;
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 4693, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 4694, -(BCBIAS_J*4 >> 16));
       if (vk) {
-        dasm_put(Dst, 4705);
+        dasm_put(Dst, 4706);
       } else {
-        dasm_put(Dst, 4707);
+        dasm_put(Dst, 4708);
       }
-      dasm_put(Dst, 4709);
+      dasm_put(Dst, 4710);
     } else {
       if (vk) {
-        dasm_put(Dst, 4716);
+        dasm_put(Dst, 4717);
       } else {
-        dasm_put(Dst, 4718);
+        dasm_put(Dst, 4719);
       }
-      dasm_put(Dst, 4720, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 4721, -(BCBIAS_J*4 >> 16));
     }
     if (vk) {
-      dasm_put(Dst, 4733);
+      dasm_put(Dst, 4734);
       if (!LJ_HASFFI) {
-        dasm_put(Dst, 4738);
+        dasm_put(Dst, 4739);
       }
     } else {
-      dasm_put(Dst, 4740);
+      dasm_put(Dst, 4741);
       if (!LJ_HASFFI) {
-        dasm_put(Dst, 4744);
+        dasm_put(Dst, 4745);
       }
-      dasm_put(Dst, 4746);
+      dasm_put(Dst, 4747);
     }
-    dasm_put(Dst, 4749);
+    dasm_put(Dst, 4750);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 4760, LJ_TCDATA);
+      dasm_put(Dst, 4761, LJ_TCDATA);
     }
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 4768);
+      dasm_put(Dst, 4769);
     }
     break;
 
   case BC_ISEQP: case BC_ISNEP:
     vk = op == BC_ISEQP;
-    dasm_put(Dst, 4792, 32-3);
+    dasm_put(Dst, 4793, 32-3);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 4799, LJ_TCDATA);
+      dasm_put(Dst, 4800, LJ_TCDATA);
     }
-    dasm_put(Dst, 4802);
+    dasm_put(Dst, 4803);
     if (LJ_HASFFI) {
-      dasm_put(Dst, 4804);
+      dasm_put(Dst, 4805);
     }
-    dasm_put(Dst, 4807, -(BCBIAS_J*4 >> 16));
+    dasm_put(Dst, 4808, -(BCBIAS_J*4 >> 16));
     if (vk) {
-      dasm_put(Dst, 4813);
+      dasm_put(Dst, 4814);
     } else {
-      dasm_put(Dst, 4815);
+      dasm_put(Dst, 4816);
     }
-    dasm_put(Dst, 4817);
+    dasm_put(Dst, 4818);
     break;
 
   /* -- Unary test and copy ops ------------------------------------------- */
 
   case BC_ISTC: case BC_ISFC: case BC_IST: case BC_ISF:
-    dasm_put(Dst, 4829);
+    dasm_put(Dst, 4830);
     if (op == BC_IST || op == BC_ISF) {
-      dasm_put(Dst, 4833, LJ_TTRUE, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 4834, LJ_TTRUE, -(BCBIAS_J*4 >> 16));
       if (op == BC_IST) {
-        dasm_put(Dst, 4840);
+        dasm_put(Dst, 4841);
       } else {
-        dasm_put(Dst, 4842);
+        dasm_put(Dst, 4843);
       }
-      dasm_put(Dst, 4844);
+      dasm_put(Dst, 4845);
     } else {
-      dasm_put(Dst, 4846, LJ_TFALSE);
+      dasm_put(Dst, 4847, LJ_TFALSE);
       if (op == BC_ISTC) {
-        dasm_put(Dst, 4851);
+        dasm_put(Dst, 4852);
       } else {
-        dasm_put(Dst, 4854);
+        dasm_put(Dst, 4855);
       }
-      dasm_put(Dst, 4857, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 4858, -(BCBIAS_J*4 >> 16));
     }
-    dasm_put(Dst, 4864);
+    dasm_put(Dst, 4865);
     break;
 
   /* -- Unary ops --------------------------------------------------------- */
 
   case BC_MOV:
-    dasm_put(Dst, 4875);
+    dasm_put(Dst, 4876);
     break;
   case BC_NOT:
-    dasm_put(Dst, 4888, LJ_TTRUE);
+    dasm_put(Dst, 4889, LJ_TTRUE);
     break;
   case BC_UNM:
-    dasm_put(Dst, 4904);
+    dasm_put(Dst, 4905);
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 4908);
+      dasm_put(Dst, 4909);
     }
-    dasm_put(Dst, 4936);
+    dasm_put(Dst, 4937);
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 4946);
+      dasm_put(Dst, 4947);
     } else {
-      dasm_put(Dst, 4949);
+      dasm_put(Dst, 4950);
     }
     break;
   case BC_LEN:
-    dasm_put(Dst, 4958, LJ_TSTR, Dt5(->len));
+    dasm_put(Dst, 4959, LJ_TSTR, Dt5(->len));
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 4968);
+      dasm_put(Dst, 4969);
     } else {
-      dasm_put(Dst, 4973);
+      dasm_put(Dst, 4974);
     }
-    dasm_put(Dst, 4980, LJ_TTAB);
+    dasm_put(Dst, 4981, LJ_TTAB);
 #ifdef LUAJIT_ENABLE_LUA52COMPAT
-    dasm_put(Dst, 4994, Dt6(->metatable));
+    dasm_put(Dst, 4995, Dt6(->metatable));
 #endif
-    dasm_put(Dst, 5001);
+    dasm_put(Dst, 5002);
 #ifdef LUAJIT_ENABLE_LUA52COMPAT
-    dasm_put(Dst, 5007, Dt6(->nomm), 1<<MM_len);
+    dasm_put(Dst, 5008, Dt6(->nomm), 1<<MM_len);
 #endif
     break;
 
@@ -8811,77 +8812,77 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5017);
+    dasm_put(Dst, 5018);
       break;
     case 1:
-    dasm_put(Dst, 5023);
+    dasm_put(Dst, 5024);
       break;
     default:
-    dasm_put(Dst, 5029);
+    dasm_put(Dst, 5030);
       break;
     }
-    dasm_put(Dst, 5035);
+    dasm_put(Dst, 5036);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5062);
+    dasm_put(Dst, 5063);
       break;
     case 1:
-    dasm_put(Dst, 5065);
+    dasm_put(Dst, 5066);
       break;
     default:
-    dasm_put(Dst, 5068);
+    dasm_put(Dst, 5069);
       break;
     }
-    dasm_put(Dst, 5071);
+    dasm_put(Dst, 5072);
     if (vk == 1) {
-    dasm_put(Dst, 5073);
+    dasm_put(Dst, 5074);
     } else {
-    dasm_put(Dst, 5077);
+    dasm_put(Dst, 5078);
     }
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5081);
+    dasm_put(Dst, 5082);
       break;
     case 1:
-    dasm_put(Dst, 5084);
+    dasm_put(Dst, 5085);
       break;
     default:
-    dasm_put(Dst, 5087);
+    dasm_put(Dst, 5088);
       break;
     }
-    dasm_put(Dst, 5090);
+    dasm_put(Dst, 5091);
     } else {
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5097);
+    dasm_put(Dst, 5098);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5099);
+    dasm_put(Dst, 5100);
     }
-    dasm_put(Dst, 5101);
+    dasm_put(Dst, 5102);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5104);
+    dasm_put(Dst, 5105);
     } else {
-    dasm_put(Dst, 5110);
+    dasm_put(Dst, 5111);
     }
       break;
     case 1:
-    dasm_put(Dst, 5114);
+    dasm_put(Dst, 5115);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5116);
+    dasm_put(Dst, 5117);
     }
-    dasm_put(Dst, 5118);
+    dasm_put(Dst, 5119);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5121);
+    dasm_put(Dst, 5122);
     } else {
-    dasm_put(Dst, 5127);
+    dasm_put(Dst, 5128);
     }
       break;
     default:
-    dasm_put(Dst, 5131);
+    dasm_put(Dst, 5132);
       break;
     }
-    dasm_put(Dst, 5141);
+    dasm_put(Dst, 5142);
     }
     break;
   case BC_SUBVN: case BC_SUBNV: case BC_SUBVV:
@@ -8889,77 +8890,77 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5154);
+    dasm_put(Dst, 5155);
       break;
     case 1:
-    dasm_put(Dst, 5160);
+    dasm_put(Dst, 5161);
       break;
     default:
-    dasm_put(Dst, 5166);
+    dasm_put(Dst, 5167);
       break;
     }
-    dasm_put(Dst, 5172);
+    dasm_put(Dst, 5173);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5199);
+    dasm_put(Dst, 5200);
       break;
     case 1:
-    dasm_put(Dst, 5202);
+    dasm_put(Dst, 5203);
       break;
     default:
-    dasm_put(Dst, 5205);
+    dasm_put(Dst, 5206);
       break;
     }
-    dasm_put(Dst, 5208);
+    dasm_put(Dst, 5209);
     if (vk == 1) {
-    dasm_put(Dst, 5210);
+    dasm_put(Dst, 5211);
     } else {
-    dasm_put(Dst, 5214);
+    dasm_put(Dst, 5215);
     }
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5218);
+    dasm_put(Dst, 5219);
       break;
     case 1:
-    dasm_put(Dst, 5221);
+    dasm_put(Dst, 5222);
       break;
     default:
-    dasm_put(Dst, 5224);
+    dasm_put(Dst, 5225);
       break;
     }
-    dasm_put(Dst, 5227);
+    dasm_put(Dst, 5228);
     } else {
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5234);
+    dasm_put(Dst, 5235);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5236);
+    dasm_put(Dst, 5237);
     }
-    dasm_put(Dst, 5238);
+    dasm_put(Dst, 5239);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5241);
+    dasm_put(Dst, 5242);
     } else {
-    dasm_put(Dst, 5247);
+    dasm_put(Dst, 5248);
     }
       break;
     case 1:
-    dasm_put(Dst, 5251);
+    dasm_put(Dst, 5252);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5253);
+    dasm_put(Dst, 5254);
     }
-    dasm_put(Dst, 5255);
+    dasm_put(Dst, 5256);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5258);
+    dasm_put(Dst, 5259);
     } else {
-    dasm_put(Dst, 5264);
+    dasm_put(Dst, 5265);
     }
       break;
     default:
-    dasm_put(Dst, 5268);
+    dasm_put(Dst, 5269);
       break;
     }
-    dasm_put(Dst, 5278);
+    dasm_put(Dst, 5279);
     }
     break;
   case BC_MULVN: case BC_MULNV: case BC_MULVV:
@@ -8967,188 +8968,188 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5291);
+    dasm_put(Dst, 5292);
       break;
     case 1:
-    dasm_put(Dst, 5297);
+    dasm_put(Dst, 5298);
       break;
     default:
-    dasm_put(Dst, 5303);
+    dasm_put(Dst, 5304);
       break;
     }
-    dasm_put(Dst, 5309);
+    dasm_put(Dst, 5310);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5336);
+    dasm_put(Dst, 5337);
       break;
     case 1:
-    dasm_put(Dst, 5339);
+    dasm_put(Dst, 5340);
       break;
     default:
-    dasm_put(Dst, 5342);
+    dasm_put(Dst, 5343);
       break;
     }
-    dasm_put(Dst, 5345);
+    dasm_put(Dst, 5346);
     if (vk == 1) {
-    dasm_put(Dst, 5347);
+    dasm_put(Dst, 5348);
     } else {
-    dasm_put(Dst, 5351);
+    dasm_put(Dst, 5352);
     }
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5355);
+    dasm_put(Dst, 5356);
       break;
     case 1:
-    dasm_put(Dst, 5358);
+    dasm_put(Dst, 5359);
       break;
     default:
-    dasm_put(Dst, 5361);
+    dasm_put(Dst, 5362);
       break;
     }
-    dasm_put(Dst, 5364);
+    dasm_put(Dst, 5365);
     } else {
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5371);
+    dasm_put(Dst, 5372);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5373);
+    dasm_put(Dst, 5374);
     }
-    dasm_put(Dst, 5375);
+    dasm_put(Dst, 5376);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5378);
+    dasm_put(Dst, 5379);
     } else {
-    dasm_put(Dst, 5384);
+    dasm_put(Dst, 5385);
     }
       break;
     case 1:
-    dasm_put(Dst, 5388);
+    dasm_put(Dst, 5389);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5390);
+    dasm_put(Dst, 5391);
     }
-    dasm_put(Dst, 5392);
+    dasm_put(Dst, 5393);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5395);
+    dasm_put(Dst, 5396);
     } else {
-    dasm_put(Dst, 5401);
+    dasm_put(Dst, 5402);
     }
       break;
     default:
-    dasm_put(Dst, 5405);
+    dasm_put(Dst, 5406);
       break;
     }
-    dasm_put(Dst, 5415);
+    dasm_put(Dst, 5416);
     }
     break;
   case BC_DIVVN: case BC_DIVNV: case BC_DIVVV:
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5428);
+    dasm_put(Dst, 5429);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5430);
+    dasm_put(Dst, 5431);
     }
-    dasm_put(Dst, 5432);
+    dasm_put(Dst, 5433);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5435);
+    dasm_put(Dst, 5436);
     } else {
-    dasm_put(Dst, 5441);
+    dasm_put(Dst, 5442);
     }
       break;
     case 1:
-    dasm_put(Dst, 5445);
+    dasm_put(Dst, 5446);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5447);
+    dasm_put(Dst, 5448);
     }
-    dasm_put(Dst, 5449);
+    dasm_put(Dst, 5450);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5452);
+    dasm_put(Dst, 5453);
     } else {
-    dasm_put(Dst, 5458);
+    dasm_put(Dst, 5459);
     }
       break;
     default:
-    dasm_put(Dst, 5462);
+    dasm_put(Dst, 5463);
       break;
     }
-    dasm_put(Dst, 5472);
+    dasm_put(Dst, 5473);
     break;
   case BC_MODVN:
     if (LJ_DUALNUM) {
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5485);
+    dasm_put(Dst, 5486);
       break;
     case 1:
-    dasm_put(Dst, 5491);
+    dasm_put(Dst, 5492);
       break;
     default:
-    dasm_put(Dst, 5497);
+    dasm_put(Dst, 5498);
       break;
     }
-    dasm_put(Dst, 5503);
+    dasm_put(Dst, 5504);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5531);
+    dasm_put(Dst, 5532);
       break;
     case 1:
-    dasm_put(Dst, 5534);
+    dasm_put(Dst, 5535);
       break;
     default:
-    dasm_put(Dst, 5537);
+    dasm_put(Dst, 5538);
       break;
     }
-    dasm_put(Dst, 5540);
+    dasm_put(Dst, 5541);
     if (vk == 1) {
-    dasm_put(Dst, 5542);
+    dasm_put(Dst, 5543);
     } else {
-    dasm_put(Dst, 5546);
+    dasm_put(Dst, 5547);
     }
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5550);
+    dasm_put(Dst, 5551);
       break;
     case 1:
-    dasm_put(Dst, 5553);
+    dasm_put(Dst, 5554);
       break;
     default:
-    dasm_put(Dst, 5556);
+    dasm_put(Dst, 5557);
       break;
     }
-    dasm_put(Dst, 5559);
+    dasm_put(Dst, 5560);
     } else {
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5571);
+    dasm_put(Dst, 5572);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5573);
+    dasm_put(Dst, 5574);
     }
-    dasm_put(Dst, 5575);
+    dasm_put(Dst, 5576);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5578);
+    dasm_put(Dst, 5579);
     } else {
-    dasm_put(Dst, 5584);
+    dasm_put(Dst, 5585);
     }
       break;
     case 1:
-    dasm_put(Dst, 5588);
+    dasm_put(Dst, 5589);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5590);
+    dasm_put(Dst, 5591);
     }
-    dasm_put(Dst, 5592);
+    dasm_put(Dst, 5593);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5595);
+    dasm_put(Dst, 5596);
     } else {
-    dasm_put(Dst, 5601);
+    dasm_put(Dst, 5602);
     }
       break;
     default:
-    dasm_put(Dst, 5605);
+    dasm_put(Dst, 5606);
       break;
     }
-    dasm_put(Dst, 5615);
+    dasm_put(Dst, 5616);
     }
     break;
   case BC_MODNV: case BC_MODVV:
@@ -9156,297 +9157,297 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5633);
+    dasm_put(Dst, 5634);
       break;
     case 1:
-    dasm_put(Dst, 5639);
+    dasm_put(Dst, 5640);
       break;
     default:
-    dasm_put(Dst, 5645);
+    dasm_put(Dst, 5646);
       break;
     }
-    dasm_put(Dst, 5651);
+    dasm_put(Dst, 5652);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5679);
+    dasm_put(Dst, 5680);
       break;
     case 1:
-    dasm_put(Dst, 5682);
+    dasm_put(Dst, 5683);
       break;
     default:
-    dasm_put(Dst, 5685);
+    dasm_put(Dst, 5686);
       break;
     }
-    dasm_put(Dst, 5688);
+    dasm_put(Dst, 5689);
     if (vk == 1) {
-    dasm_put(Dst, 5690);
+    dasm_put(Dst, 5691);
     } else {
-    dasm_put(Dst, 5694);
+    dasm_put(Dst, 5695);
     }
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5698);
+    dasm_put(Dst, 5699);
       break;
     case 1:
-    dasm_put(Dst, 5701);
+    dasm_put(Dst, 5702);
       break;
     default:
-    dasm_put(Dst, 5704);
+    dasm_put(Dst, 5705);
       break;
     }
-    dasm_put(Dst, 5707);
+    dasm_put(Dst, 5708);
     } else {
     vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
     switch (vk) {
     case 0:
-    dasm_put(Dst, 5710);
+    dasm_put(Dst, 5711);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5712);
+    dasm_put(Dst, 5713);
     }
-    dasm_put(Dst, 5714);
+    dasm_put(Dst, 5715);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5717);
+    dasm_put(Dst, 5718);
     } else {
-    dasm_put(Dst, 5723);
+    dasm_put(Dst, 5724);
     }
       break;
     case 1:
-    dasm_put(Dst, 5727);
+    dasm_put(Dst, 5728);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5729);
+    dasm_put(Dst, 5730);
     }
-    dasm_put(Dst, 5731);
+    dasm_put(Dst, 5732);
     if (LJ_DUALNUM) {
-    dasm_put(Dst, 5734);
+    dasm_put(Dst, 5735);
     } else {
-    dasm_put(Dst, 5740);
+    dasm_put(Dst, 5741);
     }
       break;
     default:
-    dasm_put(Dst, 5744);
+    dasm_put(Dst, 5745);
       break;
     }
-    dasm_put(Dst, 5754);
+    dasm_put(Dst, 5755);
     }
     break;
   case BC_POW:
-    dasm_put(Dst, 5757);
+    dasm_put(Dst, 5758);
     break;
 
   case BC_CAT:
-    dasm_put(Dst, 5780, Dt1(->base), 32-3, Dt1(->base));
+    dasm_put(Dst, 5781, Dt1(->base), 32-3, Dt1(->base));
     break;
 
   /* -- Constant ops ------------------------------------------------------ */
 
   case BC_KSTR:
-    dasm_put(Dst, 5810, 32-1, LJ_TSTR);
+    dasm_put(Dst, 5811, 32-1, LJ_TSTR);
     break;
   case BC_KCDATA:
 #if LJ_HASFFI
-    dasm_put(Dst, 5829, 32-1, LJ_TCDATA);
+    dasm_put(Dst, 5830, 32-1, LJ_TCDATA);
 #endif
     break;
   case BC_KSHORT:
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 5848, 31-13);
+      dasm_put(Dst, 5849, 31-13);
     } else {
-      dasm_put(Dst, 5864, 31-13, 31-20);
+      dasm_put(Dst, 5865, 31-13, 31-20);
     }
     break;
   case BC_KNUM:
-    dasm_put(Dst, 5892);
+    dasm_put(Dst, 5893);
     break;
   case BC_KPRI:
-    dasm_put(Dst, 5905, 32-3);
+    dasm_put(Dst, 5906, 32-3);
     break;
   case BC_KNIL:
-    dasm_put(Dst, 5920);
+    dasm_put(Dst, 5921);
     break;
 
   /* -- Upvalue and function ops ------------------------------------------ */
 
   case BC_UGET:
-    dasm_put(Dst, 5939, 32-1, offsetof(GCfuncL, uvptr), DtA(->v));
+    dasm_put(Dst, 5940, 32-1, offsetof(GCfuncL, uvptr), DtA(->v));
     break;
   case BC_USETV:
-    dasm_put(Dst, 5960, 32-1, offsetof(GCfuncL, uvptr), DtA(->marked), DtA(->v), LJ_GC_BLACK, DtA(->closed), -(LJ_TISNUM+1), LJ_TISGCV - (LJ_TISNUM+1), Dt4(->gch.marked), LJ_GC_WHITES, GG_DISP2G);
+    dasm_put(Dst, 5961, 32-1, offsetof(GCfuncL, uvptr), DtA(->marked), DtA(->v), LJ_GC_BLACK, DtA(->closed), -(LJ_TISNUM+1), LJ_TISGCV - (LJ_TISNUM+1), Dt4(->gch.marked), LJ_GC_WHITES, GG_DISP2G);
     break;
   case BC_USETS:
-    dasm_put(Dst, 6013, 32-1, 32-1, offsetof(GCfuncL, uvptr), DtA(->marked), DtA(->v), LJ_GC_BLACK, Dt5(->marked), DtA(->closed), LJ_TSTR, LJ_GC_WHITES, GG_DISP2G);
+    dasm_put(Dst, 6014, 32-1, 32-1, offsetof(GCfuncL, uvptr), DtA(->marked), DtA(->v), LJ_GC_BLACK, Dt5(->marked), DtA(->closed), LJ_TSTR, LJ_GC_WHITES, GG_DISP2G);
     break;
   case BC_USETN:
-    dasm_put(Dst, 6064, 32-1, offsetof(GCfuncL, uvptr), DtA(->v));
+    dasm_put(Dst, 6065, 32-1, offsetof(GCfuncL, uvptr), DtA(->v));
     break;
   case BC_USETP:
-    dasm_put(Dst, 6085, 32-1, 32-3, offsetof(GCfuncL, uvptr), DtA(->v));
+    dasm_put(Dst, 6086, 32-1, 32-3, offsetof(GCfuncL, uvptr), DtA(->v));
     break;
 
   case BC_UCLO:
-    dasm_put(Dst, 6108, Dt1(->openupval), 32-1, -(BCBIAS_J*4 >> 16), Dt1(->base), Dt1(->base));
+    dasm_put(Dst, 6109, Dt1(->openupval), 32-1, -(BCBIAS_J*4 >> 16), Dt1(->base), Dt1(->base));
     break;
 
   case BC_FNEW:
-    dasm_put(Dst, 6138, 32-1, Dt1(->base), Dt1(->base), LJ_TFUNC);
+    dasm_put(Dst, 6139, 32-1, Dt1(->base), Dt1(->base), LJ_TFUNC);
     break;
 
   /* -- Table ops --------------------------------------------------------- */
 
   case BC_TNEW:
   case BC_TDUP:
-    dasm_put(Dst, 6166, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), Dt1(->base));
+    dasm_put(Dst, 6167, DISPATCH_GL(gc.total), DISPATCH_GL(gc.threshold), Dt1(->base));
     if (op == BC_TNEW) {
-      dasm_put(Dst, 6179);
+      dasm_put(Dst, 6180);
     } else {
-      dasm_put(Dst, 6188, 32-1);
+      dasm_put(Dst, 6189, 32-1);
     }
-    dasm_put(Dst, 6195, Dt1(->base), LJ_TTAB);
+    dasm_put(Dst, 6196, Dt1(->base), LJ_TTAB);
     if (op == BC_TNEW) {
-      dasm_put(Dst, 6212);
+      dasm_put(Dst, 6213);
     }
-    dasm_put(Dst, 6217);
+    dasm_put(Dst, 6218);
     break;
 
   case BC_GGET:
   case BC_GSET:
-    dasm_put(Dst, 6226, 32-1, Dt7(->env));
+    dasm_put(Dst, 6227, 32-1, Dt7(->env));
     if (op == BC_GGET) {
-      dasm_put(Dst, 6234);
+      dasm_put(Dst, 6235);
     } else {
-      dasm_put(Dst, 6237);
+      dasm_put(Dst, 6238);
     }
     break;
 
   case BC_TGETV:
-    dasm_put(Dst, 6240);
+    dasm_put(Dst, 6241);
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 6244);
+      dasm_put(Dst, 6245);
     } else {
-      dasm_put(Dst, 6246);
+      dasm_put(Dst, 6247);
     }
-    dasm_put(Dst, 6248, LJ_TTAB);
+    dasm_put(Dst, 6249, LJ_TTAB);
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 6254, Dt6(->asize), Dt6(->array), 31-3);
+      dasm_put(Dst, 6255, Dt6(->asize), Dt6(->array), 31-3);
     } else {
-      dasm_put(Dst, 6264, Dt6(->asize), Dt6(->array), 31-3);
+      dasm_put(Dst, 6265, Dt6(->asize), Dt6(->array), 31-3);
     }
-    dasm_put(Dst, 6281, LJ_TNIL, Dt6(->metatable), Dt6(->nomm), 1<<MM_index, LJ_TSTR);
+    dasm_put(Dst, 6282, LJ_TNIL, Dt6(->metatable), Dt6(->nomm), 1<<MM_index, LJ_TSTR);
     if (!LJ_DUALNUM) {
-      dasm_put(Dst, 6321);
+      dasm_put(Dst, 6322);
     }
-    dasm_put(Dst, 6323);
+    dasm_put(Dst, 6324);
     break;
   case BC_TGETS:
-    dasm_put(Dst, 6326, 32-1, LJ_TTAB, Dt6(->hmask), Dt5(->hash), Dt6(->node), 31-5, 31-3, DtB(->key), 4+offsetof(Node, key), DtB(->val), 4+offsetof(Node, val), LJ_TSTR, LJ_TNIL, DtB(->next));
-    dasm_put(Dst, 6387, LJ_TNIL, Dt6(->metatable), Dt6(->nomm), 1<<MM_index);
+    dasm_put(Dst, 6327, 32-1, LJ_TTAB, Dt6(->hmask), Dt5(->hash), Dt6(->node), 31-5, 31-3, DtB(->key), 4+offsetof(Node, key), DtB(->val), 4+offsetof(Node, val), LJ_TSTR, LJ_TNIL, DtB(->next));
+    dasm_put(Dst, 6388, LJ_TNIL, Dt6(->metatable), Dt6(->nomm), 1<<MM_index);
     break;
   case BC_TGETB:
-    dasm_put(Dst, 6407, 32-3, LJ_TTAB, Dt6(->asize), Dt6(->array), LJ_TNIL, Dt6(->metatable), Dt6(->nomm), 1<<MM_index);
+    dasm_put(Dst, 6408, 32-3, LJ_TTAB, Dt6(->asize), Dt6(->array), LJ_TNIL, Dt6(->metatable), Dt6(->nomm), 1<<MM_index);
     break;
 
   case BC_TSETV:
-    dasm_put(Dst, 6455);
+    dasm_put(Dst, 6456);
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 6459);
+      dasm_put(Dst, 6460);
     } else {
-      dasm_put(Dst, 6461);
+      dasm_put(Dst, 6462);
     }
-    dasm_put(Dst, 6463, LJ_TTAB);
+    dasm_put(Dst, 6464, LJ_TTAB);
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 6469, Dt6(->asize), Dt6(->array), 31-3);
+      dasm_put(Dst, 6470, Dt6(->asize), Dt6(->array), 31-3);
     } else {
-      dasm_put(Dst, 6479, Dt6(->asize), Dt6(->array), 31-3);
+      dasm_put(Dst, 6480, Dt6(->asize), Dt6(->array), 31-3);
     }
-    dasm_put(Dst, 6496, Dt6(->marked), LJ_TNIL, LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, LJ_TSTR);
+    dasm_put(Dst, 6497, Dt6(->marked), LJ_TNIL, LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, LJ_TSTR);
     if (!LJ_DUALNUM) {
-      dasm_put(Dst, 6543);
+      dasm_put(Dst, 6544);
     }
-    dasm_put(Dst, 6545, DISPATCH_GL(gc.grayagain), DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
+    dasm_put(Dst, 6546, DISPATCH_GL(gc.grayagain), DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
     break;
   case BC_TSETS:
-    dasm_put(Dst, 6560, 32-1, LJ_TTAB, Dt6(->hmask), Dt5(->hash), Dt6(->node), Dt6(->nomm), 31-5, 31-3, Dt6(->marked), DtB(->key), 4+offsetof(Node, key), DtB(->val), DtB(->next), LJ_TSTR, LJ_TNIL);
-    dasm_put(Dst, 6611, LJ_GC_BLACK, DtB(->val), Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, Dt6(->metatable), DISPATCH_GL(tmptv), Dt1(->base), Dt6(->nomm), 1<<MM_newindex, LJ_TSTR);
-    dasm_put(Dst, 6668, Dt1(->base), DISPATCH_GL(gc.grayagain), DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
+    dasm_put(Dst, 6561, 32-1, LJ_TTAB, Dt6(->hmask), Dt5(->hash), Dt6(->node), Dt6(->nomm), 31-5, 31-3, Dt6(->marked), DtB(->key), 4+offsetof(Node, key), DtB(->val), DtB(->next), LJ_TSTR, LJ_TNIL);
+    dasm_put(Dst, 6612, LJ_GC_BLACK, DtB(->val), Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, Dt6(->metatable), DISPATCH_GL(tmptv), Dt1(->base), Dt6(->nomm), 1<<MM_newindex, LJ_TSTR);
+    dasm_put(Dst, 6669, Dt1(->base), DISPATCH_GL(gc.grayagain), DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
     break;
   case BC_TSETB:
-    dasm_put(Dst, 6691, 32-3, LJ_TTAB, Dt6(->asize), Dt6(->array), Dt6(->marked), LJ_TNIL, LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, DISPATCH_GL(gc.grayagain));
-    dasm_put(Dst, 6749, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
+    dasm_put(Dst, 6692, 32-3, LJ_TTAB, Dt6(->asize), Dt6(->array), Dt6(->marked), LJ_TNIL, LJ_GC_BLACK, Dt6(->metatable), Dt6(->nomm), 1<<MM_newindex, DISPATCH_GL(gc.grayagain));
+    dasm_put(Dst, 6750, DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
     break;
 
   case BC_TSETM:
-    dasm_put(Dst, 6759, 32-3, Dt6(->asize), 31-3, Dt6(->marked), Dt6(->array), LJ_GC_BLACK, Dt1(->base), DISPATCH_GL(gc.grayagain), DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
-    dasm_put(Dst, 6828);
+    dasm_put(Dst, 6760, 32-3, Dt6(->asize), 31-3, Dt6(->marked), Dt6(->array), LJ_GC_BLACK, Dt1(->base), DISPATCH_GL(gc.grayagain), DISPATCH_GL(gc.grayagain), Dt6(->marked), Dt6(->gclist));
+    dasm_put(Dst, 6829);
     break;
 
   /* -- Calls and vararg handling ----------------------------------------- */
 
   case BC_CALLM:
-    dasm_put(Dst, 6831);
+    dasm_put(Dst, 6832);
     break;
   case BC_CALL:
-    dasm_put(Dst, 6833, LJ_TFUNC, Dt7(->pc));
+    dasm_put(Dst, 6834, LJ_TFUNC, Dt7(->pc));
     break;
 
   case BC_CALLMT:
-    dasm_put(Dst, 6854);
+    dasm_put(Dst, 6855);
     break;
   case BC_CALLT:
-    dasm_put(Dst, 6856, LJ_TFUNC, FRAME_TYPE, Dt7(->ffid), FRAME_VARG, Dt7(->pc), -4-8, Dt7(->pc), PC2PROTO(k), FRAME_TYPEP);
-    dasm_put(Dst, 6920, FRAME_TYPE);
+    dasm_put(Dst, 6857, LJ_TFUNC, FRAME_TYPE, Dt7(->ffid), FRAME_VARG, Dt7(->pc), -4-8, Dt7(->pc), PC2PROTO(k), FRAME_TYPEP);
+    dasm_put(Dst, 6921, FRAME_TYPE);
     break;
 
   case BC_ITERC:
-    dasm_put(Dst, 6929, LJ_TFUNC, Dt7(->pc));
+    dasm_put(Dst, 6930, LJ_TFUNC, Dt7(->pc));
     break;
 
   case BC_ITERN:
 #if LJ_HASJIT
 #endif
-    dasm_put(Dst, 6956, Dt6(->asize), Dt6(->array), 31-3, LJ_TNIL);
+    dasm_put(Dst, 6957, Dt6(->asize), Dt6(->array), 31-3, LJ_TNIL);
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 6978);
+      dasm_put(Dst, 6979);
     } else {
-      dasm_put(Dst, 6981);
+      dasm_put(Dst, 6982);
     }
-    dasm_put(Dst, 6985, -(BCBIAS_J*4 >> 16));
+    dasm_put(Dst, 6986, -(BCBIAS_J*4 >> 16));
     if (!LJ_DUALNUM) {
-      dasm_put(Dst, 6993);
+      dasm_put(Dst, 6994);
     }
-    dasm_put(Dst, 6995, Dt6(->hmask), Dt6(->node), 31-5, 31-3, LJ_TNIL, DtB(->key), -(BCBIAS_J*4 >> 16));
+    dasm_put(Dst, 6996, Dt6(->hmask), Dt6(->node), 31-5, 31-3, LJ_TNIL, DtB(->key), -(BCBIAS_J*4 >> 16));
     break;
 
   case BC_ISNEXT:
-    dasm_put(Dst, 7051, LJ_TTAB, LJ_TFUNC, LJ_TNIL, Dt8(->ffid), FF_next_N, 32-1, -(BCBIAS_J*4 >> 16), BC_JMP, BC_ITERC, -(BCBIAS_J*4 >> 16));
+    dasm_put(Dst, 7052, LJ_TTAB, LJ_TFUNC, LJ_TNIL, Dt8(->ffid), FF_next_N, 32-1, -(BCBIAS_J*4 >> 16), BC_JMP, BC_ITERC, -(BCBIAS_J*4 >> 16));
     break;
 
   case BC_VARG:
-    dasm_put(Dst, 7101, FRAME_VARG, Dt1(->maxstack), Dt1(->top), Dt1(->base), 32-3, Dt1(->base));
-    dasm_put(Dst, 7181);
+    dasm_put(Dst, 7102, FRAME_VARG, Dt1(->maxstack), Dt1(->top), Dt1(->base), 32-3, Dt1(->base));
+    dasm_put(Dst, 7182);
     break;
 
   /* -- Returns ----------------------------------------------------------- */
 
   case BC_RETM:
-    dasm_put(Dst, 7187);
+    dasm_put(Dst, 7188);
     break;
 
   case BC_RET:
-    dasm_put(Dst, 7189, FRAME_TYPE, FRAME_VARG, Dt7(->pc), PC2PROTO(k), FRAME_TYPEP);
+    dasm_put(Dst, 7190, FRAME_TYPE, FRAME_VARG, Dt7(->pc), PC2PROTO(k), FRAME_TYPEP);
     break;
 
   case BC_RET0: case BC_RET1:
-    dasm_put(Dst, 7259, FRAME_TYPE, FRAME_VARG);
+    dasm_put(Dst, 7260, FRAME_TYPE, FRAME_VARG);
     if (op == BC_RET1) {
-      dasm_put(Dst, 7272);
+      dasm_put(Dst, 7273);
     }
-    dasm_put(Dst, 7275, Dt7(->pc), PC2PROTO(k));
+    dasm_put(Dst, 7276, Dt7(->pc), PC2PROTO(k));
     break;
 
   /* -- Loops and branches ------------------------------------------------ */
 
   case BC_FORL:
 #if LJ_HASJIT
-    dasm_put(Dst, 7303, GG_DISP2HOT, -HOTCOUNT_LOOP);
+    dasm_put(Dst, 7304, GG_DISP2HOT, -HOTCOUNT_LOOP);
 #endif
     break;
 
@@ -9459,100 +9460,100 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
   case BC_IFORL:
     vk = (op == BC_IFORL || op == BC_JFORL);
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 7313, FORL_IDX*8+4);
+      dasm_put(Dst, 7314, FORL_IDX*8+4);
       if (vk) {
-        dasm_put(Dst, 7318, FORL_STEP*8+4, FORL_STOP*8+4, FORL_IDX*8+4);
+        dasm_put(Dst, 7319, FORL_STEP*8+4, FORL_STOP*8+4, FORL_IDX*8+4);
       } else {
-        dasm_put(Dst, 7332, FORL_STEP*8, FORL_STEP*8+4, FORL_STOP*8, FORL_STOP*8+4);
+        dasm_put(Dst, 7333, FORL_STEP*8, FORL_STEP*8+4, FORL_STOP*8, FORL_STOP*8+4);
       }
-      dasm_put(Dst, 7348, FORL_EXT*8);
+      dasm_put(Dst, 7349, FORL_EXT*8);
       if (op != BC_JFORL) {
-        dasm_put(Dst, 7355, 32-1);
+        dasm_put(Dst, 7356, 32-1);
       }
-      dasm_put(Dst, 7358, FORL_EXT*8+4);
+      dasm_put(Dst, 7359, FORL_EXT*8+4);
       if (op != BC_JFORL) {
-        dasm_put(Dst, 7361);
+        dasm_put(Dst, 7362);
       }
       if (op == BC_FORI) {
-        dasm_put(Dst, 7363);
+        dasm_put(Dst, 7364);
       } else if (op == BC_JFORI) {
-        dasm_put(Dst, 7366, -(BCBIAS_J*4 >> 16));
+        dasm_put(Dst, 7367, -(BCBIAS_J*4 >> 16));
       } else if (op == BC_IFORL) {
-        dasm_put(Dst, 7371, -(BCBIAS_J*4 >> 16));
+        dasm_put(Dst, 7372, -(BCBIAS_J*4 >> 16));
       } else {
-        dasm_put(Dst, 7376, BC_JLOOP);
+        dasm_put(Dst, 7377, BC_JLOOP);
       }
-      dasm_put(Dst, 7379);
+      dasm_put(Dst, 7380);
       if (vk) {
-        dasm_put(Dst, 7395);
+        dasm_put(Dst, 7396);
       }
     }
     if (vk) {
       if (LJ_DUALNUM) {
-        dasm_put(Dst, 7402, FORL_IDX*8);
+        dasm_put(Dst, 7403, FORL_IDX*8);
       } else {
-        dasm_put(Dst, 7406);
+        dasm_put(Dst, 7407);
       }
-      dasm_put(Dst, 7408, FORL_STEP*8, FORL_STOP*8, FORL_STEP*8, FORL_IDX*8);
+      dasm_put(Dst, 7409, FORL_STEP*8, FORL_STOP*8, FORL_STEP*8, FORL_IDX*8);
     } else {
       if (LJ_DUALNUM) {
-        dasm_put(Dst, 7418);
+        dasm_put(Dst, 7419);
       } else {
-        dasm_put(Dst, 7420, FORL_STEP*8, FORL_STOP*8);
+        dasm_put(Dst, 7421, FORL_STEP*8, FORL_STOP*8);
       }
-      dasm_put(Dst, 7429, FORL_IDX*8, FORL_STOP*8);
+      dasm_put(Dst, 7430, FORL_IDX*8, FORL_STOP*8);
     }
-    dasm_put(Dst, 7438);
+    dasm_put(Dst, 7439);
     if (op != BC_JFORL) {
-      dasm_put(Dst, 7440, 32-1);
+      dasm_put(Dst, 7441, 32-1);
     }
-    dasm_put(Dst, 7443, FORL_EXT*8);
+    dasm_put(Dst, 7444, FORL_EXT*8);
     if (op != BC_JFORL) {
-      dasm_put(Dst, 7446);
+      dasm_put(Dst, 7447);
     }
-    dasm_put(Dst, 7448);
+    dasm_put(Dst, 7449);
     if (op == BC_JFORI) {
-      dasm_put(Dst, 7450, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 7451, -(BCBIAS_J*4 >> 16));
     }
-    dasm_put(Dst, 7453);
+    dasm_put(Dst, 7454);
     if (op == BC_FORI) {
-      dasm_put(Dst, 7456);
+      dasm_put(Dst, 7457);
     } else if (op == BC_IFORL) {
       if (LJ_DUALNUM) {
-        dasm_put(Dst, 7459);
+        dasm_put(Dst, 7460);
       } else {
-        dasm_put(Dst, 7462);
+        dasm_put(Dst, 7463);
       }
-      dasm_put(Dst, 7465, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 7466, -(BCBIAS_J*4 >> 16));
     } else if (op == BC_JFORI) {
-      dasm_put(Dst, 7469);
+      dasm_put(Dst, 7470);
     } else {
-      dasm_put(Dst, 7472, BC_JLOOP);
+      dasm_put(Dst, 7473, BC_JLOOP);
     }
     if (LJ_DUALNUM) {
-      dasm_put(Dst, 7475);
+      dasm_put(Dst, 7476);
     } else {
-      dasm_put(Dst, 7478);
+      dasm_put(Dst, 7479);
     }
-    dasm_put(Dst, 7490);
+    dasm_put(Dst, 7491);
     if (op == BC_FORI) {
-      dasm_put(Dst, 7492, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 7493, -(BCBIAS_J*4 >> 16));
     } else if (op == BC_IFORL) {
-      dasm_put(Dst, 7498);
+      dasm_put(Dst, 7499);
     } else if (op == BC_JFORI) {
-      dasm_put(Dst, 7501);
+      dasm_put(Dst, 7502);
     } else {
-      dasm_put(Dst, 7504, BC_JLOOP);
+      dasm_put(Dst, 7505, BC_JLOOP);
     }
-    dasm_put(Dst, 7507);
+    dasm_put(Dst, 7508);
     if (op == BC_JFORI) {
-      dasm_put(Dst, 7510, BC_JLOOP);
+      dasm_put(Dst, 7511, BC_JLOOP);
     }
     break;
 
   case BC_ITERL:
 #if LJ_HASJIT
-    dasm_put(Dst, 7516, GG_DISP2HOT, -HOTCOUNT_LOOP);
+    dasm_put(Dst, 7517, GG_DISP2HOT, -HOTCOUNT_LOOP);
 #endif
     break;
 
@@ -9561,40 +9562,40 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
     break;
 #endif
   case BC_IITERL:
-    dasm_put(Dst, 7526, LJ_TNIL);
+    dasm_put(Dst, 7527, LJ_TNIL);
     if (op == BC_JITERL) {
-      dasm_put(Dst, 7533, BC_JLOOP);
+      dasm_put(Dst, 7534, BC_JLOOP);
     } else {
-      dasm_put(Dst, 7538, 32-1, -(BCBIAS_J*4 >> 16));
+      dasm_put(Dst, 7539, 32-1, -(BCBIAS_J*4 >> 16));
     }
-    dasm_put(Dst, 7546);
+    dasm_put(Dst, 7547);
     break;
 
   case BC_LOOP:
 #if LJ_HASJIT
-    dasm_put(Dst, 7558, GG_DISP2HOT, -HOTCOUNT_LOOP);
+    dasm_put(Dst, 7559, GG_DISP2HOT, -HOTCOUNT_LOOP);
 #endif
     break;
 
   case BC_ILOOP:
-    dasm_put(Dst, 7568);
+    dasm_put(Dst, 7569);
     break;
 
   case BC_JLOOP:
 #if LJ_HASJIT
-    dasm_put(Dst, 7579, DISPATCH_J(trace), 32-1, DISPATCH_GL(vmstate), DtD(->mcode), DISPATCH_GL(jit_base), DISPATCH_GL(jit_L), GG_DISP2G+32768);
+    dasm_put(Dst, 7580, DISPATCH_J(trace), 32-1, DISPATCH_GL(vmstate), DtD(->mcode), DISPATCH_GL(jit_base), DISPATCH_GL(jit_L), GG_DISP2G+32768);
 #endif
     break;
 
   case BC_JMP:
-    dasm_put(Dst, 7598, 32-1, -(BCBIAS_J*4 >> 16));
+    dasm_put(Dst, 7599, 32-1, -(BCBIAS_J*4 >> 16));
     break;
 
   /* -- Function headers -------------------------------------------------- */
 
   case BC_FUNCF:
 #if LJ_HASJIT
-    dasm_put(Dst, 7614, GG_DISP2HOT, -HOTCOUNT_CALL);
+    dasm_put(Dst, 7615, GG_DISP2HOT, -HOTCOUNT_CALL);
 #endif
   case BC_FUNCV:  /* NYI: compiled vararg functions. */
     break;
@@ -9604,42 +9605,42 @@ static void build_ins(BuildCtx *ctx, BCOp op, int defop)
     break;
 #endif
   case BC_IFUNCF:
-    dasm_put(Dst, 7624, Dt1(->maxstack), -4+PC2PROTO(numparams), -4+PC2PROTO(k), 31-3);
+    dasm_put(Dst, 7625, Dt1(->maxstack), -4+PC2PROTO(numparams), -4+PC2PROTO(k), 31-3);
     if (op != BC_JFUNCF) {
-      dasm_put(Dst, 7636);
+      dasm_put(Dst, 7637);
     }
-    dasm_put(Dst, 7639);
+    dasm_put(Dst, 7640);
     if (op == BC_JFUNCF) {
-      dasm_put(Dst, 7644, BC_JLOOP);
+      dasm_put(Dst, 7645, BC_JLOOP);
     } else {
-      dasm_put(Dst, 7648);
+      dasm_put(Dst, 7649);
     }
-    dasm_put(Dst, 7657);
+    dasm_put(Dst, 7658);
     break;
 
   case BC_JFUNCV:
 #if !LJ_HASJIT
     break;
 #endif
-    dasm_put(Dst, 7663);
+    dasm_put(Dst, 7664);
     break;  /* NYI: compiled vararg functions. */
 
   case BC_IFUNCV:
-    dasm_put(Dst, 7665, Dt1(->maxstack), 8+FRAME_VARG, -4+PC2PROTO(k), -4+PC2PROTO(numparams), LJ_TNIL);
+    dasm_put(Dst, 7666, Dt1(->maxstack), 8+FRAME_VARG, -4+PC2PROTO(k), -4+PC2PROTO(numparams), LJ_TNIL);
     break;
 
   case BC_FUNCC:
   case BC_FUNCCW:
     if (op == BC_FUNCC) {
-      dasm_put(Dst, 7718, Dt8(->f));
+      dasm_put(Dst, 7719, Dt8(->f));
     } else {
-      dasm_put(Dst, 7721, DISPATCH_GL(wrapf));
+      dasm_put(Dst, 7722, DISPATCH_GL(wrapf));
     }
-    dasm_put(Dst, 7724, Dt1(->maxstack), Dt1(->base), Dt1(->top), ~LJ_VMST_C);
+    dasm_put(Dst, 7725, Dt1(->maxstack), Dt1(->base), Dt1(->top), ~LJ_VMST_C);
     if (op == BC_FUNCCW) {
-      dasm_put(Dst, 7737, Dt8(->f));
+      dasm_put(Dst, 7738, Dt8(->f));
     }
-    dasm_put(Dst, 7740, DISPATCH_GL(vmstate), Dt1(->base), 31-3, Dt1(->top), ~LJ_VMST_INTERP, DISPATCH_GL(vmstate));
+    dasm_put(Dst, 7741, DISPATCH_GL(vmstate), Dt1(->base), 31-3, Dt1(->top), ~LJ_VMST_INTERP, DISPATCH_GL(vmstate));
     break;
 
   /* ---------------------------------------------------------------------- */
@@ -9659,7 +9660,7 @@ static int build_backend(BuildCtx *ctx)
 
   build_subroutines(ctx);
 
-  dasm_put(Dst, 7761);
+  dasm_put(Dst, 7762);
   for (op = 0; op < BC__MAX; op++)
     build_ins(ctx, (BCOp)op, op);