jz 0.8.0 → 0.9.0

package/layout.js

@@ -52,7 +52,16 @@ const AUX_SHIFT = BigInt(LAYOUT.AUX_SHIFT), AUX_MASK = BigInt(LAYOUT.AUX_MASK)
 const OFFSET_MASK = BigInt(LAYOUT.OFFSET_MASK)
 
 /** Format an i64 BigInt as a zero-padded `0x…` hex literal for WAT/IR templates. */
-export const i64Hex = bits => '0x' + bits.toString(16).toUpperCase().padStart(16, '0')
+// Formatted via 32-bit halves with an explicit logical shift, NOT
+// bits.toString(16): under self-host, BigInts are raw SIGNED i64 bits
+// (kind-erased — see ir.js's SELF-HOST CONTRACT), so toString(16) of a
+// bit-63-set value renders a signed "-8000…" fragment and the emitted
+// `(i64.const 0x00-8000…)` kills the kernel's watr parse ("Bad int") — the
+// nanPrefixMaskHex regression that silently broke every durable-log helper
+// the kernel compiled. `>> 32n` sign-extends on raw bits; the & masks the
+// extension off, so both host and kernel produce the same unsigned halves.
+const _hx8 = (n) => n.toString(16).toUpperCase().padStart(8, '0')
+export const i64Hex = bits => '0x' + _hx8(Number((bits >> 32n) & 0xFFFFFFFFn)) + _hx8(Number(bits & 0xFFFFFFFFn))
 
 /** Pack (type, aux, offset) into the i64 NaN-box carrier — the single source of
  *  truth for pointer bit layout. Compiler IR (`packPtrBits`/`mkPtrIR`), the
@@ -123,6 +132,12 @@ export const decodePtrAux = hi => hi & LAYOUT.AUX_MASK
 /** i64 NaN-prefix OR-mask for WAT `(i64.const …)` templates. */
 export const nanPrefixHex = () => i64Hex(LAYOUT.NAN_PREFIX_BITS)
 
+/** AND-mask isolating the boxed-carrier prefix (sign + exponent + quiet bit):
+ *  `(v & nanPrefixMask) == nanPrefix` ⇔ v is a NaN-boxed carrier (any tag/aux/
+ *  payload). The mask is the prefix with the SIGN bit forced on — boxes are
+ *  emitted sign-clear, so a set sign bit must fail the carrier test. */
+export const nanPrefixMaskHex = () => i64Hex(LAYOUT.NAN_PREFIX_BITS | (1n << 63n))
+
 /** Atom sentinel as i64 hex (compiler WAT templates). */
 export const atomNanHex = atomId => i64Hex(LAYOUT.NAN_PREFIX_BITS | (BigInt(atomId) << AUX_SHIFT))
 
