jz 0.6.0 → 0.8.0

package/module/regex.js

@@ -9,7 +9,7 @@
 
 import { typed, asF64, asI64, UNDEF_NAN, NULL_NAN, mkPtrIR, temp, tempI32 } from '../src/ir.js'
 import { emit, deps } from '../src/bridge.js'
-import { ctx, err, inc, PTR, LAYOUT, getter, declGlobal } from '../src/ctx.js'
+import { ctx, err, inc, PTR, LAYOUT, registerGetter, declGlobal } from '../src/ctx.js'
 import { valTypeOf } from '../src/kind.js'
 import { VAL } from '../src/reps.js'
 
@@ -746,13 +746,14 @@ export default (ctx) => {
     (if (i32.eqz (i32.and (local.get $aux) (i32.const ${LAYOUT.SSO_BIT})))
       (then (return (call $__ptr_offset (local.get $ptr)))))
     (local.set $off (call $__ptr_offset (local.get $ptr)))
-    (local.set $len (i32.and (local.get $aux) (i32.const 7)))
+    (local.set $len (i32.and (i32.shr_u (local.get $aux) (i32.const 10)) (i32.const 7)))
     (local.set $buf (call $__alloc (local.get $len)))
     (local.set $i (i32.const 0))
     (block $done (loop $next
       (br_if $done (i32.ge_u (local.get $i) (local.get $len)))
+      ;; 7-bit ASCII SSO: char i at payload bit i*7 (read from the full i64 ptr; chars 4-5 span aux).
       (i32.store8 (i32.add (local.get $buf) (local.get $i))
-        (i32.and (i32.shr_u (local.get $off) (i32.mul (local.get $i) (i32.const 8))) (i32.const 0xFF)))
+        (i32.wrap_i64 (i64.and (i64.shr_u (local.get $ptr) (i64.mul (i64.extend_i32_u (local.get $i)) (i64.const 7))) (i64.const 0x7f))))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br $next)))
     (local.get $buf))`
@@ -911,14 +912,14 @@ export default (ctx) => {
   // RegExp.prototype.source — the pattern text. A literal stores it verbatim
   // (already grammar-escaped), so `/A/.source` is the 6-char "A".
   // An empty pattern serializes to "(?:)" so the result re-parses to a regex.
-  ctx.core.emit['.regex:source'] = getter((obj) => {
+  registerGetter('.regex:source', (obj) => {
     const a = regexAstOf(obj)
     return emit(['str', (a && a[1]) || '(?:)'])
   })
 
   // RegExp.prototype.flags — flag characters in canonical order (sec-get-regexp.prototype.flags).
   const FLAG_ORDER = 'dgimsvy'
-  ctx.core.emit['.regex:flags'] = getter((obj) => {
+  registerGetter('.regex:flags', (obj) => {
     const f = flagsOf(obj)
     return emit(['str', [...FLAG_ORDER].filter(c => f.includes(c)).join('')])
   })
@@ -927,10 +928,10 @@ export default (ctx) => {
   for (const [prop, ch] of [
     ['global', 'g'], ['ignoreCase', 'i'], ['multiline', 'm'], ['dotAll', 's'],
     ['unicode', 'u'], ['sticky', 'y'], ['hasIndices', 'd'], ['unicodeSets', 'v'],
-  ]) ctx.core.emit[`.regex:${prop}`] = getter((obj) => typed(['f64.const', flagsOf(obj).includes(ch) ? 1 : 0], 'f64'))
+  ]) registerGetter(`.regex:${prop}`, (obj) => typed(['f64.const', flagsOf(obj).includes(ch) ? 1 : 0], 'f64'))
 
   // lastIndex — for /g and /y regexes, reads the mutable global; others always 0.
-  ctx.core.emit['.regex:lastIndex'] = getter((obj) => {
+  registerGetter('.regex:lastIndex', (obj) => {
     const id = resolveRegex(obj)
     if (id != null) {
       const flags = flagsOf(obj)

package/module/simd.js

@@ -1,8 +1,9 @@
 /**
- * SIMD module — source-level f32x4 / i32x4 intrinsics that lower 1:1 to wasm SIMD
- * (v128). Lets a jz kernel process 4 lanes per instruction: the per-pixel-parallel
- * kernels (mandelbrot, raymarcher) run 4 pixels/rays in masked lockstep and beat
- * scalar V8 several-fold (validated: SIMD-4 mandelbrot ≈ 4.6× a warm-V8 scalar loop).
+ * SIMD module — source-level f32x4 / i32x4 / f64x2 intrinsics that lower 1:1 to wasm
+ * SIMD (v128). Lets a jz kernel process 4 (or, for f64x2, 2) lanes per instruction:
+ * the per-pixel-parallel kernels (mandelbrot, raymarcher) run 4 pixels/rays in masked
+ * lockstep, and the attractors kernel packs its two sines + two cosines two-per-f64x2.
+ * Several-fold over scalar V8 (validated: SIMD-4 mandelbrot ≈ 4.6× a warm-V8 scalar loop).
  *
  * A v128 value is just a local whose wasm type is `v128` (exprType returns 'v128'
  * for these calls; emit passes it through without an f64/i32 coercion). Building
@@ -18,11 +19,14 @@
  *   i32x4.splat(n) / add/sub(a,b) / lane(v,k)
  *   v128.and/or/xor(a,b) / not(a) / bitselect(t,f,mask)
  *   v128.anyTrue(v) / v128.allTrue(v) → i32 (loop-exit tests)
+ *   f64x2.splat(x) / lanes(a,b) / add/sub/mul/div/min/max / sqrt/abs/neg/… / cmp
+ *   f64x2.sin(v) / f64x2.cos(v) → both lanes through one poly ($math.sin2/$math.cos2)
+ *   f64x2.lane(v, k)          extract lane k (0..1) as a number
  *
  * @module simd
  */
 import { typed, asF64, asI32 } from '../src/ir.js'
-import { emit } from '../src/bridge.js'
+import { emit, emitter } from '../src/bridge.js'
 import { err } from '../src/ctx.js'
 
 export default (ctx) => {
@@ -82,4 +86,32 @@ export default (ctx) => {
   // ── lane extract (read a single lane back to a scalar) ───────────────────────
   e['f32x4.lane'] = (v, k) => F(['f64.promote_f32', ['f32x4.extract_lane', laneIdx(k), op(v)]])
   e['i32x4.lane'] = (v, k) => I(['i32x4.extract_lane', laneIdx(k), op(v)])
+
+  // ── f64x2 — two full-precision f64 lanes (no f32 demotion) ───────────────────
+  // For kernels whose hot value is f64: two independent angles/coords per instruction.
+  // `f64x2.sin`/`f64x2.cos` lower to the shared $math.sin2/$math.cos2 poly (module/math.js)
+  // — sin and cos of distinct args pack two-per-vector and ≈halve transcendental cost.
+  const lane2 = (k) => {
+    const v = typeof k === 'number' ? k : (Array.isArray(k) && k.length === 2 && k[0] == null && typeof k[1] === 'number') ? k[1] : null
+    if (v == null || (v | 0) !== v || v < 0 || v > 1)
+      err(`f64x2 lane index must be a 0..1 literal (got ${JSON.stringify(k)}).`)
+    return v
+  }
+  e['f64x2.splat'] = (a) => V(['f64x2.splat', asF64(emit(a))])
+  e['f64x2.lanes'] = (a, b) => V(['f64x2.replace_lane', 1, ['f64x2.splat', asF64(emit(a))], asF64(emit(b))])
+  for (const o of ['add', 'sub', 'mul', 'div', 'min', 'max'])
+    e[`f64x2.${o}`] = (a, b) => V([`f64x2.${o}`, op(a), op(b)])
+  for (const o of ['sqrt', 'abs', 'neg', 'floor', 'ceil', 'trunc', 'nearest'])
+    e[`f64x2.${o}`] = (a) => V([`f64x2.${o}`, op(a)])
+  for (const o of ['eq', 'ne', 'lt', 'le', 'gt', 'ge'])
+    e[`f64x2.${o}`] = (a, b) => V([`f64x2.${o}`, op(a), op(b)])
+  e['f64x2.sin'] = emitter(['math.sin2'], (a) => V(['call', '$math.sin2', op(a)]))
+  e['f64x2.cos'] = emitter(['math.cos2'], (a) => V(['call', '$math.cos2', op(a)]))
+  // f64x2.log/exp/exp2 lower to the true-vectorized $math.log_v/$math.exp_v/$math.exp2_v polys —
+  // both lanes through one fdlibm/2^f evaluation (≈2× over two scalar calls), bit-exact via a
+  // hot-path-vectorized + scalar-edge-fallback split (module/math.js).
+  e['f64x2.log'] = emitter(['math.log_v'], (a) => V(['call', '$math.log_v', op(a)]))
+  e['f64x2.exp'] = emitter(['math.exp_v'], (a) => V(['call', '$math.exp_v', op(a)]))
+  e['f64x2.exp2'] = emitter(['math.exp2_v'], (a) => V(['call', '$math.exp2_v', op(a)]))
+  e['f64x2.lane'] = (v, k) => F(['f64x2.extract_lane', lane2(k), op(v)])
 }