porffor 0.2.0-fde989a → 0.14.0-032e4ad08

package/byg/index.js

@@ -0,0 +1,216 @@
+import fs from 'node:fs';
+
+const noAnsi = s => s.replace(/\u001b\[[0-9]+m/g, '');
+const printLine = (line, number, breakpoint = false, current = false, selected = false) => {
+  console.log(`\x1b[${breakpoint ? (selected ? '43' : '103') : (selected ? '47' : '100')}m\x1b[${selected || breakpoint ? '30' : '97'}m${number.toFixed(0).padStart(4, ' ')}\x1b[${breakpoint ? (selected ? '33' : '93') : (selected ? '37' : '90')}m\x1b[${current ? '47' : '40'}m▌ \x1b[${current ? '47' : '40'}m\x1b[${current ? '30' : '37'}m${current ? noAnsi(line) : line}\x1b[0K`);
+};
+
+const box = (x, y, width, height, title = '', content = [], color = ['90', '100', '37', '35', '45'], padding = true) => {
+  if (padding) {
+    width += 1;
+    height += 1;
+
+    // top
+    process.stdout.write(`\x1b[48m\x1b[${y + 1};${x + 1}H\x1b[${color[0]}m` + '▄'.repeat(width));
+    // bottom
+    process.stdout.write(`\x1b[${y + height + 1};${x + 1}H▝` + '▀'.repeat(width - 1) + '▘');
+    // left
+    process.stdout.write(`\x1b[${y + 1};${x + 1}H▗` + '\x1b[1B\x1b[1D▐'.repeat(height - 1));
+    // right
+    process.stdout.write(`\x1b[${y + 1};${x + width + 1}H▖` + '\x1b[1B\x1b[1D▌'.repeat(height - 1));
+
+    x += 1;
+    y += 1;
+    width -= 1;
+    height -= 1;
+  }
+
+  // bg
+  process.stdout.write(`\x1b[${y + 1};${x + 1}H\x1b[${color[1]}m` + ' '.repeat(width) + (`\x1b[1B\x1b[${width}D` + ' '.repeat(width)).repeat(Math.max(0, height - 1)));
+
+  // title
+  if (title) process.stdout.write(`\x1b[${y};${x}H\x1b[0m\x1b[${color[3]}m▐\x1b[${color[4]}m\x1b[${color[2]}m\x1b[1m${' '.repeat((width - title.length) / 2 | 0)}${title}${' '.repeat(width - (((width - title.length) / 2 | 0)) - title.length)}\x1b[0m\x1b[${color[3]}m▌`);
+
+  // content
+  process.stdout.write(`\x1b[${y + (title ? 1 : 1)};${x + 1}H\x1b[${color[1]}m\x1b[${color[2]}m${content.join(`\x1b[1B\x1b[${x + 1}G`)}`);
+};
+
+const controls = {
+  'ret': 'resume  ',
+  'b': 'breakpoint  ',
+  's': 'step over',
+  'i': 'step in',
+  'o': 'step out  ',
+};
+
+const controlInfo = Object.keys(controls).reduce((acc, x, i) => acc + `\x1B[45m\x1B[97m${x}\x1b[105m\x1b[37m ${controls[x]}  `, '');
+const plainControlInfo = noAnsi(controlInfo);
+
+globalThis.termWidth = process.stdout.columns || 80;
+globalThis.termHeight = process.stdout.rows || 24;
+
+export default ({ lines, pause, breakpoint }) => {
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+
+  process.stdin.on('data', s => {
+    // ctrl c
+    if (s === '\u0003') {
+      process.exit();
+    }
+
+    if (!paused) pause();
+  });
+
+  const stdin = fs.openSync('/dev/stdin', 'r+');
+  const readCharSync = () => {
+    const buffer = Buffer.alloc(1);
+    fs.readSync(stdin, buffer, 0, 1);
+    return buffer.toString('utf8');
+  };
+
+  const tooManyLines = lines.length > (termHeight - 1);
+  const breakpoints = {};
+
+  process.on('exit', () => {
+    process.stdout.write('\x1b[0m');
+  });
+
+  console.clear();
+
+  let paused = true;
+  return (_paused, currentLine, text, boxes = []) => {
+    paused = _paused;
+
+    let scrollOffset = 0;
+    let currentLinePos = currentLine;
+
+    const draw = () => {
+      console.clear();
+      process.stdout.write(`\x1b[1;1H`);
+
+      if (tooManyLines) {
+        const edgePadding = (termHeight / 2) - 1;
+        let beforePadding = currentLine - edgePadding;
+        let afterPadding = currentLine + edgePadding + 1;
+
+        if (beforePadding < 0) {
+          afterPadding += Math.abs(beforePadding);
+          beforePadding = 0;
+        }
+
+        beforePadding += scrollOffset;
+        afterPadding += scrollOffset;
+
+        if (afterPadding > lines.length) {
+          beforePadding -= afterPadding - lines.length;
+          afterPadding = lines.length;
+        }
+
+        for (let i = Math.max(0, beforePadding); i < Math.max(0, beforePadding) + (termHeight - 1); i++) {
+          printLine(lines[i], i + 1, !!breakpoints[i], currentLine === i, currentLine + scrollOffset === i);
+        }
+
+        currentLinePos = currentLine - beforePadding;
+      } else {
+        for (let i = 0; i < lines.length; i++) {
+          printLine(lines[i], i + 1, !!breakpoints[i], currentLine === i, currentLine + scrollOffset === i);
+        }
+      }
+
+      for (const x of boxes) {
+        const y = x.y({ currentLinePos });
+        if (y < 0 || y >= termHeight) continue;
+
+        box(x.x, y, x.width, x.height, x.title, x.content);
+      }
+
+      // text += ` | rss: ${(process.memoryUsage.rss() / 1024 / 1024).toFixed(2)}mb`;
+
+      process.stdout.write(`\x1b[${termHeight};1H\x1b[105m\x1b[37m${text}${' '.repeat(termWidth - plainControlInfo.length - noAnsi(text).length - 1)}${controlInfo} \x1b[0m`);
+    };
+
+    draw();
+
+    let lastSpecial = false;
+    while (true) {
+      const char = readCharSync();
+
+      if (char === '[') {
+        lastSpecial = true;
+        continue;
+      }
+
+      switch (char.toLowerCase()) {
+        case '\r': {
+          paused = false;
+          return 'resume';
+        }
+
+        case 's': {
+          return 'stepOver';
+        }
+
+        case 'i': {
+          return 'stepIn';
+        }
+
+        case 'o': {
+          return 'stepOut';
+        }
+
+        case 'b': {
+          if (!lastSpecial) {
+            // b pressed normally
+            breakpoints[currentLine + scrollOffset] = !breakpoints[currentLine + scrollOffset];
+            draw();
+
+            breakpoint(currentLine + scrollOffset, breakpoints[currentLine + scrollOffset]);
+            break;
+          }
+
+          // arrow down
+          if (scrollOffset < lines.length - currentLine - 1) scrollOffset++;
+          draw();
+          break;
+        }
+
+        case 'a': {
+          if (!lastSpecial) break;
+
+          // arrow up
+          if (scrollOffset > -currentLine) scrollOffset--;
+          draw();
+
+          break;
+        }
+
+        case '5': {
+          if (!lastSpecial) break;
+
+          // page up
+          scrollOffset -= Math.min(scrollOffset + currentLine, termHeight - 1);
+          draw();
+          break;
+        }
+
+        case '6': {
+          if (!lastSpecial) break;
+
+          // page down
+          scrollOffset += Math.min(lines.length - (scrollOffset + currentLine) - 1, termHeight - 1);
+          draw();
+          break;
+        }
+
+        case 'q':
+        case '\u0003': {
+          process.exit();
+        }
+      }
+
+      lastSpecial = false;
+    }
+  };
+};

package/compiler/2c.js

@@ -1,7 +1,7 @@
 import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
 import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
 import { operatorOpcode } from './expression.js';
-import { log } from "./log.js";
+import { log } from './log.js';
 
 const CValtype = {
   i8: 'i8',
@@ -106,17 +106,6 @@ for (const x in CValtype) {
   if (Valtype[x]) CValtype[Valtype[x]] = CValtype[x];
 }
 
-const todo = msg => {
-  class TodoError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = 'TodoError';
-    }
-  }
-
-  throw new TodoError(`todo: ${msg}`);
-};
-
 const removeBrackets = str => {
   // return str;
   // if (str.startsWith(`(${CValtype.i32})(${CValtype.u32})`)) return `(${CValtype.i32})(${CValtype.u32})(` + removeBrackets(str.slice(22, -1)) + ')';
@@ -130,6 +119,9 @@ const removeBrackets = str => {
 };
 
 export default ({ funcs, globals, tags, data, exceptions, pages }) => {
+  // fix declaring order for c
+  funcs.reverse();
+
   const invOperatorOpcode = Object.values(operatorOpcode).reduce((acc, x) => {
     for (const k in x) {
       acc[x[k]] = k;
@@ -167,10 +159,10 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
     prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n'));
   }
 
-  // for (const [ x, p ] of pages) {
-    // out += `${CValtype[p.type]} ${x.replace(': ', '_').replace(/[^0-9a-zA-Z_]/g, '')}[100]`;
-    // out += ';\n';
-  // }
+  if (importFuncs.find(x => x.name === '__Porffor_readArgv')) {
+    prepend.set('argv', `int _argc; char** _argv;`);
+    prependMain.set('argv', `_argc = argc; _argv = argv;`);
+  }
 
   if (out) out += '\n';
 
@@ -213,9 +205,9 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
   for (const f of funcs) {
     depth = 1;
+    brDepth = 0;
 
     const invLocals = inv(f.locals, x => x.idx);
-    // if (f.returns.length > 1) todo('funcs returning >1 value unsupported');
 
     for (const x in invLocals) {
       invLocals[x] = sanitize(invLocals[x]);
@@ -223,8 +215,9 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
     const returns = f.returns.length > 0;
 
-    const shouldInline = f.internal;
-    out += `${f.name === 'main' ? 'int' : (f.internal ? (returns ? CValtype.f64 : 'void') : 'struct ReturnValue')} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+    const shouldInline = false; // f.internal;
+    if (f.name === 'main') out += `int main(${prependMain.has('argv') ? 'int argc, char* argv[]' : ''}) {\n`;
+      else out += `${f.internal ? (returns ? CValtype.f64 : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
 
     if (f.name === 'main') {
       out += [...prependMain.values()].join('\n');
@@ -247,12 +240,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
     const brs = [];
     let lastCond = false;
 
-    // let brDepth = 0;
-
     const blockStart = (i, loop) => {
-      // reset "stack"
-      // vals = [];
-
       rets.push(i[1]);
 
       const br = brId++;
@@ -269,25 +257,6 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
       brDepth++;
     };
 
-    const highlight = i => {
-      const surrounding = 6;
-
-      const decomp = decompile(f.wasm.slice(i - surrounding, i + surrounding + 1), '', 0, f.locals, f.params, f.returns, funcs, globals, exceptions).slice(0, -1).split('\n');
-
-      const noAnsi = s => s.replace(/\u001b\[[0-9]+m/g, '');
-      let longest = 0;
-      for (let j = 0; j < decomp.length; j++) {
-        longest = Math.max(longest, noAnsi(decomp[j]).length);
-      }
-
-      const middle = Math.floor(decomp.length / 2);
-      decomp[middle] = `\x1B[47m\x1B[30m${noAnsi(decomp[middle])}${'\u00a0'.repeat(longest - noAnsi(decomp[middle]).length)}\x1B[0m`;
-
-      console.log('\x1B[90m...\x1B[0m');
-      console.log(decomp.join('\n'));
-      console.log('\x1B[90m...\x1B[0m\n');
-    };
-
     for (let _ = 0; _ < f.wasm.length; _++) {
       const i = f.wasm[_];
       if (!i || !i[0]) continue;
@@ -415,8 +384,6 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
           const br = brs.at(-1);
           const ret = rets.at(-1);
           if (ret && ret !== Blocktype.void) {
-            // console.log(vals, ret);
-            // console.log(decompile(f.wasm.slice(_ - 5, _ + 1)));
             if (vals.length > 0) line(`_r${br} = ${removeBrackets(vals.pop())}`);
             // vals.push(`_r${br}`);
           }
@@ -425,8 +392,6 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
           line(`} else {`, false);
           depth++;
 
-          // reset "stack"
-          // vals = [];
           break;
         }
 
@@ -441,8 +406,6 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
           const br = brs.pop();
           const ret = rets.pop();
           if (ret && ret !== Blocktype.void) {
-            // console.log(vals, ret);
-            // console.log(decompile(f.wasm.slice(_ - 5, _ + 1)));
             if (vals.length > 0) line(`_r${br} = ${removeBrackets(vals.pop())}`);
             vals.push(`_r${br}`);
           }
@@ -505,6 +468,60 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
                 winIncludes.set('windows.h', true);
                 break;
 
+              case '__Porffor_readArgv':
+                includes.set('stdlib.h', true);
+
+                prepend.set('__Porffor_readArgv',
+`void __Porffor_readArgv(u32 index, u32 outPtr) {
+  if (index >= _argc) {
+    printf("expected %d arguments\\n", index);
+    exit(1);
+  }
+
+  char* arg = _argv[index];
+
+  u32 read = 0;
+  char* out = _memory + outPtr + 4;
+  char ch;
+  while ((ch = *(arg++)) != 0) {
+    out[read++] = ch;
+  }
+
+  memcpy(_memory + outPtr, &read, sizeof(read));
+}`);
+
+                line(`__Porffor_readArgv((u32)(${vals.at(-2)}), (u32)(${vals.pop()}))`);
+                vals.pop();
+                break;
+
+              case '__Porffor_readFile':
+                includes.set('stdio.h', true);
+                includes.set('stdlib.h', true);
+
+                prepend.set('__Porffor_readFile',
+`void __Porffor_readFile(u32 pathPtr, u32 outPtr) {
+  char* path = _memory + pathPtr + 4;
+  FILE* fp = fopen(path, "r");
+  if (fp == NULL) {
+    printf("failed to open file: %s\\n", path);
+    exit(1);
+  }
+
+  u32 read = 0;
+  char* out = _memory + outPtr + 4;
+  char ch;
+  while ((ch = fgetc(fp)) != EOF) {
+    out[read++] = ch;
+  }
+
+  fclose(fp);
+
+  memcpy(_memory + outPtr, &read, sizeof(read));
+}`);
+                line(`__Porffor_readFile((u32)(${vals.at(-2)}), (u32)(${vals.pop()}))`);
+                vals.pop();
+                break;
+
               default:
                 log.warning('2c', `unimplemented import: ${importFunc.name}`);
                 break;
@@ -541,18 +558,14 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
 
         case Opcodes.br: {
           const ret = rets[brDepth - i[1] - 1];
-          // console.log(rets, brDepth, i[1], brDepth - i[1] - 1, ret, vals);
           if (ret !== Blocktype.void) line(`_r${brs[brDepth - i[1] - 1]} = ${removeBrackets(vals.pop())}`);
           line(`goto j${brs[brDepth - i[1] - 1]}`);
 
-          // // reset "stack"
-          // vals = [];
           break;
         }
 
         case Opcodes.br_if: {
           const ret = rets[brDepth - i[1] - 1];
-          // console.log(rets, brDepth, i[1], brDepth - i[1] - 1, ret, vals);
 
           let cond = removeBrackets(vals.pop());
           if (!lastCond) {
@@ -602,7 +615,6 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
           }
 
           log.warning('2c', `unimplemented op: ${invOpcodes[i[0]]}`);
-          // todo(`unimplemented op: ${invOpcodes[i[0]]}`);
       }
 
       lastCond = false;

package/compiler/{sections.js → assemble.js}

@@ -1,8 +1,8 @@
-import { Valtype, FuncType, Empty, ExportDesc, Section, Magic, ModuleVersion, Opcodes, PageSize } from './wasmSpec.js';
-import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128 } from './encoding.js';
-import { number } from './embedding.js';
+import { Valtype, FuncType, ExportDesc, Section, Magic, ModuleVersion, Opcodes, PageSize, Reftype } from './wasmSpec.js';
+import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128, unsignedLEB128_into, signedLEB128_into, ieee754_binary64_into } from './encoding.js';
 import { importedFuncs } from './builtins.js';
-import { log } from "./log.js";
+import { log } from './log.js';
+import Prefs from './prefs.js';
 
 const createSection = (type, data) => [
   type,
@@ -26,12 +26,12 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
 
-  const compileHints = process.argv.includes('-compile-hints');
-  if (compileHints) log.warning('sections', 'compile hints is V8 only w/ experimental arg! (you used -compile-hints)');
+  const compileHints = Prefs.compileHints;
+  if (compileHints) log.warning('assemble', 'compile hints is V8 only w/ experimental arg! (you used -compile-hints)');
 
   const getType = (params, returns) => {
     const hash = `${params.join(',')}_${returns.join(',')}`;
-    if (optLog) log('sections', `getType(${JSON.stringify(params)}, ${JSON.stringify(returns)}) -> ${hash} | cache: ${typeCache[hash]}`);
+    if (Prefs.optLog) log('assemble', `getType(${JSON.stringify(params)}, ${JSON.stringify(returns)}) -> ${hash} | cache: ${typeCache[hash]}`);
     if (optLevel >= 1 && typeCache[hash] !== undefined) return typeCache[hash];
 
     const type = [ FuncType, ...encodeVector(params), ...encodeVector(returns) ];
@@ -44,7 +44,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   let importFuncs = [];
 
-  if (optLevel < 1) {
+  if (optLevel < 1 || !Prefs.treeshakeWasmImports) {
     importFuncs = importedFuncs;
   } else {
     let imports = new Map();
@@ -65,6 +65,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
     importFuncs = [...imports.values()];
 
     // fix call indexes for non-imports
+    // also fix call_indirect types
     const delta = importedFuncs.length - importFuncs.length;
     for (const f of funcs) {
       f.originalIndex = f.index;
@@ -74,16 +75,26 @@ export default (funcs, globals, tags, pages, data, flags) => {
         if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] >= importedFuncs.length) {
           inst[1] -= delta;
         }
+
+        if (inst[0] === Opcodes.call_indirect) {
+          const params = [];
+          for (let i = 0; i < inst[1]; i++) {
+            params.push(valtypeBinary, Valtype.i32);
+          }
+
+          const returns = [ valtypeBinary, Valtype.i32 ];
+          inst[1] = getType(params, returns);
+        }
       }
     }
   }
   globalThis.importFuncs = importFuncs;
 
-  if (optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
+  if (Prefs.optLog) log('assemble', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
 
   const importSection = importFuncs.length === 0 ? [] : createSection(
     Section.import,
-    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(new Array(x.params).fill(valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
+    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(new Array(x.params).fill(x.name.startsWith('profile') ? Valtype.i32 : valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
   );
 
   const funcSection = createSection(
@@ -91,22 +102,89 @@ export default (funcs, globals, tags, pages, data, flags) => {
     encodeVector(funcs.map(x => getType(x.params, x.returns))) // type indexes
   );
 
-  // compilation hints section - unspecd, v8 only
-  // https://github.com/WebAssembly/design/issues/1473#issuecomment-1431274746
-  const chSection = !compileHints ? [] : customSection(
-    'compilationHints',
-    // for now just do everything as optimise eager
-    encodeVector(funcs.map(_ => chHint(0x02, 0x02, 0x02)))
+  const tableSection = !funcs.table ? [] : createSection(
+    Section.table,
+    encodeVector([ [ Reftype.funcref, 0x00, funcs.length ] ])
   );
 
-  const globalSection = Object.keys(globals).length === 0 ? [] : createSection(
-    Section.global,
-    encodeVector(Object.keys(globals).map(x => [ globals[x].type, 0x01, ...number(globals[x].init ?? 0, globals[x].type).flat(), Opcodes.end ]))
+  const elementSection = !funcs.table ? [] : createSection(
+    Section.element,
+    encodeVector([ [
+      0x00,
+      Opcodes.i32_const, 0, Opcodes.end,
+      ...encodeVector(funcs.map(x => x.index))
+    ] ])
   );
 
+  if (pages.has('func argc lut')) {
+    // generate func argc lut data
+    const bytes = [];
+    for (let i = 0; i < funcs.length; i++) {
+      const argc = Math.floor(funcs[i].params.length / 2);
+      bytes.push(argc % 256, (argc / 256 | 0) % 256);
+    }
+
+    data.push({
+      offset: pages.get('func argc lut').ind * pageSize,
+      bytes
+    });
+  }
+
+  // const t0 = performance.now();
+
+  // specially optimized assembly for globals as this version is much (>5x) faster than traditional createSection()
+  const globalsValues = Object.values(globals);
+
+  let globalSection = [];
+  if (globalsValues.length > 0) {
+    let data = unsignedLEB128(globalsValues.length);
+    for (let i = 0; i < globalsValues.length; i++) {
+      const global = globalsValues[i];
+
+      switch (global.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);
+          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);
+          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);
+          break;
+      }
+    }
+
+    data.push(Opcodes.end);
+
+    globalSection.push(Section.global);
+
+    unsignedLEB128_into(data.length, globalSection);
+    globalSection = globalSection.concat(data);
+  }
+
+  // if (Prefs.profileCompiler) {
+  //   const log = console.log;
+  //   console.log = function () {
+  //     log.apply(this, arguments);
+  //     console.log = log;
+  //     console.log(`  a. assembled global section in ${(performance.now() - t0).toFixed(2)}ms\n`);
+  //   };
+  // }
+
   const exports = funcs.filter(x => x.export).map((x, i) => [ ...encodeString(x.name === 'main' ? 'm' : x.name), ExportDesc.func, x.index ]);
 
-  if (process.argv.includes('-always-memory') && pages.size === 0) pages.set('-always-memory', 0);
+  if (Prefs.alwaysMemory && pages.size === 0) pages.set('--always-memory', 0);
   if (optLevel === 0) pages.set('O0 precaution', 0);
 
   const usesMemory = pages.size > 0;
@@ -169,7 +247,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
     unsignedLEB128(data.length)
   );
 
-  if (process.argv.includes('-sections')) console.log({
+  if (Prefs.sections) console.log({
     typeSection: typeSection.map(x => x.toString(16)),
     importSection: importSection.map(x => x.toString(16)),
     funcSection: funcSection.map(x => x.toString(16)),
@@ -179,6 +257,14 @@ export default (funcs, globals, tags, pages, data, flags) => {
     dataSection: dataSection.map(x => x.toString(16)),
   });
 
+  // compilation hints section - unspecd, v8 only
+  // https://github.com/WebAssembly/design/issues/1473#issuecomment-1431274746
+  const chSection = !compileHints ? [] : customSection(
+    'compilationHints',
+    // for now just do everything as optimize eager
+    encodeVector(funcs.map(_ => chHint(0x02, 0x02, 0x02)))
+  );
+
   return Uint8Array.from([
     ...Magic,
     ...ModuleVersion,
@@ -186,10 +272,12 @@ export default (funcs, globals, tags, pages, data, flags) => {
     ...importSection,
     ...funcSection,
     ...chSection,
+    ...tableSection,
     ...memorySection,
     ...tagSection,
     ...globalSection,
     ...exportSection,
+    ...elementSection,
     ...dataCountSection,
     ...codeSection,
     ...dataSection