watr 4.5.0 → 4.5.3

package/src/compile.js

@@ -308,7 +308,7 @@ function normalize(nodes, ctx) {
       else if ((node.startsWith('memory.') || node.endsWith('load') || node.endsWith('store')) && isIdx(nodes[0])) out.push(nodes.shift())
     }
     else if (Array.isArray(node)) {
-      const op = node[0]
+      let op = node[0]
       node.loc != null && (err.loc = node.loc) // track position for errors
 
       // code metadata annotations - pass through as marker with metadata type and data
@@ -348,6 +348,13 @@ function normalize(nodes, ctx) {
         }
         out.push(...normalize(parts, ctx), 'end')
       }
+      else if (op === 'ref.test' || op === 'ref.cast') {
+        const type = parts[0]
+        const isNullable = !Array.isArray(type) || type[1] === 'null' || type[0] !== 'ref'
+        if (isNullable) op += '_null'
+        out.push(...normalize(parts.slice(1), ctx), op, type)
+        nodes.unshift(...out.splice(out.length - 2))
+      }
       else {
         const imm = []
         // Collect immediate operands (non-arrays or special forms like type/param/result/ref)
@@ -965,7 +972,7 @@ const instr = (nodes, ctx) => {
       // select: becomes typed select (opcode+1) if next node is an array with result types
       if (op === 'select' && nodes[0]?.length) bytes[0]++
       // ref.type|cast: opcode+1 if type is nullable: (ref null $t) or (funcref, anyref, etc.)
-      else if (HANDLER[op] === IMM.reftype && (nodes[0][1] === 'null' || nodes[0][0] !== 'ref')) {
+      else if (HANDLER[op] === IMM.reftype && !op.endsWith('_null') && (nodes[0][1] === 'null' || nodes[0][0] !== 'ref')) {
         bytes[bytes.length - 1]++
       }
       bytes.push(...HANDLER[op](nodes, ctx, op))

package/src/const.js

@@ -59,7 +59,7 @@ export const INSTR = [
     'struct.new typeidx', 'struct.new_default typeidx', 'struct.get typeidx_field', 'struct.get_s typeidx_field', 'struct.get_u typeidx_field', 'struct.set typeidx_field',
     'array.new typeidx', 'array.new_default typeidx', 'array.new_fixed typeidx_multi', 'array.new_data typeidx_dataidx', 'array.new_elem typeidx_elemidx',
     'array.get typeidx', 'array.get_s typeidx', 'array.get_u typeidx', 'array.set typeidx', 'array.len', 'array.fill typeidx', 'array.copy typeidx_typeidx',
-    'array.init_data typeidx_dataidx', 'array.init_elem typeidx_elemidx', 'ref.test reftype', '', 'ref.cast reftype', '', 'br_on_cast reftype2', 'br_on_cast_fail reftype2',
+    'array.init_data typeidx_dataidx', 'array.init_elem typeidx_elemidx', 'ref.test reftype', 'ref.test_null reftype', 'ref.cast reftype', 'ref.cast_null reftype', 'br_on_cast reftype2', 'br_on_cast_fail reftype2',
     'any.convert_extern', 'extern.convert_any', 'ref.i31', 'i31.get_s', 'i31.get_u',
     // custom descriptors (Phase 3): 0xFB 0x20-0x26
     , 'struct.new_desc typeidx', 'struct.new_default_desc typeidx', 'ref.get_desc typeidx', 'ref.cast_desc_eq reftype', , 'br_on_cast_desc_eq reftype2', 'br_on_cast_desc_eq_fail reftype2',
@@ -182,7 +182,7 @@ export const TYPE = {
   // Value types
   i8: 0x78, i16: 0x77, i32: 0x7f, i64: 0x7e, f32: 0x7d, f64: 0x7c, void: 0x40, v128: 0x7B,
   // Heap types
-  exn: 0x69, noexn: 0x74, nofunc: 0x73, noextern: 0x72, none: 0x71, func: 0x70, extern: 0x6F, any: 0x6E, eq: 0x6D, i31: 0x6C, struct: 0x6B, array: 0x6A,
+  exn: 0x69, noexn: 0x74, nofunc: 0x73, noextern: 0x72, none: 0x71, func: 0x70, extern: 0x6F, any: 0x6E, eq: 0x6D, i31: 0x6C, struct: 0x6B, array: 0x6A, data: 0x6B,
   cont: 0x68, nocont: 0x75,  // stack switching (Phase 3)
   string: 0x67, stringview_wtf8: 0x66, stringview_wtf16: 0x60, stringview_iter: 0x61,  // stringref
   // Reference type abbreviations (absheaptype abbrs)

package/src/encode.js

@@ -128,16 +128,30 @@ const _u8 = new Uint8Array(_buf), _i32 = new Int32Array(_buf), _f32 = new Float3
 
 i64.parse = n => {
   n = cleanInt(n)
-  n = n[0] === '-' ? -BigInt(n.slice(1)) : BigInt(n) // can be -0x123
-  if (n < -0x8000000000000000n || n > 0xffffffffffffffffn) err(`i64 constant out of range`)
-  _i64[0] = n
+  const neg = n[0] === '-'
+  const body = neg ? n.slice(1) : n
+  // Range check on the literal string before BigInt conversion (lexicographic compare on clean digits).
+  let max
+  if (body[0] === '0' && (body[1] === 'x' || body[1] === 'X')) {
+    const hex = body.slice(2).replace(/^0+/, '') || '0'
+    max = neg ? '8000000000000000' : 'ffffffffffffffff'
+    if (hex.length > 16 || (hex.length === 16 && hex.toLowerCase() > max)) err(`i64 constant out of range`)
+  } else {
+    const dec = body.replace(/^0+/, '') || '0'
+    max = neg ? '9223372036854775808' : '18446744073709551615'
+    if (dec.length > max.length || (dec.length === max.length && dec > max)) err(`i64 constant out of range`)
+  }
+  let bi = BigInt(body)
+  if (neg) bi = 0n - bi
+  _i64[0] = bi
   return _i64[0]
 }
 
-const F32_SIGN = 0x80000000, F32_NAN = 0x7f800000
+const F32_SIGN = 0x80000000, F32_NAN = 0x7f800000, F32_QUIET = 0x400000
 export function f32(input, value, idx) {
-  if (typeof input === 'string' && ~(idx = input.indexOf('nan:'))) {
-    value = i32.parse(input.slice(idx + 4))
+  // Plain `nan` / `-nan` (with optional `:0xPAYLOAD`) — set the bit pattern explicitly.
+  if (typeof input === 'string' && (idx = input.indexOf('nan')) >= 0) {
+    value = input[idx + 3] === ':' ? i32.parse(input.slice(idx + 4)) : F32_QUIET
     value |= F32_NAN
     if (input[0] === '-') value |= F32_SIGN
     _i32[0] = value
@@ -150,10 +164,11 @@ export function f32(input, value, idx) {
   return [_u8[0], _u8[1], _u8[2], _u8[3]]
 }
 
-const F64_SIGN = 0x8000000000000000n, F64_NAN = 0x7ff0000000000000n
+const F64_SIGN = 0x8000000000000000n, F64_NAN = 0x7ff0000000000000n, F64_QUIET = 0x8000000000000n
 export function f64(input, value, idx) {
-  if (typeof input === 'string' && ~(idx = input.indexOf('nan:'))) {
-    value = i64.parse(input.slice(idx + 4))
+  // Plain `nan` / `-nan` (with optional `:0xPAYLOAD`) — set the bit pattern explicitly.
+  if (typeof input === 'string' && (idx = input.indexOf('nan')) >= 0) {
+    value = input[idx + 3] === ':' ? i64.parse(input.slice(idx + 4)) : F64_QUIET
     value |= F64_NAN
     if (input[0] === '-') value |= F64_SIGN
     _i64[0] = value
@@ -179,9 +194,15 @@ f64.parse = (input, max=Number.MAX_VALUE) => {
     let [int, fract=''] = sig.split('.'); // integer and fractional parts
     let flen = fract.length ?? 0;
 
-    // Parse integer part
-    let intVal = parseInt(int); // 0x is included in int
-    isNaN(intVal) && err()
+    // Parse integer part — accumulate from least-significant digit to preserve precision.
+    // parseInt loses low bits for values > 2^53 because left-to-right
+    // accumulation rounds at each step; right-to-left keeps intermediates
+    // small so the final large+small addition rounds correctly.
+    let intVal = 0;
+    for (let i = int.length - 1; i >= 2; i--) {
+      let digit = parseInt(int[i], 16);
+      intVal += digit * (16 ** (int.length - 1 - i));
+    }
 
     // 0x10a.fbc = 0x10afbc * 16⁻³ = 266.9833984375
     // Parse fractional part: fract / 16^flen