compiler: make OHM_DEBUG a compile-time-only option (#595)

Author: pdubroy

packages/compiler/scripts/bootstrap.ts

@@ -38,7 +38,9 @@ try {
   const g = ohm.grammar(source);
 
   // Compile to WASM.
-  const bytes = new Compiler(g).compile();
+  // Never include debug imports in the metagrammar — it's loaded via the
+  // sync Grammar constructor which doesn't support debug imports.
+  const bytes = new Compiler(g, {debug: false}).compile();
 
   // Write the raw .wasm file.
   writeFileSync(wasmPath, bytes);

packages/compiler/scripts/bundlewasm.ts

@@ -6,8 +6,6 @@ import * as w from '@wasmgroundup/emit';
 
 import {extractSections} from './modparse.ts';
 
-const importAdjust = process.env.OHM_DEBUG === '1' ? 10000 : 0;
-
 /*
   Extracts the code section from the AssemblyScript release build
   and writes it to a .ts module in the same directory.
@@ -17,18 +15,10 @@ const inputPath = process.argv[2];
 const outputPath = inputPath + '_sections.ts';
 
 const buf = fs.readFileSync(inputPath);
-const sections = extractSections(buf, {
-  destImportCountAdjustment: importAdjust,
-});
-
-// We've rewritten every funcidx in the function bodies to account for a
-// specific number of imports in the dest module. We record that number
-// to enable a run-time check that the final module is compatible.
-const destImportCount = importAdjust + sections.importsec.entryCount;
+const sections = extractSections(buf);
 
 let output = `const decodeBase64 = (str: string) => Array.from(atob(str), c => c.charCodeAt(0));
 
-export const destImportCount = ${destImportCount};
 export const startFuncidx = ${sections.startFuncidx};
 `;
 

packages/compiler/scripts/modparse.ts

@@ -1,18 +1,10 @@
-import {decodeULEB128, decodeSLEB128} from '@thi.ng/leb128';
+import {decodeULEB128} from '@thi.ng/leb128';
 import * as w from '@wasmgroundup/emit';
 
 import assert from 'node:assert';
 
 const textDecoder = new TextDecoder();
 
-// For sanity checking, assume that the number of locals is never
-// above a certain number. (We can raise this if necessary.)
-const MAX_LOCALS = 64;
-
-const WASM_NUMTYPES = [0x7c, 0x7d, 0x7e, 0x7f];
-const WASM_VECTYPE = 0x7b;
-const WASM_REFTYPES = [0x6f, 0x70];
-
 function checkNotNull<T>(x: T): NonNullable<T> {
   assert(x !== null, 'unexpected null value');
   return x as NonNullable<T>;
@@ -35,25 +27,11 @@ function skipPreamble(bytes: Uint8Array): void {
   }
 }
 
-function isValtype(t: number): boolean {
-  return WASM_NUMTYPES.includes(t) || WASM_VECTYPE === t || WASM_REFTYPES.includes(t);
-}
-
-function checkValtype(t: number): number {
-  assert(isValtype(t), `unrecognized valtype: 0x${t.toString(16).padStart(2, '0')}`);
-  return t;
-}
-
 function checkU32(b: bigint): number {
   assert(b >= 0n && b < 2n ** 32n, `not a valid U32 value: ${b}`);
   return Number(b);
 }
 
-function checkI32(b: bigint): number {
-  assert(b >= -(2n ** 31n) && b < 2n ** 31n, `not a valid I32 value: ${b}`);
-  return Number(b);
-}
-
 export type VecContents = {
   entryCount: number;
   contents: Uint8Array;
@@ -67,13 +45,8 @@ export type RawContents = {
   contents: Uint8Array;
 };
 
-interface ExtractOptions {
-  // The number of extra imports int the dest module.
-  destImportCountAdjustment?: number;
-}
-
 // Extracts the type, import, function, global, and code sections from a Wasm module.
-export function extractSections(bytes: Uint8Array, opts: ExtractOptions = {}) {
+export function extractSections(bytes: Uint8Array) {
   skipPreamble(bytes);
 
   const parseU32 = () => {
@@ -96,7 +69,7 @@ export function extractSections(bytes: Uint8Array, opts: ExtractOptions = {}) {
   // Parse the export section. Returns {funcs, globals} maps of {name: idx}.
   // `funcidxAdjustment` adjusts function indices to account for the dest
   // module having more imports than the source module.
-  function parseExportSection(expectedId: number, funcidxAdjustment: number) {
+  function parseExportSection(expectedId: number) {
     const id = bytes[pos++];
     assert(id === expectedId, `expected section with id ${expectedId}, got ${id}`);
     const size = parseU32();
@@ -119,10 +92,8 @@ export function extractSections(bytes: Uint8Array, opts: ExtractOptions = {}) {
       const index = parseU32();
 
       if (kind === 0x00) {
-        // Function export: adjust index for dest import count.
-        funcs[name] = index + funcidxAdjustment;
+        funcs[name] = index;
       } else if (kind === 0x03) {
-        // Global export: index is unchanged (globals aren't rewritten).
         globals[name] = index;
       }
     }
@@ -202,11 +173,6 @@ export function extractSections(bytes: Uint8Array, opts: ExtractOptions = {}) {
   let codesec: VecContents | undefined;
   let startFuncidx: number | undefined;
 
-  let srcImportCount = 0;
-  let destImportCount = 0;
-
-  const importAdjust = opts.destImportCountAdjustment ?? 0;
-
   let pos = 8;
   let lastId = -1;
   while (pos < bytes.length) {
@@ -223,26 +189,16 @@ export function extractSections(bytes: Uint8Array, opts: ExtractOptions = {}) {
       typesec = parseVecSectionOpaque(id);
     } else if (id === 2) {
       importsec = parseVecSectionOpaque(id);
-      srcImportCount = importsec.entryCount;
-      destImportCount = srcImportCount + importAdjust;
     } else if (id === 3) {
       funcsec = parseVecSectionOpaque(id);
     } else if (id === 6) {
       globalsec = parseVecSectionOpaque(id);
     } else if (id === 7) {
-      exports = parseExportSection(id, destImportCount - srcImportCount);
+      exports = parseExportSection(id);
     } else if (id === 8) {
-      startFuncidx = parseStartSection(id) + destImportCount - srcImportCount;
+      startFuncidx = parseStartSection(id);
     } else if (id === 10) {
       codesec = parseVecSectionOpaque(id);
-      // Rewrite the code section to account for the number of imports that
-      // will exist in the final module. If `destImportCount` is not provided,
-      // assume that it's the same as srcImportCount.
-      codesec.contents = rewriteCodesecContents(
-        codesec.contents,
-        srcImportCount,
-        destImportCount
-      );
     } else if (id === 0) {
       // Custom section — check if it's the 'name' section.
       pos++; // consume section id
@@ -274,207 +230,3 @@ export function extractSections(bytes: Uint8Array, opts: ExtractOptions = {}) {
     startFuncidx,
   };
 }
-
-function rewriteCodeEntry(
-  bytes: Uint8Array,
-  srcImportCount: number,
-  destImportCount: number
-): number[] {
-  const {instr} = w;
-  let pos = 0;
-
-  const parseU32 = () => {
-    const [val, count] = decodeULEB128(bytes, pos);
-    pos += count;
-    return checkU32(val);
-  };
-
-  const parseI32 = () => {
-    const [val, count] = decodeSLEB128(bytes, pos);
-    pos += count;
-    return checkI32(val);
-  };
-
-  function skipLocals() {
-    const len = parseU32();
-    for (let i = 0; i < len; i++) {
-      const count = parseU32();
-      assert(count < MAX_LOCALS, `too many locals: ${count} @${pos}`);
-      checkValtype(bytes[pos++]);
-    }
-  }
-
-  function skipU32Vec() {
-    const len = parseU32();
-    for (let i = 0; i < len; i++) {
-      parseU32();
-    }
-  }
-
-  // See https://webassembly.github.io/spec/core/bikeshed/#binary-blocktype
-  function skipBlocktype() {
-    const b = bytes[pos];
-    if (b === 0x40 || isValtype(b)) {
-      pos += 1;
-      return;
-    }
-    // From the spec:
-    // > Unlike any other occurrence, the type index in a block type is encoded
-    // > as a positive signed integer, so that its signed LEB128 bit pattern
-    // > cannot collide with the encoding of value types or the special code
-    // > 0x40, which correspond to the LEB128 encoding of negative integers.
-    const [idx, count] = decodeSLEB128(bytes.slice(pos));
-    pos += count;
-    assert(idx >= 0, `unexpected typeidx in blocktype: ${idx}`);
-  }
-
-  skipLocals();
-
-  const result: number[] = [];
-  let sliceStart = 0;
-  let nesting = 1;
-
-  // Walk through the function's bytecode.
-  while (pos < bytes.length) {
-    const bc = bytes[pos++];
-
-    // The cases here are ordered by ascending opcode.
-    // See https://pengowray.github.io/wasm-ops/ for an overview.
-    switch (bc) {
-      case instr.unreachable:
-      case instr.nop:
-        break;
-      case instr.block:
-      case instr.loop:
-      case instr.if:
-        skipBlocktype();
-        ++nesting;
-        break;
-      case instr.else:
-        break;
-      case instr.end:
-        assert(--nesting >= 0, `bad nesting @${pos - 1}`);
-        break;
-      case instr.br:
-      case instr.br_if:
-        parseU32();
-        break;
-      case instr.br_table:
-        skipU32Vec(); // labels
-        parseU32(); // default label
-        break;
-      case instr.return:
-        break;
-      case instr.call:
-        // Rewrite `call` instructions so that the index is valid for the
-        // target module.
-        result.push(...bytes.slice(sliceStart, pos));
-        let idx = parseU32();
-
-        // Function indices in a Wasm bundle are automatically assigned.
-        // First come the imports, then the user-defined functions.
-        // Since the dest module has additional imports, we need to rewrite
-        // the funcidx if and only if it referred to a user function.
-        if (idx >= srcImportCount) {
-          idx += destImportCount - srcImportCount;
-        }
-        result.push(...w.u32(idx));
-        sliceStart = pos;
-        break;
-      case instr.call_indirect:
-        parseU32();
-        parseU32();
-        break;
-      case instr.drop:
-      case instr.select:
-        break;
-      case instr.local.get:
-      case instr.local.set:
-      case instr.local.tee:
-      case instr.global.get:
-      case instr.global.set:
-        parseU32();
-        break;
-      case instr.i32.const:
-        parseI32();
-        break;
-      case instr.i64.const:
-        const origPos = pos;
-        const [_, count] = decodeULEB128(bytes.slice(pos));
-        assert(count <= 10, `too many bytes (${count}) for i64 @${origPos}`);
-        pos += count;
-        break;
-      case instr.f32.const:
-        pos += 4;
-        break;
-      case instr.f64.const:
-        pos += 8;
-        break;
-      // @ts-ignore Fallthrough case in switch
-      case 0xfc:
-        const bc2 = parseU32();
-        if (0 <= bc2 && bc2 <= 7) {
-          // i32.trunc_sat_XXX
-          break;
-        }
-        switch (bc2) {
-          case 0x0a: // memory.copy
-            parseU32();
-            parseU32();
-            break;
-          case 0x0b: // memory.fill
-            parseU32();
-            break;
-          default:
-            throw new Error(`unhandled multibyte ${bc2.toString(16)} @${pos - 1}`);
-        }
-        break;
-      default:
-        if (instr.i32.load <= bc && bc <= instr.i64.store32) {
-          parseU32();
-          parseU32();
-        } else if (instr.memory.size <= bc && bc <= instr.memory.grow) {
-          parseU32();
-        } else if (instr.i32.eqz <= bc && bc <= instr.f64.reinterpret_i64) {
-          // do nothing
-        } else {
-          throw new Error(`unhandled bytecode 0x${bc.toString(16)} @${pos - 1}`);
-        }
-        break;
-    }
-  }
-  result.push(...bytes.slice(sliceStart));
-  return result;
-}
-
-// Rewrite the contents of the prebuilt code section, changing the funcidx of
-// `call` instructions to account for the correct number of imports in the
-// final module.
-function rewriteCodesecContents(
-  bytes: Uint8Array,
-  srcImportCount: number,
-  destImportCount: number
-): Uint8Array {
-  let pos = 0;
-
-  const parseU32 = () => {
-    const [val, count] = decodeULEB128(bytes, pos);
-    pos += count;
-    return checkU32(val);
-  };
-
-  const newBytes: number[] = [];
-
-  while (pos < bytes.length) {
-    const size = parseU32();
-    const newEntry = rewriteCodeEntry(
-      bytes.slice(pos, pos + size),
-      srcImportCount,
-      destImportCount
-    );
-    newBytes.push(...w.u32(newEntry.length), ...newEntry);
-    pos += size;
-  }
-
-  return new Uint8Array(newBytes);
-}