@@ -136,12 +151,27 @@ export const atomNanHex = atomId => i64Hex(LAYOUT.NAN_PREFIX_BITS | (BigInt(atom
  *  heap consumers read the len header at -4 regardless of aux. */
 export const STR_INTERN_BIT = 0x1
 
+/** STRING aux bit 1 on a PLAIN-HEAP string (SSO and SLICE clear): the string was
+ *  allocated with an [hash u32][len u32][bytes] header where the hash cell is a
+ *  LAZY cache — seeded 0 (byte-FNV clamps to ≥2, so 0 is unambiguous "uncomputed"),
+ *  filled by __str_hash on first hash. Sound because heap strings never relocate
+ *  and die with their arena; the two in-place mutators (concat/append bump-extend
+ *  of a heap-top accumulator) zero the cell when they change the bytes. Unlike
+ *  STR_INTERN_BIT it carries NO canonicality claim — two hcache strings with equal
+ *  content are ordinary bit-unequal pointers. Inert for slices (their aux[12:0]
+ *  is a length, only read under SLICE_BIT) and every len/byte reader (-4 header
+ *  unchanged). Producers opt in one by one; an unmarked string just re-hashes. */
+export const STR_HCACHE_BIT = 0x2
+
 /** Pre-shifted STRING SSO aux bit as i64 hex. */
 export const ssoBitI64Hex = () => i64Hex(BigInt(LAYOUT.SSO_BIT) << AUX_SHIFT)
 
 /** Pre-shifted STRING slice/view aux bit as i64 hex. */
 export const sliceBitI64Hex = () => i64Hex(BigInt(LAYOUT.SLICE_BIT) << AUX_SHIFT)
 
+/** Pre-shifted STRING hash-cache aux bit as i64 hex. */
+export const hcacheBitI64Hex = () => i64Hex(BigInt(STR_HCACHE_BIT) << AUX_SHIFT)
+
 /** Full i64 NaN-box hex for `(i64.const …)` — ptr type + aux, offset OR'd separately. */
 export const ptrNanHex = (ptrType, aux = 0) => i64Hex(ptrBits(ptrType, aux))
 
@@ -174,10 +204,25 @@ export const oobNanIR = () => ['f64.const', oobNanLiteral()]
  *  __arr_idx_known, __typed_idx…) — a body containing a loop is excluded from
  *  V8's wasm inliner, and these helpers sit on ~25% of self-host compile time.
  *  Callers must list '__ptr_offset_fwd' in their deps()/wat() dependency set. */
+// Upper bound is `off <= memory.size() * 65536` (total bytes currently backed) — read from
+// $__heap_end64 (module/core.js, kept in sync by __memgrow on every grow), NOT recomputed
+// as `i64.shl(i64.extend_i32_u(memory.size), 16)` inline: this check is on the hottest
+// pointer-dereference path (~25% of self-host compile time, per the doc comment above), so
+// a per-call recompute would cost 3 extra instructions at every inlined site instead of one
+// global read. The i32 form `memory.size() << 16` (what a naive version — and $__heap_end
+// itself — uses) overflows to exactly 0 at the wasm32 ceiling (memory.size()==65536 pages,
+// i.e. the full 4 GiB: 65536*65536 == 2^32, unrepresentable in i32). Reading $__heap_end
+// here instead of $__heap_end64 would make the bound "off <= 0", failing for every real off
+// and silently disabling the forward-chase for the rest of execution: any pointer to an
+// already-relocated ARRAY/SET/MAP/HASH stops following its forwarding header and reads the
+// abandoned old block (cap=-1 sentinel misread as a real capacity) instead. That wraparound
+// is benign for $__heap_end's own consumer (__alloc's fast-path check just slow-paths one
+// extra time and __memgrow re-derives everything fresh in i64) but NOT here, where it gates
+// whether forwarding runs at all — hence the separate i64 global instead of reusing $__heap_end.
 export const followForwardingWat = (off = '$off', { lowGuard = true } = {}) =>
   `(if (i32.and
         ${lowGuard ? `(i32.ge_u (local.get ${off}) (i32.const 8))` : '(i32.const 1)'}
-        (i32.le_u (local.get ${off}) (i32.shl (memory.size) (i32.const 16))))
+        (i64.le_u (i64.extend_i32_u (local.get ${off})) (global.get $__heap_end64)))
     (then (if (i32.eq (i32.load (i32.sub (local.get ${off}) (i32.const 4))) (i32.const -1))
       (then (local.set ${off} (call $__ptr_offset_fwd (local.get ${off})))))))`
 
@@ -188,7 +233,7 @@ export const ptrOffsetFwdWat = () =>
   `(func $__ptr_offset_fwd (param $off i32) (result i32)
     (block $done (loop $follow
       (br_if $done (i32.lt_u (local.get $off) (i32.const 8)))
-      (br_if $done (i32.gt_u (local.get $off) (i32.shl (memory.size) (i32.const 16))))
+      (br_if $done (i64.gt_u (i64.extend_i32_u (local.get $off)) (global.get $__heap_end64)))
       (br_if $done (i32.ne (i32.load (i32.sub (local.get $off) (i32.const 4))) (i32.const -1)))
       (local.set $off (i32.load (i32.sub (local.get $off) (i32.const 8))))
       (br $follow)))