porffor 0.57.19 → 0.57.21

package/compiler/assemble.js

@@ -1,61 +1,10 @@
 import { Valtype, FuncType, ExportDesc, Section, Magic, Opcodes, PageSize, Reftype } from './wasmSpec.js';
-import { encodeVector, encodeString, unsignedLEB128, signedLEB128, unsignedLEB128_into, signedLEB128_into, ieee754_binary64, ieee754_binary64_into, unsignedLEB128_length } from './encoding.js';
+import { unsignedLEB128_length, signedLEB128_length } from './encoding.js';
 import { importedFuncs } from './builtins.js';
 import { log } from './log.js';
 import './prefs.js';
 
-const createSection = (type, data) => [
-  type,
-  ...encodeVector(data)
-];
-
-const customSection = (name, data) => createSection(
-  Section.custom,
-  [ ...encodeString(name), ...data ]
-);
-
-const encodeNames = funcs => {
-  const encodeSection = (id, section) => [
-    id,
-    ...unsignedLEB128(section.length),
-    ...section
-  ];
-
-  const moduleSection = encodeString('js'); // TODO: filename?
-  const functionsSection = encodeVector(
-    funcs.map(x => unsignedLEB128(x.asmIndex).concat(encodeString(x.name))),
-  );
-  const localsSection = encodeVector(
-    funcs.map(x => unsignedLEB128(x.asmIndex).concat(encodeVector(
-      Object.entries(x.locals).map(([name, local]) =>
-        unsignedLEB128(local.idx).concat(encodeString(name))
-      )
-    )))
-  );
-
-  return [
-    ...encodeSection(0, moduleSection),
-    ...encodeSection(1, functionsSection),
-    ...encodeSection(2, localsSection),
-  ];
-};
-
 export default (funcs, globals, tags, pages, data, noTreeshake = false) => {
-  const types = [], typeCache = {};
-
-  const getType = (params, returns) => {
-    const hash = `${params.join(',')}_${returns.join(',')}`;
-    if (Prefs.optLog) log('assemble', `getType(${JSON.stringify(params)}, ${JSON.stringify(returns)}) -> ${hash} | cache: ${typeCache[hash]}`);
-    if (typeCache[hash] !== undefined) return typeCache[hash];
-
-    const type = [ FuncType, ...encodeVector(params), ...encodeVector(returns) ];
-    const idx = types.length;
-
-    types.push(type);
-
-    return typeCache[hash] = idx;
-  };
-
   let t = performance.now();
   const time = msg => {
     if (!Prefs.profileAssemble) return;
@@ -64,71 +13,189 @@ export default (funcs, globals, tags, pages, data, noTreeshake = false) => {
     t = performance.now();
   };
 
-  let importFuncs = [], importDelta = 0;
+  let importFuncs = globalThis.importFuncs = [];
+  globalThis.importDelta = 0;
   if (!Prefs.treeshakeWasmImports || noTreeshake) {
     importFuncs = Array.from(importedFuncs);
   } else {
-    let imports = new Map();
-
     // tree shake imports
-    for (const f of funcs) {
-      if (f.usesImports) for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] < importedFuncs.length) {
-          const idx = inst[1];
+    const remap = new WeakMap();
+    for (let i = 0; i < funcs.length; i++) {
+      const f = funcs[i];
+      if (f.usesImports) for (let j = 0; j < f.wasm.length; j++) {
+        const x = f.wasm[j];
+        if (x[0] === Opcodes.call && x[1] < importedFuncs.length) {
+          const idx = x[1];
           const func = importedFuncs[idx];
 
-          if (!imports.has(func.name)) imports.set(func.name, { ...func, idx: imports.size });
-          inst[1] = imports.get(func.name).idx;
+          if (!remap.has(func)) {
+            remap.set(func, importFuncs.length);
+            importFuncs.push(func);
+          }
+          x[1] = remap.get(func);
         }
       }
     }
 
-    importFuncs = globalThis.importFuncs = [...imports.values()];
-    importDelta = importedFuncs.length - importFuncs.length;
+    globalThis.importDelta = importedFuncs.length - importFuncs.length;
+  }
+
+  if (Prefs.optLog) log('assemble', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
+  time('import treeshake');
+
+  // todo: this will just break if it is too small
+  let bufferSize = 1024 * 1024; // 1MB
+  let buffer = new Uint8Array(bufferSize);
+  let offset = 0;
+
+  const ensureBufferSize = added => {
+    if (offset + added >= bufferSize - 64) {
+      const newBuffer = new Uint8Array(bufferSize *= 2);
+      newBuffer.set(buffer);
+      buffer = null; // help gc
+      buffer = newBuffer;
+    }
+  };
+
+  const byte = byte => {
+    ensureBufferSize(1);
+    buffer[offset++] = byte;
+  };
+
+  const array = array => {
+    ensureBufferSize(array.length);
+    buffer.set(array, offset);
+    offset += array.length;
+  };
+
+  const unsigned = n => {
+    n |= 0;
+    if (n >= 0 && n <= 127) return byte(n);
+
+    do {
+      let x = n & 0x7f;
+      n >>>= 7;
+      if (n !== 0) {
+        x |= 0x80;
+      }
+
+      byte(x);
+    } while (n !== 0);
+  };
+
+  const signed = n => {
+    n |= 0;
+    if (n >= 0 && n <= 63) return byte(n);
+
+    while (true) {
+      let x = n & 0x7f;
+      n >>= 7;
+
+      if ((n === 0 && (x & 0x40) === 0) || (n === -1 && (x & 0x40) !== 0)) {
+        byte(x);
+        break;
+      } else {
+        x |= 0x80;
+      }
+
+      byte(x);
+    }
+  };
+
+  const ieee754 = n => {
+    ensureBufferSize(8);
+    array(new Uint8Array(new Float64Array([ n ]).buffer));
+  };
+
+  const string = str => {
+    unsigned(str.length);
+    for (let i = 0; i < str.length; i++) {
+      byte(str.charCodeAt(i));
+    }
+  };
+
+  const section = (id, bytes) => {
+    byte(id);
+    unsigned(bytes);
+  };
+
+  const unsignedPost = () => {
+    const o = offset;
+    offset += 5;
+    return n => {
+      const o2 = offset;
+      offset = o;
+      unsigned(n);
+
+      buffer.set(buffer.subarray(o + 5, o2), offset);
+      offset = o2 - (5 - (offset - o));
+    };
+  };
+
+  array(Magic, Magic.length);
+  time('setup');
+
+  const types = [], typeCache = new Map();
+  const getType = (params, returns) => {
+    const hash = `${params.join()}_${returns.join()}`;
+    if (typeCache.has(hash)) return typeCache.get(hash);
+
+    const type = [ FuncType, params.length, ...params, returns.length, ...returns ];
+    const idx = types.length;
+
+    types.push(type);
+    typeCache.set(hash, idx);
+    return idx;
+  };
+
+  // precache all types to be used
+  for (let i = 0; i < funcs.length; i++) {
+    const func = funcs[i];
+    getType(func.params, func.returns);
   }
 
-  for (const f of funcs) {
-    f.asmIndex = f.index - importDelta;
+  for (let i = 0; i < importFuncs.length; i++) {
+    const func = importFuncs[i];
+    getType(func.params, func.returns);
   }
 
-  if (Prefs.optLog) log('assemble', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
+  for (let i = 0; i < tags.length; i++) {
+    const tag = tags[i];
+    getType(tag.params, tag.results);
+  }
 
-  const importSection = importFuncs.length === 0 ? [] : createSection(
-    Section.import,
-    encodeVector(importFuncs.map(x => {
-      return [
-        0, 1, x.import.charCodeAt(0),
-        ExportDesc.func,
-        getType(x.params, x.returns)
-      ];
-    }))
-  );
+  section(Section.type, unsignedLEB128_length(types.length) + types.reduce((acc, x) => acc + x.length, 0));
+  unsigned(types.length);
+  for (let i = 0; i < types.length; i++) {
+    array(types[i]);
+  }
+  time('type section');
+
+  if (importFuncs.length > 0) {
+    section(Section.import, unsignedLEB128_length(importFuncs.length) + importFuncs.length * 5);
+    unsigned(importFuncs.length);
+    for (let i = 0; i < importFuncs.length; i++) {
+      const x = importFuncs[i];
+      byte(0); byte(1);
+      byte(x.import.charCodeAt(0));
+      byte(ExportDesc.func);
+      byte(getType(x.params, x.returns));
+    }
+  }
   time('import section');
 
-  const funcSection = createSection(
-    Section.func,
-    encodeVector(funcs.map(x => getType(x.params, x.returns))) // type indexes
-  );
-  time('func section');
+  const indirectFuncs = [], exportFuncs = [];
 
-  const nameSection = Prefs.d ? customSection('name', encodeNames(funcs)) : [];
-
-  const indirectFuncs = funcs.filter(x => x.indirect);
-  const tableSection = !funcs.table ? [] : createSection(
-    Section.table,
-    encodeVector([ [ Reftype.funcref, 0x00, ...unsignedLEB128(indirectFuncs.length) ] ])
-  );
-  time('table section');
-
-  const elementSection = !funcs.table ? [] : createSection(
-    Section.element,
-    encodeVector([ [
-      0x00,
-      Opcodes.i32_const, 0, Opcodes.end,
-      ...encodeVector(indirectFuncs.map(x => unsignedLEB128(x.asmIndex)))
-    ] ])
-  );
-  time('element section');
+  section(Section.func, unsignedLEB128_length(funcs.length) + funcs.length);
+  unsigned(funcs.length);
+  for (let i = 0; i < funcs.length; i++) {
+    const x = funcs[i];
+    byte(getType(x.params, x.returns));
+
+    if (x.indirect) indirectFuncs.push(x);
+    if (x.export) exportFuncs.push(x);
+  }
+  time('func section');
 
   if (pages.has('func lut')) {
     if (data.addedFuncArgcLut) {
@@ -182,285 +249,276 @@ export default (funcs, globals, tags, pages, data, noTreeshake = false) => {
   }
   time('func lut');
 
-  // specially optimized assembly for globals as this version is much (>5x) faster than traditional createSection()
-  const globalsValues = Object.values(globals);
+  if (funcs.table) {
+    section(Section.table, unsignedLEB128_length(indirectFuncs.length) + 3);
+    byte(1); // table count
+    byte(Reftype.funcref); byte(0); // table type
+    unsigned(indirectFuncs.length); // table size
+    time('table section');
+  }
 
-  let globalSection = [];
+  if (Prefs.alwaysMemory && pages.size === 0) pages.set('--always-memory', 0);
+  const usesMemory = pages.size > 0;
+  if (usesMemory) {
+    const pageCount = Math.ceil((pages.size * pageSize) / PageSize);
+    section(Section.memory, unsignedLEB128_length(pageCount) + 2);
+    byte(1); // memory count
+    byte(0); // memory type
+    unsigned(pageCount); // memory size
+    time('memory section');
+  }
+
+  const usesTags = tags.length > 0;
+  if (usesTags) {
+    section(Section.tag, unsignedLEB128_length(tags.length) + tags.length * 2);
+    unsigned(tags.length);
+    for (let i = 0; i < tags.length; i++) {
+      const x = tags[i];
+      byte(0); // tag type
+      byte(getType(x.params, x.results)); // tag signature
+    }
+    time('tag section');
+  }
+
+  const globalsValues = Object.values(globals);
   if (globalsValues.length > 0) {
-    let data = unsignedLEB128(globalsValues.length);
+    section(Section.global, unsignedLEB128_length(globalsValues.length) + globalsValues.length * 4
+      + globalsValues.reduce((acc, x) => acc + (x.type === Valtype.f64 ? 8 : signedLEB128_length(x.init ?? 0)), 0));
+    unsigned(globalsValues.length);
     for (let i = 0; i < globalsValues.length; i++) {
-      const global = globalsValues[i];
-
-      switch (global.type) {
+      const x = globalsValues[i];
+      switch (x.type) {
         case Valtype.i32:
-          if (i > 0) data.push(Opcodes.end, Valtype.i32, 0x01, Opcodes.i32_const);
-            else data.push(Valtype.i32, 0x01, Opcodes.i32_const);
-
-          signedLEB128_into(global.init ?? 0, data);
+          byte(Valtype.i32);
+          byte(0x01);
+          byte(Opcodes.i32_const);
+          signed(x.init ?? 0);
           break;
 
         case Valtype.i64:
-          if (i > 0) data.push(Opcodes.end, Valtype.i64, 0x01, Opcodes.i64_const);
-            else data.push(Valtype.i64, 0x01, Opcodes.i64_const);
-
-          signedLEB128_into(global.init ?? 0, data);
+          byte(Valtype.i64);
+          byte(0x01);
+          byte(Opcodes.i64_const);
+          signed(x.init ?? 0);
           break;
 
         case Valtype.f64:
-          if (i > 0) data.push(Opcodes.end, Valtype.f64, 0x01, Opcodes.f64_const);
-            else data.push(Valtype.f64, 0x01, Opcodes.f64_const);
-
-          ieee754_binary64_into(global.init ?? 0, data);
+          byte(Valtype.f64);
+          byte(0x01);
+          byte(Opcodes.f64_const);
+          ieee754(x.init ?? 0);
           break;
       }
+
+      byte(Opcodes.end);
     }
+    time('global section');
+  }
 
-    data.push(Opcodes.end);
+  if (exportFuncs.length > 0 || usesMemory || usesTags) {
+    byte(Section.export);
+    const sizeOffset = offset, setSize = unsignedPost();
 
-    globalSection.push(Section.global);
+    unsigned(exportFuncs.length + usesMemory + usesTags);
+    if (usesMemory) {
+      string('$');
+      byte(ExportDesc.mem); byte(0);
+    }
+    if (usesTags) {
+      string('0');
+      byte(ExportDesc.tag); byte(0);
+    }
 
-    unsignedLEB128_into(data.length, globalSection);
-    globalSection = globalSection.concat(data);
+    for (let i = 0; i < exportFuncs.length; i++) {
+      const x = exportFuncs[i];
+      string(x.name === '#main' ? 'm' : x.name);
+      byte(ExportDesc.func);
+      unsigned(x.index - importDelta);
+    }
+
+    setSize(offset - sizeOffset - 5);
+    time('export section');
   }
-  time('global section');
 
-  if (Prefs.alwaysMemory && pages.size === 0) pages.set('--always-memory', 0);
+  if (funcs.table) {
+    section(Section.element, unsignedLEB128_length(indirectFuncs.length) + 5 + indirectFuncs.reduce((acc, x) => acc + unsignedLEB128_length(x.index - importDelta), 0));
+    byte(1); // table index
+    byte(0); // element type
+    byte(Opcodes.i32_const); byte(0); byte(Opcodes.end); // offset
 
-  const usesMemory = pages.size > 0;
-  const memorySection = !usesMemory ? [] : createSection(
-    Section.memory,
-    encodeVector([ [ 0x00, ...unsignedLEB128(Math.ceil((pages.size * pageSize) / PageSize)) ] ])
-  );
-  time('memory section');
-
-  const exports = funcs.filter(x => x.export).map((x, i) => [ ...encodeString(x.name === '#main' ? 'm' : x.name), ExportDesc.func, ...unsignedLEB128(x.asmIndex) ]);
-
-  // export memory if used
-  if (usesMemory) exports.unshift([ ...encodeString('$'), ExportDesc.mem, 0x00 ]);
-  time('gen exports');
-
-  const tagSection = tags.length === 0 ? [] : createSection(
-    Section.tag,
-    encodeVector(tags.map(x => [ 0x00, getType(x.params, x.results) ]))
-  );
-
-  // export first tag if used
-  if (tags.length !== 0) exports.unshift([ ...encodeString('0'), ExportDesc.tag, 0x00 ]);
-  time('tag section');
-
-  const exportSection = createSection(
-    Section.export,
-    encodeVector(exports)
-  );
-  time('export section');
-
-  let codeSection = [];
+    unsigned(indirectFuncs.length);
+    for (let i = 0; i < indirectFuncs.length; i++) {
+      const x = indirectFuncs[i];
+      unsigned(x.index - importDelta);
+    }
+    time('element section');
+  }
+
+  if (data.length > 0) {
+    section(Section.data_count, unsignedLEB128_length(data.length));
+    unsigned(data.length);
+    time('data count section');
+  }
+
+  byte(Section.code);
+  const codeSectionSizeOffset = offset, setCodeSectionSize = unsignedPost();
+
+  unsigned(funcs.length);
   for (let i = 0; i < funcs.length; i++) {
+    const funcSizeOffset = offset, setFuncSize = unsignedPost();
+
     const x = funcs[i];
     const locals = Object.values(x.locals).sort((a, b) => a.idx - b.idx);
 
     const paramCount = x.params.length;
-    let localDecl = [], typeCount = 0, lastType, declCount = 0;
+    let declCount = 0, lastType, typeCount = 0;
     for (let i = paramCount; i <= locals.length; i++) {
       const local = locals[i];
-      if (i !== paramCount && local?.type !== lastType) {
-        unsignedLEB128_into(typeCount, localDecl);
-        localDecl.push(lastType);
-        typeCount = 0;
+      if (lastType && local?.type !== lastType) {
         declCount++;
       }
 
-      typeCount++;
       lastType = local?.type;
     }
+    unsigned(declCount);
 
-    let wasm = [], wasmNonFlat = [];
-    if (Prefs.d) {
-      for (let i = 0; i < x.wasm.length; i++) {
-        let o = x.wasm[i];
-
-        // encode local/global ops as unsigned leb128 from raw number
-        if (
-          (o[0] >= Opcodes.local_get && o[0] <= Opcodes.global_set) &&
-          o[1] > 127
-        ) {
-          const n = o[1];
-          o = [ o[0] ];
-          unsignedLEB128_into(n, o);
-        }
-
-        // encode f64.const ops as ieee754 from raw number
-        if (o[0] === Opcodes.f64_const) {
-          const n = o[1];
-          o = ieee754_binary64(n);
-          if (o.length === 8) o.unshift(Opcodes.f64_const);
-        }
-
-        // encode call ops as unsigned leb128 from raw number
-        if ((o[0] === Opcodes.call /* || o[0] === Opcodes.return_call */) && o[1] >= importedFuncs.length) {
-          const n = o[1] - importDelta;
-          o = [ Opcodes.call ];
-          unsignedLEB128_into(n, o);
-        }
-
-        // encode call indirect ops as types from info
-        if (o[0] === Opcodes.call_indirect) {
-          o = [...o];
-          const params = [];
-          for (let i = 0; i < o[1]; i++) {
-            params.push(valtypeBinary, Valtype.i32);
-          }
-
-          let returns = [ valtypeBinary, Valtype.i32 ];
-          if (o.at(-1) === 'no_type_return') {
-            o.pop();
-            returns = [ valtypeBinary ];
-          }
-
-          o[1] = getType(params, returns);
-        }
+    lastType = undefined;
+    for (let i = paramCount; i <= locals.length; i++) {
+      const local = locals[i];
+      if (lastType && local?.type !== lastType) {
+        unsigned(typeCount);
+        byte(lastType);
+        typeCount = 0;
+      }
 
-        for (let j = 0; j < o.length; j++) {
-          const x = o[j];
-          if (x == null || !(x <= 0xff)) continue;
-          wasm.push(x);
-        }
+      typeCount++;
+      lastType = local?.type;
+    }
 
-        wasmNonFlat.push(o);
+    for (let i = 0; i < x.wasm.length; i++) {
+      let o = x.wasm[i];
+      const op = o[0];
+
+      // encode local/global ops as unsigned leb128 from raw number
+      if (
+        (op >= Opcodes.local_get && op <= Opcodes.global_set) &&
+        o[1] > 127
+      ) {
+        byte(op);
+        unsigned(o[1]);
+        continue;
       }
 
-      x.assembled = { localDecl, wasm, wasmNonFlat };
-    } else {
-      for (let i = 0; i < x.wasm.length; i++) {
-        let o = x.wasm[i];
-        const op = o[0];
-
-        // encode local/global ops as unsigned leb128 from raw number
-        if (
-          (op >= Opcodes.local_get && op <= Opcodes.global_set) &&
-          o[1] > 127
-        ) {
-          wasm.push(op);
-          unsignedLEB128_into(o[1], wasm);
-          continue;
-        }
+      // encode f64.const ops as ieee754 from raw number
+      if (op === Opcodes.f64_const) {
+        byte(op);
+        ieee754(o[1]);
+        continue;
+      }
 
-        // encode f64.const ops as ieee754 from raw number
-        if (op === Opcodes.f64_const) {
-          wasm.push(op);
-          ieee754_binary64_into(o[1], wasm);
-          continue;
-        }
+      // encode call ops as unsigned leb128 from raw number
+      if ((op === Opcodes.call /* || o[0] === Opcodes.return_call */) && o[1] >= importedFuncs.length) {
+        byte(op);
+        unsigned(o[1] - importDelta);
+        continue;
+      }
 
-        // encode call ops as unsigned leb128 from raw number
-        if ((op === Opcodes.call /* || o[0] === Opcodes.return_call */) && o[1] >= importedFuncs.length) {
-          wasm.push(op);
-          unsignedLEB128_into(o[1] - importDelta, wasm);
-          continue;
+      // encode call indirect ops as types from info
+      if (op === Opcodes.call_indirect) {
+        const params = [];
+        for (let i = 0; i < o[1]; i++) {
+          params.push(valtypeBinary, Valtype.i32);
         }
 
-        // encode call indirect ops as types from info
-        if (op === Opcodes.call_indirect) {
-          const params = [];
-          for (let i = 0; i < o[1]; i++) {
-            params.push(valtypeBinary, Valtype.i32);
-          }
-
-          let returns = [ valtypeBinary, Valtype.i32 ];
-          if (o.at(-1) === 'no_type_return') {
-            returns = [ valtypeBinary ];
-          }
-
-          wasm.push(op, getType(params, returns), o[2]);
-          continue;
-        }
+        byte(op);
+        byte(getType(params, [ valtypeBinary, Valtype.i32 ]));
+        byte(o[2]);
+        continue;
+      }
 
-        for (let j = 0; j < o.length; j++) {
-          const x = o[j];
-          if (x == null || !(x <= 0xff)) continue;
-          wasm.push(x);
-        }
+      for (let j = 0; j < o.length; j++) {
+        const x = o[j];
+        if (x == null || !(x <= 0xff)) continue;
+        buffer[offset++] = x;
       }
     }
 
-    if (wasm.length > 100000) {
-      // slow path for handling large arrays which break v8 due to running out of stack size
-      const out = unsignedLEB128(declCount)
-        .concat(localDecl, wasm, Opcodes.end);
-      codeSection = codeSection.concat(unsignedLEB128(out.length), out);
-    } else {
-      codeSection.push(
-        ...unsignedLEB128(unsignedLEB128_length(declCount) + localDecl.length + wasm.length + 1),
-        ...unsignedLEB128(declCount),
-        ...localDecl,
-        ...wasm,
-        Opcodes.end
-      );
+    byte(Opcodes.end);
+    setFuncSize(offset - funcSizeOffset - 5);
+  }
+
+  setCodeSectionSize(offset - codeSectionSizeOffset - 5);
+  time('code section');
+
+  section(Section.data, unsignedLEB128_length(data.length) + data.reduce((acc, x) =>
+    acc + (x.page != null ? (3 + signedLEB128_length(pages.allocs.get(x.page) ?? (pages.get(x.page) * pageSize))) : 1)
+    + unsignedLEB128_length(x.bytes.length) + x.bytes.length, 0));
+
+  unsigned(data.length);
+  for (let i = 0; i < data.length; i++) {
+    const x = data[i];
+    if (x.page != null) { // active
+      let offset = pages.allocs.get(x.page) ?? (pages.get(x.page) * pageSize);
+      if (offset === 0) offset = 16;
+
+      byte(0x00);
+      byte(Opcodes.i32_const);
+      signed(offset);
+      byte(Opcodes.end);
+    } else { // passive
+      byte(0x01);
     }
 
-    // globalThis.progress?.(`${i}/${funcs.length}`);
+    unsigned(x.bytes.length);
+    array(x.bytes);
   }
+  time('data section');
 
-  codeSection.unshift(...unsignedLEB128(funcs.length, codeSection));
-  codeSection.unshift(Section.code, ...unsignedLEB128(codeSection.length));
-  time('code section');
+  if (Prefs.d) {
+    byte(Section.custom);
+    const totalSizeOffset = offset, setTotalSize = unsignedPost();
+    string('name');
 
-  const typeSection = createSection(
-    Section.type,
-    encodeVector(types)
-  );
-  time('type section');
+    const section = (id, cb) => {
+      byte(id);
+      const sizeOffset = offset, setSize = unsignedPost();
+      cb();
+      setSize(offset - sizeOffset - 5);
+    };
 
-  let dataSection = [];
-  if (data.length > 0) {
-    for (let i = 0; i < data.length; i++) {
-      const x = data[i];
-      if (Prefs.d && x.bytes.length > PageSize) log.warning('assemble', `data (${x.page}) has more bytes than Wasm page size! (${x.bytes.length})`);
-
-      if (x.page != null) {
-        // type: active
-        let offset = pages.allocs.get(x.page) ?? (pages.get(x.page) * pageSize);
-        if (offset === 0) offset = 16;
-        dataSection.push(0x00, Opcodes.i32_const, ...signedLEB128(offset), Opcodes.end);
-      } else {
-        // type: passive
-        dataSection.push(0x01);
+    section(0, () => { // module
+      string('js'); // todo: filename?
+    });
+
+    section(1, () => { // funcs
+      unsigned(funcs.length);
+      for (let i = 0; i < funcs.length; i++) {
+        const x = funcs[i];
+        unsigned(x.index - importDelta);
+        string(x.name);
       }
+    });
 
-      if (x.bytes.length > 100000) {
-        codeSection = codeSection.concat(unsignedLEB128(x.bytes.length), x.bytes);
-      } else {
-        dataSection.push(
-          ...unsignedLEB128(x.bytes.length),
-          ...x.bytes
-        );
+    section(2, () => { // locals
+      unsigned(funcs.length);
+      for (let i = 0; i < funcs.length; i++) {
+        const x = funcs[i];
+        unsigned(x.index - importDelta);
+
+        const locals = Object.keys(x.locals);
+        unsigned(locals.length);
+        for (let j = 0; j < locals.length; j++) {
+          const name = locals[j];
+          unsigned(x.locals[name]);
+          string(name);
+        }
       }
-    }
+    });
 
-    dataSection.unshift(...unsignedLEB128(data.length, dataSection));
-    dataSection.unshift(Section.data, ...unsignedLEB128(dataSection.length));
+    setTotalSize(offset - totalSizeOffset - 5);
+    time('name section');
   }
 
-  const dataCountSection = data.length === 0 ? [] : createSection(
-    Section.data_count,
-    unsignedLEB128(data.length)
-  );
-  time('data section');
-
-  return Uint8Array.from([
-    ...Magic,
-    ...typeSection,
-    ...importSection,
-    ...funcSection,
-    ...tableSection,
-    ...memorySection,
-    ...tagSection,
-    ...globalSection,
-    ...exportSection,
-    ...elementSection,
-    ...dataCountSection,
-    ...codeSection,
-    ...dataSection,
-    ...nameSection
-  ]);
+  buffer = buffer.subarray(0, offset);
+  return buffer;
 };

package/compiler/codegen.js

@@ -2516,6 +2516,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     const wrapperArgc = Prefs.indirectWrapperArgc ?? 10;
     const underflow = wrapperArgc - args.length;
     for (let i = 0; i < underflow; i++) args.push(DEFAULT_VALUE());
+    if (args.length > wrapperArgc) args = args.slice(0, wrapperArgc);
 
     for (let i = 0; i < args.length; i++) {
       const arg = args[i];
@@ -2715,9 +2716,7 @@ const generateThis = (scope, decl) => {
 
   if (!scope.constr && !scope.method) {
     // this in a non-constructor context is a reference to globalThis
-    return [
-      ...generate(scope, { type: 'Identifier', name: 'globalThis' })
-    ];
+    return generate(scope, { type: 'Identifier', name: 'globalThis' });
   }
 
   // opt: do not check for pure constructors or strict mode

package/compiler/encoding.js

@@ -84,6 +84,28 @@ export const unsignedLEB128_length = n => {
   return length;
 };
 
+export const signedLEB128_length = n => {
+  if (n >= -64 && n <= 63) return 1;
+  if (n >= -8192 && n <= 8191) return 2;
+  if (n >= -1048576 && n <= 1048575) return 3;
+  if (n >= -134217728 && n <= 134217727) return 4;
+
+  let length = 0;
+  while (true) {
+    let byte = n & 0x7f;
+    n >>= 7;
+
+    if ((n === 0 && (byte & 0x40) === 0) || (n === -1 && (byte & 0x40) !== 0)) {
+      length++;
+      break;
+    } else {
+      length++;
+    }
+  }
+
+  return length;
+};
+
 export const big_signedLEB128 = n => {
   // just input for small numbers (for perf as common)
   if (n >= 0n && n <= 63n) return [ Number(n) ];

package/compiler/wrap.js

@@ -401,7 +401,7 @@ export default (source, module = undefined, customImports = {}, print = str => p
     const surrounding = Prefs.backtraceSurrounding ?? 10;
     let min = middleIndex - surrounding;
     let max = middleIndex + surrounding + 1;
-    if (Prefs.backtraceFunc || middleIndex == -1) {
+    if (Prefs.backtraceFunc || middleIndex === -1) {
       min = 0;
       max = func.wasm.length;
     }
@@ -415,7 +415,7 @@ export default (source, module = undefined, customImports = {}, print = str => p
       longest = Math.max(longest, noAnsi(disasm[j])?.length ?? 0);
     }
 
-    if (middleIndex != -1) {
+    if (middleIndex !== -1) {
       const middle = Math.floor(disasm.length / 2);
       disasm[middle] = `\x1B[47m\x1B[30m${noAnsi(disasm[middle])}${'\u00a0'.repeat(longest - noAnsi(disasm[middle]).length)}\x1B[0m`;
     }
@@ -429,47 +429,11 @@ export default (source, module = undefined, customImports = {}, print = str => p
     if (funcInd == null || blobOffset == null ||
         Number.isNaN(funcInd) || Number.isNaN(blobOffset) || Prefs.backtrace === false) return false;
 
-    // convert blob offset -> function wasm offset
-    const func = funcs.find(x => x.asmIndex === funcInd);
+    const func = funcs.find(x => (x.index - importDelta) === funcInd);
     if (!func) return false;
 
-    const { wasm: assembledWasmFlat, wasmNonFlat: assembledWasmOps, localDecl } = func.assembled;
-    const toFind = encodeVector(localDecl).concat(assembledWasmFlat.slice(0, 100));
-
-    let i = 0;
-    for (; i < wasm.length; i++) {
-      let mismatch = false;
-      for (let j = 0; j < toFind.length; j++) {
-        if (wasm[i + j] !== toFind[j]) {
-          mismatch = true;
-          break;
-        }
-      }
-
-      if (!mismatch) break;
-    }
-
-    if (i === wasm.length) {
-      printBacktrace(-1, func, funcs, globals, exceptions);
-      return false;
-    }
-
-    const offset = (blobOffset - i) - encodeVector(localDecl).length;
-
-    let cumLen = 0;
-    i = 0;
-    for (; i < assembledWasmOps.length; i++) {
-      cumLen += assembledWasmOps[i].filter(x => x != null && x <= 0xff).length;
-      if (cumLen === offset) break;
-    }
-
-    if (cumLen !== offset) {
-      printBacktrace(-1, func, funcs, globals, exceptions);
-      return false;
-    }
-
-    printBacktrace(i + 1, func, funcs, globals, exceptions);
-    return true;
+    printBacktrace(-1, func, funcs, globals, exceptions);
+    return false;
   };
 
   const t2 = performance.now();

package/foo.js

@@ -1 +1,17 @@
-console.log(process.argv);
+import compile from './compiler/wrap.js';
+import { Worker, isMainThread } from 'node:worker_threads';
+
+import { join } from 'node:path';
+const __dirname = import.meta.dirname;
+const __filename = join(__dirname, 'foo.js');
+
+if (isMainThread) {
+  const worker = new Worker(__filename);
+} else {
+  for (let i = 0; i < 500; i++) {
+    const js = `console.log(globalThis);`;
+    const out = compile(js);
+    out.exports.main();
+    console.log(i);
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.57.19",
+  "version": "0.57.21",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/r.js

@@ -0,0 +1,243 @@
+function isConfigurable(obj, name) {
+  if (Object.hasOwn(obj, name)) return Object.getOwnPropertyDescriptor(obj, name).configurable;
+  return true;
+}
+
+function isEnumerable(obj, name) {
+  return Object.hasOwn(obj, name) && Object.getOwnPropertyDescriptor(obj, name).enumerable;
+}
+
+function isSameValue(a, b) {
+  if (a === 0 && b === 0) return 1 / a === 1 / b;
+  if (a !== a && b !== b) return true;
+
+  return a === b;
+}
+
+function isWritable(obj, name, verifyProp, value) {
+  if (Object.hasOwn(obj, name) && Object.getOwnPropertyDescriptor(obj, name).writable != null) return Object.getOwnPropertyDescriptor(obj, name).writable;
+  if (!Object.hasOwn(obj, name) && Object.isExtensible(obj)) return true;
+
+  var unlikelyValue = Array.isArray(obj) && name === "length" ?
+    Math.pow(2, 32) - 1 :
+    "unlikelyValue";
+  var newValue = value || unlikelyValue;
+  var hadValue = Object.hasOwn(obj, name);
+  var oldValue = obj[name];
+  var writeSucceeded;
+
+  try {
+    obj[name] = newValue;
+  } catch {}
+
+  writeSucceeded = isSameValue(obj[verifyProp || name], newValue);
+
+  if (writeSucceeded) {
+    if (hadValue) {
+      obj[name] = oldValue;
+    } else {
+      delete obj[name];
+    }
+  }
+
+  return writeSucceeded;
+}
+
+function verifyProperty(obj, name, desc, options) {
+  var originalDesc = Object.getOwnPropertyDescriptor(obj, name);
+
+  if (desc === undefined) {
+    if (originalDesc !== undefined) {
+      throw new Test262Error('verifyProperty: expected undefined descriptor');
+    }
+
+    return true;
+  }
+
+  if (!Object.hasOwn(obj, name)) throw new Test262Error('verifyProperty: obj should have own property');
+
+  if (Object.hasOwn(desc, 'value')) {
+    const v = desc.value;
+    if (!isSameValue(originalDesc.value, v)) throw new Test262Error('verifyProperty: descriptor value mismatch');
+    // if (!isSameValue(obj[name], v)) throw new Test262Error('verifyProperty: object value mismatch');
+  }
+
+  if (Object.hasOwn(desc, 'enumerable')) {
+    if (desc.enumerable !== originalDesc.enumerable ||
+        desc.enumerable !== isEnumerable(obj, name)) {
+      throw new Test262Error('enumerable fail');
+    }
+  }
+
+  if (Object.hasOwn(desc, 'writable')) {
+    if (desc.writable !== originalDesc.writable ||
+        desc.writable !== isWritable(obj, name)) {
+      throw new Test262Error('writable fail');
+    }
+  }
+
+  if (Object.hasOwn(desc, 'configurable')) {
+    if (desc.configurable !== originalDesc.configurable ||
+        desc.configurable !== isConfigurable(obj, name)) {
+      throw new Test262Error('configurable fail');
+    }
+  }
+
+  if (options && options.restore) {
+    Object.defineProperty(obj, name, originalDesc);
+  }
+
+  return true;
+}
+
+function verifyEqualTo(obj, name, value) {
+  if (!isSameValue(obj[name], value)) {
+    throw new Test262Error('propertyHelper verifyEqualTo failed');
+  }
+}
+
+function verifyWritable(obj, name, verifyProp, value) {
+  if (!verifyProp) {
+    if (!Object.getOwnPropertyDescriptor(obj, name).writable)
+      throw new Test262Error('propertyHelper verifyWritable failed');
+  }
+
+  if (!isWritable(obj, name, verifyProp, value)) {
+    throw new Test262Error('propertyHelper verifyWritable failed');
+  }
+}
+
+function verifyNotWritable(obj, name, verifyProp, value) {
+  if (!verifyProp) {
+    if (Object.getOwnPropertyDescriptor(obj, name).writable)
+      throw new Test262Error('propertyHelper verifyNotWritable failed');
+  }
+
+  if (isWritable(obj, name, verifyProp)) {
+    throw new Test262Error('propertyHelper verifyNotWritable failed');
+  }
+}
+
+function verifyEnumerable(obj, name) {
+  if (!isEnumerable(obj, name)) {
+    throw new Test262Error('propertyHelper verifyEnumerable failed');
+  }
+}
+
+function verifyNotEnumerable(obj, name) {
+  if (isEnumerable(obj, name)) {
+    throw new Test262Error('propertyHelper verifyNotEnumerable failed');
+  }
+}
+
+function verifyConfigurable(obj, name) {
+  if (!isConfigurable(obj, name)) {
+    throw new Test262Error('propertyHelper verifyConfigurable failed');
+  }
+}
+
+function verifyNotConfigurable(obj, name) {
+  if (isConfigurable(obj, name)) {
+    throw new Test262Error('propertyHelper verifyNotConfigurable failed');
+  }
+}
+var assert = mustBeTrue => {
+  if (mustBeTrue === true) {
+    return;
+  }
+
+  throw new Test262Error('assert failed');
+};
+assert; // idk why exactly but this fixes many tests by forcing indirect ref
+
+var __assert_throws = (expectedErrorConstructor, func) => {
+  if (typeof func !== 'function') {
+    throw new Test262Error('assert.throws invoked with a non-function value');
+  }
+
+  try {
+    func();
+  } catch {
+    return;
+  }
+
+  throw new Test262Error('assert.throws failed');
+};
+
+var __assert__isSameValue = (a, b) => {
+  if (a === b) {
+    // Handle +/-0 vs. -/+0
+    return a !== 0 || 1 / a === 1 / b;
+  }
+
+  // Handle NaN vs. NaN
+  return a !== a && b !== b;
+};
+
+var __assert_sameValue = (actual, expected) => {
+  if (assert._isSameValue(actual, expected)) {
+    return;
+  }
+
+  throw new Test262Error('assert.sameValue failed');
+};
+
+var __assert_notSameValue = (actual, unexpected) => {
+  if (!assert._isSameValue(actual, unexpected)) {
+    return;
+  }
+
+  throw new Test262Error('assert.notSameValue failed');
+};
+// define our $262 here too
+// var $262 = {
+//   global: globalThis,
+//   gc() { /* noop */ },
+//   detachArrayBuffer(buffer) {
+//     return Porffor.arraybuffer.detach(buffer);
+//   },
+//   getGlobal(name) {
+//     return globalThis[name];
+//   },
+//   // todo: setGlobal
+//   destroy() { /* noop */ },
+//   agent: {}
+// };
+
+// function Test262Error(message) {
+//   this.message = message;
+//   this.name = 'Test262Error';
+// }
+
+// var __Test262Error_thrower = message => {
+//   throw new Test262Error(message);
+// };
+
+var $DONOTEVALUATE = () => {
+  throw 'Test262: This statement should not be evaluated.';
+};
+// Copyright (C) 2019 Aleksey Shvayka. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-array-constructor
+description: >
+  Property descriptor of Array
+info: |
+  22.1.1 The Array Constructor
+
+  * is the initial value of the Array property of the global object.
+
+  17 ECMAScript Standard Built-in Objects
+
+  Every other data property described in clauses 18 through 26 and in Annex B.2
+  has the attributes { [[Writable]]: true, [[Enumerable]]: false,
+  [[Configurable]]: true } unless otherwise specified.
+includes: [propertyHelper.js]
+---*/
+
+verifyProperty(this, 'Array', {
+  value: Array,
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});

package/runtime/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.57.19';
+globalThis.version = '0.57.21';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {