porffor 0.2.0-6aff0fa → 0.2.0-6bc63ef

package/compiler/index.js

@@ -1,8 +1,8 @@
 import { underline, bold, log } from './log.js';
 import parse from './parse.js';
-import codeGen from './codeGen.js';
+import codegen from './codegen.js';
 import opt from './opt.js';
-import produceSections from './sections.js';
+import assemble from './assemble.js';
 import decompile from './decompile.js';
 import toc from './2c.js';
 import Prefs from './prefs.js';
@@ -26,29 +26,29 @@ const logFuncs = (funcs, globals, exceptions) => {
   console.log();
 };
 
-const writeFileSync = (typeof process?.version !== 'undefined' ? (await import('node:fs')).writeFileSync : undefined);
+const fs = (typeof process?.version !== 'undefined' ? (await import('node:fs')) : undefined);
 const execSync = (typeof process?.version !== 'undefined' ? (await import('node:child_process')).execSync : undefined);
 
 export default (code, flags) => {
   const t0 = performance.now();
   const program = parse(code, flags);
-  if (flags.includes('info')) console.log(`1. parsed in ${(performance.now() - t0).toFixed(2)}ms`);
+  if (Prefs.profileCompiler) console.log(`1. parsed in ${(performance.now() - t0).toFixed(2)}ms`);
 
   const t1 = performance.now();
-  const { funcs, globals, tags, exceptions, pages, data } = codeGen(program);
-  if (flags.includes('info')) console.log(`2. generated code in ${(performance.now() - t1).toFixed(2)}ms`);
+  const { funcs, globals, tags, exceptions, pages, data } = codegen(program);
+  if (Prefs.profileCompiler) console.log(`2. generated code in ${(performance.now() - t1).toFixed(2)}ms`);
 
   if (Prefs.funcs) logFuncs(funcs, globals, exceptions);
 
   const t2 = performance.now();
   opt(funcs, globals, pages, tags, exceptions);
-  if (flags.includes('info')) console.log(`3. optimized code in ${(performance.now() - t2).toFixed(2)}ms`);
+  if (Prefs.profileCompiler) console.log(`3. optimized in ${(performance.now() - t2).toFixed(2)}ms`);
 
   if (Prefs.optFuncs) logFuncs(funcs, globals, exceptions);
 
   const t3 = performance.now();
-  const sections = produceSections(funcs, globals, tags, pages, data, flags);
-  if (flags.includes('info')) console.log(`4. produced sections in ${(performance.now() - t3).toFixed(2)}ms`);
+  const wasm = assemble(funcs, globals, tags, pages, data, flags);
+  if (Prefs.profileCompiler) console.log(`4. assembled in ${(performance.now() - t3).toFixed(2)}ms`);
 
   if (Prefs.allocLog) {
     const wasmPages = Math.ceil((pages.size * pageSize) / 65536);
@@ -57,13 +57,13 @@ export default (code, flags) => {
     console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n') + '\n');
   }
 
-  const out = { wasm: sections, funcs, globals, tags, exceptions, pages, data };
+  const out = { wasm, funcs, globals, tags, exceptions, pages, data };
 
   const target = Prefs.target ?? 'wasm';
   const outFile = Prefs.o;
 
   if (target === 'wasm' && outFile) {
-    writeFileSync(outFile, Buffer.from(sections));
+    fs.writeFileSync(outFile, Buffer.from(wasm));
 
     if (process.version) process.exit();
   }
@@ -73,7 +73,7 @@ export default (code, flags) => {
     out.c = c;
 
     if (outFile) {
-      writeFileSync(outFile, c);
+      fs.writeFileSync(outFile, c);
     } else {
       console.log(c);
     }
@@ -88,17 +88,17 @@ export default (code, flags) => {
     if (compiler === 'zig') compiler = [ 'zig', 'cc' ];
       else compiler = [ compiler ];
 
-    const tmpfile = 'tmp.c';
-    // const args = [ compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native', '-s', '-fno-unwind-tables', '-fno-asynchronous-unwind-tables', '-ffunction-sections', '-fdata-sections', '-Wl', '-fno-ident', '-fno-exceptions', '-ffast-math' ];
-    // const args = [ ...compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native', '-s', '-ffast-math', '-fno-exceptions', '-target', 'x86_64-linux' ];
+    const tmpfile = 'porffor_tmp.c';
     const args = [ ...compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native', '-s', '-ffast-math', '-fno-exceptions' ];
 
     const c = toc(out);
-    writeFileSync(tmpfile, c);
+    fs.writeFileSync(tmpfile, c);
 
     // obvious command escape is obvious
     execSync(args.join(' '), { stdio: 'inherit' });
 
+    fs.unlinkSync(tmpfile);
+
     if (process.version) process.exit();
   }
 

package/compiler/log.js

@@ -5,9 +5,9 @@ export const bold = x => `\u001b[1m${x}\u001b[0m`;
 const areaColors = {
   codegen: [ 20, 80, 250 ],
   opt: [ 250, 20, 80 ],
-  sections: [ 20, 250, 80 ],
+  assemble: [ 20, 250, 80 ],
   alloc: [ 250, 250, 20 ],
-  parser: [ 240, 240, 240 ],
+  parse: [ 240, 240, 240 ],
   '2c': [ 20, 250, 250 ],
   wrap: [ 250, 100, 20 ]
 };

package/compiler/opt.js

@@ -1,7 +1,7 @@
-import { Opcodes, Valtype } from "./wasmSpec.js";
-import { number } from "./embedding.js";
-import { read_signedLEB128, read_ieee754_binary64 } from "./encoding.js";
-import { log } from "./log.js";
+import { Opcodes, Valtype } from './wasmSpec.js';
+import { number } from './embedding.js';
+import { read_signedLEB128, read_ieee754_binary64 } from './encoding.js';
+import { log } from './log.js';
 import Prefs from './prefs.js';
 
 const performWasmOp = (op, a, b) => {
@@ -100,8 +100,9 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
   if (Prefs.optInlineOnly) return;
 
-  const tagUse = tags.reduce((acc, x) => { acc[x.idx] = 0; return acc; }, {});
-  const exceptionUse = exceptions.reduce((acc, _, i) => { acc[i] = 0; return acc; }, {});
+  // todo: this breaks exceptions after due to indexes not being adjusted
+  // const tagUse = tags.reduce((acc, x) => { acc[x.idx] = 0; return acc; }, {});
+  // const exceptionUse = exceptions.reduce((acc, _, i) => { acc[i] = 0; return acc; }, {});
 
   // wasm transform pass
   for (const f of funcs) {
@@ -109,7 +110,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
     const lastType = f.locals['#last_type'];
 
-    let runs = 2; // how many by default? add arg?
+    let runs = (+Prefs.optWasmRuns) || 2; // todo: how many by default?
     while (runs > 0) {
       runs--;
 
@@ -131,12 +132,12 @@ export default (funcs, globals, pages, tags, exceptions) => {
         if (inst[0] === Opcodes.local_get) getCount[inst[1]]++;
         if (inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) setCount[inst[1]]++;
 
-        if (inst[0] === Opcodes.throw) {
-          tagUse[inst[1]]++;
+        // if (inst[0] === Opcodes.throw) {
+        //   tagUse[inst[1]]++;
 
-          const exceptId = read_signedLEB128(wasm[i - 1].slice(1));
-          exceptionUse[exceptId]++;
-        }
+        //   const exceptId = read_signedLEB128(wasm[i - 1].slice(1));
+        //   exceptionUse[exceptId]++;
+        // }
 
         if (inst[0] === Opcodes.block) {
           // remove unneeded blocks (no brs inside)
@@ -171,14 +172,14 @@ export default (funcs, globals, pages, tags, exceptions) => {
           }
         }
 
-        if (inst[inst.length - 1] === 'string_only' && !pages.hasString) {
+        if (inst[inst.length - 1] === 'string_only' && !pages.hasAnyString && !Prefs.noRmUnusedTypes) {
           // remove this inst
           wasm.splice(i, 1);
           if (i > 0) i--;
           inst = wasm[i];
         }
 
-        if (inst[inst.length - 1] === 'string_only|start' && !pages.hasString) {
+        if (inst[inst.length - 1] === 'string_only|start' && !pages.hasAnyString&& !Prefs.noRmUnusedTypes) {
           let j = i;
           for (; j < wasm.length; j++) {
             const op = wasm[j];
@@ -192,7 +193,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           inst = wasm[i];
         }
 
-        if (inst[0] === Opcodes.if && typeof inst[2] === 'string') {
+        if (inst[0] === Opcodes.if && typeof inst[2] === 'string' && !Prefs.noRmUnusedTypes) {
           // remove unneeded typeswitch checks
 
           const type = inst[2].split('|')[1];
@@ -553,18 +554,18 @@ export default (funcs, globals, pages, tags, exceptions) => {
     }
   }
 
-  for (const x in tagUse) {
-    if (tagUse[x] === 0) {
-      const el = tags.find(y => y.idx === x);
-      tags.splice(tags.indexOf(el), 1);
-    }
-  }
-
-  for (const x of Object.keys(exceptionUse).sort((a, b) => b - a)) {
-    if (exceptionUse[x] === 0) {
-      exceptions.splice(+x, 1);
-    }
-  }
+  // for (const x in tagUse) {
+  //   if (tagUse[x] === 0) {
+  //     const el = tags.find(y => y.idx === x);
+  //     tags.splice(tags.indexOf(el), 1);
+  //   }
+  // }
+
+  // for (const x of Object.keys(exceptionUse).sort((a, b) => b - a)) {
+  //   if (exceptionUse[x] === 0) {
+  //     exceptions.splice(+x, 1);
+  //   }
+  // }
 
   // return funcs;
 };

package/compiler/parse.js

@@ -1,16 +1,16 @@
-import { log } from "./log.js";
+import { log } from './log.js';
 import Prefs from './prefs.js';
 
-// import { parse } from 'acorn';
-
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
   const textEncoder = new TextEncoder();
   globalThis.process = { argv: ['', '', ...Deno.args], stdout: { write: str => Deno.writeAllSync(Deno.stdout, textEncoder.encode(str)) } };
 }
 
+const file = process.argv.slice(2).find(x => x[0] !== '-');
+
 // should we try to support types (while parsing)
-const types = Prefs.parseTypes;
+const types = Prefs.parseTypes || file?.endsWith('.ts');
 globalThis.typedInput = types && Prefs.optTypes;
 
 // todo: review which to use by default
@@ -20,37 +20,43 @@ globalThis.typedInput = types && Prefs.optTypes;
 // - hermes-parser
 // - @babel/parser
 
-let parser, parse;
+globalThis.parser = '';
+let parse;
 const loadParser = async (fallbackParser = 'acorn', forceParser) => {
-  parser = forceParser ?? process.argv.find(x => x.startsWith('-parser='))?.split('=')?.[1] ?? fallbackParser;
-  0, { parse } = (await import((globalThis.document ? 'https://esm.sh/' : '') + parser));
+  parser = forceParser ?? process.argv.find(x => x.startsWith('--parser='))?.split('=')?.[1] ?? fallbackParser;
+  0, { parse } = (await import((globalThis.document || globalThis.Deno ? 'https://esm.sh/' : '') + parser));
 };
 globalThis._porf_loadParser = loadParser;
 await loadParser(types ? '@babel/parser' : undefined);
 
-if (types && !['@babel/parser', 'hermes-parser'].includes(parser)) log.warning('parser', `passed -types with a parser (${parser}) which does not support`);
+if (types && !['@babel/parser', 'hermes-parser'].includes(parser)) log.warning('parse', `passed -parse-types with a parser (${parser}) which does not support`);
 
 export default (input, flags) => {
-  const ast = parse(input, {
-    // acorn
-    ecmaVersion: 'latest',
-
-    // meriyah
-    next: true,
-    module: flags.includes('module'),
-    webcompat: true,
-
-    // babel
-    plugins: types ? ['estree', 'typescript'] : ['estree'],
-
-    // multiple
-    sourceType: flags.includes('module') ? 'module' : 'script',
-    ranges: false,
-    tokens: false,
-    comments: false,
-  });
-
-  if (ast.type === 'File') return ast.program;
-
-  return ast;
+  try {
+    const ast = parse(input, {
+      // acorn
+      ecmaVersion: 'latest',
+
+      // meriyah
+      next: true,
+      module: flags.includes('module'),
+      webcompat: true,
+
+      // babel
+      plugins: types ? ['estree', 'typescript'] : ['estree'],
+
+      // multiple
+      sourceType: flags.includes('module') ? 'module' : 'script',
+      ranges: false,
+      tokens: false,
+      comments: false,
+    });
+
+    if (ast.type === 'File') return ast.program;
+
+    return ast;
+  } catch (e) {
+    // normalize error class thrown by 3rd party parsers
+    throw new SyntaxError(e.message, { cause: e });
+  }
 };

package/compiler/precompile.js

@@ -1,4 +1,5 @@
 import { Opcodes } from './wasmSpec.js';
+import { TYPES } from './types.js';
 
 import fs from 'node:fs';
 import { join } from 'node:path';
@@ -6,52 +7,37 @@ import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 
-const TYPES = {
-  number: 0x00,
-  boolean: 0x01,
-  string: 0x02,
-  undefined: 0x03,
-  object: 0x04,
-  function: 0x05,
-  symbol: 0x06,
-  bigint: 0x07,
-
-  // these are not "typeof" types but tracked internally
-  _array: 0x10,
-  _regexp: 0x11,
-  _bytestring: 0x12
-};
-
-// import porfParse from './parse.js';
-// import porfCodegen from './codeGen.js';
-
 const argv = process.argv.slice();
 
 const compile = async (file, [ _funcs, _globals ]) => {
-  const source = fs.readFileSync(file, 'utf8');
-  const first = source.slice(0, source.indexOf('\n'));
+  let source = fs.readFileSync(file, 'utf8');
+  let first = source.slice(0, source.indexOf('\n'));
+
+  if (first.startsWith('export default')) {
+    source = (await import(file)).default();
+    first = source.slice(0, source.indexOf('\n'));
+  }
 
-  let args = ['-bytestring'];
-  if (file.endsWith('.ts')) args.push('-parse-types', '-opt-types');
+  let args = ['--bytestring', '--todo-time=compile', '--no-aot-pointer-opt', '--no-treeshake-wasm-imports', '--no-rm-unused-types', '--scoped-page-names', '--funsafe-no-unlikely-proto-checks', '--parse-types', '--opt-types'];
   if (first.startsWith('// @porf')) {
     args = args.concat(first.slice('// @porf '.length).split(' '));
   }
   process.argv = argv.concat(args);
 
-  // const porfParse = (await import(`./parse.js?_=${Date.now()}`)).default;
-  // const porfCodegen = (await import(`./codeGen.js?_=${Date.now()}`)).default;
-
-  // let { funcs, globals, data } = porfCodegen(porfParse(source, ['module']));
-
   const porfCompile = (await import(`./index.js?_=${Date.now()}`)).default;
 
   let { funcs, globals, data, exceptions } = porfCompile(source, ['module']);
 
   const allocated = new Set();
 
-  const exports = funcs.filter(x => x.export);
+  const exports = funcs.filter(x => x.export && x.name !== 'main');
   for (const x of exports) {
-    if (x.data) x.data = x.data.map(x => data[x]);
+    if (x.data) {
+      x.data = x.data.map(x => data[x]);
+      for (const y in x.data) {
+        x.data[y].offset -= x.data[0].offset;
+      }
+    }
     if (x.exceptions) x.exceptions = x.exceptions.map(x => {
       const obj = exceptions[x];
       if (obj) obj.exceptId = x;
@@ -76,15 +62,22 @@ const compile = async (file, [ _funcs, _globals ]) => {
       if (y[0] === Opcodes.const && (n[0] === Opcodes.local_set || n[0] === Opcodes.local_tee)) {
         const l = locals[n[1]];
         if (!l) continue;
-        if (![TYPES.string, TYPES._array, TYPES._bytestring].includes(l.metadata?.type)) continue;
+        if (![TYPES.string, TYPES.array, TYPES.bytestring].includes(l.metadata?.type)) continue;
         if (!x.pages) continue;
 
         const pageName = [...x.pages.keys()].find(z => z.endsWith(l.name));
         if (!pageName || allocated.has(pageName)) continue;
         allocated.add(pageName);
 
-        y.splice(0, 10, 'alloc', pageName, x.pages.get(pageName).type);
-        // y.push(x.pages.get(pageName));
+        y.splice(0, 10, 'alloc', pageName, x.pages.get(pageName).type, valtypeBinary);
+      }
+
+      if (y[0] === Opcodes.i32_const && n[0] === Opcodes.throw) {
+        const id = y[1];
+        y.splice(0, 10, 'throw', exceptions[id].constructor, exceptions[id].message);
+
+        // remove throw inst
+        x.wasm.splice(i + 1, 1);
       }
     }
   }
@@ -99,31 +92,29 @@ const precompile = async () => {
   let funcs = [], globals = [];
   for (const file of fs.readdirSync(dir)) {
     if (file.endsWith('.d.ts')) continue;
+    console.log(file);
+
     await compile(join(dir, file), [ funcs, globals ]);
   }
 
-  // ${x.pages && x.pages.size > 0 ? `    pages: ${JSON.stringify(Object.fromEntries(x.pages.entries()))},` : ''}
-  // ${x.used && x.used.length > 0 ? `    used: ${JSON.stringify(x.used)},` : ''}
-
   return `// autogenerated by compiler/precompile.js
 import { number } from './embedding.js';
 
 export const BuiltinFuncs = function() {
-${funcs.map(x => `  this.${x.name} = {
-    wasm: (scope, { allocPage, builtin }) => ${JSON.stringify(x.wasm.filter(x => x.length && x[0] != null)).replace(/\["alloc","(.*?)","(.*?)"\]/g, (_, reason, type) => `...number(allocPage(scope, '${reason}', '${type}') * pageSize, ${valtypeBinary})`).replace(/\[16,"(.*?)"]/g, (_, name) => `[16, builtin('${name}')]`)},
+${funcs.map(x => {
+  const wasm = JSON.stringify(x.wasm.filter(x => x.length && x[0] != null)).replace(/\["alloc","(.*?)","(.*?)",(.*?)\]/g, (_, reason, type, valtype) => `...number(allocPage(scope, '${reason}', '${type}') * pageSize, ${valtype})`).replace(/\[16,"(.*?)"]/g, (_, name) => `[16, builtin('${name}')]`).replace(/\["throw","(.*?)","(.*?)"\]/g, (_, constructor, message) => `...internalThrow(scope, '${constructor}', \`${message}\`)`);
+  return `  this.${x.name} = {
+    wasm: (scope, {${wasm.includes('allocPage(') ? 'allocPage,' : ''}${wasm.includes('builtin(') ? 'builtin,' : ''}${wasm.includes('internalThrow(') ? 'internalThrow,' : ''}}) => ${wasm},
     params: ${JSON.stringify(x.params)},
     typedParams: true,
     returns: ${JSON.stringify(x.returns)},
-    typedReturns: true,
+    ${x.returnType != null ? `returnType: ${JSON.stringify(x.returnType)}` : 'typedReturns: true'},
     locals: ${JSON.stringify(Object.values(x.locals).slice(x.params.length).map(x => x.type))},
     localNames: ${JSON.stringify(Object.keys(x.locals))},
-${x.data && x.data.length > 0 ? `    data: ${JSON.stringify(x.data)},` : ''}
-${x.exceptions && x.exceptions.length > 0 ? `    exceptions: ${JSON.stringify(x.exceptions)},` : ''}
-  };`.replaceAll('\n\n', '\n')).join('\n')}
+${x.data && x.data.length > 0 ? `    data: ${JSON.stringify(x.data)}` : ''}
+  };`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n')
+}).join('\n')}
 };`;
 };
 
-const code = await precompile();
-// console.log(code);
-
-fs.writeFileSync(join(__dirname, 'generated_builtins.js'), code);
+fs.writeFileSync(join(__dirname, 'generated_builtins.js'), await precompile());

package/compiler/prefs.js

@@ -1,6 +1,6 @@
-const onByDefault = [ 'bytestring' ];
+const onByDefault = [ 'bytestring', 'aotPointerOpt', 'treeshakeWasmImports', 'alwaysMemory' ];
 
-const cache = {};
+let cache = {};
 const obj = new Proxy({}, {
   get(_, p) {
     // intentionally misses with undefined values cached
@@ -9,11 +9,12 @@ const obj = new Proxy({}, {
     return cache[p] = (() => {
       // fooBar -> foo-bar
       const name = p[0] === '_' ? p : p.replace(/[A-Z]/g, c => `-${c.toLowerCase()}`);
-      if (process.argv.includes('-' + name)) return true;
-      if (process.argv.includes('-no-' + name)) return false;
+      const prefix = name.length === 1 ? '-' : '--';
+      if (process.argv.includes(prefix + name)) return true;
+      if (process.argv.includes(prefix + 'no-' + name)) return false;
 
-      const valArg = process.argv.find(x => x.startsWith(`-${name}=`));
-      if (valArg) return valArg.slice(name.length + 2);
+      const valArg = process.argv.find(x => x.startsWith(`${prefix}${name}=`));
+      if (valArg) return valArg.slice(name.length + 1 + prefix.length);
 
       if (onByDefault.includes(p)) return true;
       return undefined;

package/compiler/prototype.js

@@ -1,26 +1,10 @@
-import { Opcodes, Blocktype, Valtype, ValtypeSize, PageSize } from "./wasmSpec.js";
-import { number } from "./embedding.js";
-import { unsignedLEB128 } from "./encoding.js";
-import { UNDEFINED } from "./builtins.js";
+import { Opcodes, Blocktype, Valtype, ValtypeSize } from './wasmSpec.js';
+import { number } from './embedding.js';
+import { unsignedLEB128 } from './encoding.js';
+import { UNDEFINED } from './builtins.js';
+import { TYPES } from './types.js';
 import Prefs from './prefs.js';
 
-// todo: do not duplicate this
-const TYPES = {
-  number: 0x00,
-  boolean: 0x01,
-  string: 0x02,
-  undefined: 0x03,
-  object: 0x04,
-  function: 0x05,
-  symbol: 0x06,
-  bigint: 0x07,
-
-  // these are not "typeof" types but tracked internally
-  _array: 0x10,
-  _regexp: 0x11,
-  _bytestring: 0x12
-};
-
 // todo: turn these into built-ins once arrays and these become less hacky
 
 export const PrototypeFuncs = function() {
@@ -30,7 +14,7 @@ export const PrototypeFuncs = function() {
   if (Prefs.zeroChecks) zeroChecks = Prefs.zeroChecks.split('=')[1].split(',').reduce((acc, x) => { acc[x.toLowerCase()] = true; return acc; }, {});
     else zeroChecks = {};
 
-  this[TYPES._array] = {
+  this[TYPES.array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
     at: (pointer, length, wIndex, iTmp) => [
       ...wIndex,
@@ -150,7 +134,7 @@ export const PrototypeFuncs = function() {
     shift: (pointer, length) => [
       // if length == 0, noop
       ...length.getCachedI32(),
-      Opcodes.i32_eqz,
+      [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
       [ Opcodes.br, 1 ],
@@ -269,10 +253,10 @@ export const PrototypeFuncs = function() {
     ]
   };
 
-  this[TYPES._array].at.local = Valtype.i32;
-  this[TYPES._array].push.noArgRetLength = true;
-  this[TYPES._array].fill.local = valtypeBinary;
-  this[TYPES._array].fill.returnType = TYPES._array;
+  this[TYPES.array].at.local = Valtype.i32;
+  this[TYPES.array].push.noArgRetLength = true;
+  this[TYPES.array].fill.local = valtypeBinary;
+  this[TYPES.array].fill.returnType = TYPES.array;
 
   this[TYPES.string] = {
     at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
@@ -492,7 +476,7 @@ export const PrototypeFuncs = function() {
   this[TYPES.string].isWellFormed.returnType = TYPES.boolean;
 
   if (Prefs.bytestring) {
-    this[TYPES._bytestring] = {
+    this[TYPES.bytestring] = {
       at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
         const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
@@ -622,14 +606,14 @@ export const PrototypeFuncs = function() {
       }
     };
 
-    this[TYPES._bytestring].at.local = Valtype.i32;
-    this[TYPES._bytestring].at.returnType = TYPES._bytestring;
-    this[TYPES._bytestring].charAt.returnType = TYPES._bytestring;
-    this[TYPES._bytestring].charCodeAt.local = Valtype.i32;
-    this[TYPES._bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
+    this[TYPES.bytestring].at.local = Valtype.i32;
+    this[TYPES.bytestring].at.returnType = TYPES.bytestring;
+    this[TYPES.bytestring].charAt.returnType = TYPES.bytestring;
+    this[TYPES.bytestring].charCodeAt.local = Valtype.i32;
+    this[TYPES.bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
-    this[TYPES._bytestring].isWellFormed.local = Valtype.i32;
-    this[TYPES._bytestring].isWellFormed.local2 = Valtype.i32;
-    this[TYPES._bytestring].isWellFormed.returnType = TYPES.boolean;
+    this[TYPES.bytestring].isWellFormed.local = Valtype.i32;
+    this[TYPES.bytestring].isWellFormed.local2 = Valtype.i32;
+    this[TYPES.bytestring].isWellFormed.returnType = TYPES.boolean;
   }
 };

package/compiler/types.js

@@ -0,0 +1,38 @@
+export const TYPES = {
+  number: 0x00,
+  boolean: 0x01,
+  string: 0x02,
+  undefined: 0x03,
+  object: 0x04,
+  function: 0x05,
+  symbol: 0x06,
+  bigint: 0x07
+};
+
+export const TYPE_NAMES = {
+  [TYPES.number]: 'Number',
+  [TYPES.boolean]: 'Boolean',
+  [TYPES.string]: 'String',
+  [TYPES.undefined]: 'undefined',
+  [TYPES.object]: 'Object',
+  [TYPES.function]: 'Function',
+  [TYPES.symbol]: 'Symbol',
+  [TYPES.bigint]: 'BigInt'
+};
+
+export const INTERNAL_TYPE_BASE = 0x10;
+let internalTypeIndex = INTERNAL_TYPE_BASE;
+const registerInternalType = name => {
+  const n = internalTypeIndex++;
+  TYPES[name.toLowerCase()] = n;
+  TYPE_NAMES[n] = name;
+};
+
+// note: when adding a new internal type, please also add a deserializer to wrap.js
+// (it is okay to add a throw todo deserializer for wips)
+
+registerInternalType('Array');
+registerInternalType('RegExp');
+registerInternalType('ByteString');
+registerInternalType('Date');
+registerInternalType('Set');

package/compiler/wasmSpec.js

@@ -1,4 +1,13 @@
-import { enumify } from "../util/enum.js";
+const enumify = (...args) => {
+  const obj = {};
+
+  for (let i = 0; i < args.length; i++) {
+    obj[i] = args[i];
+    obj[args[i]] = i;
+  }
+
+  return obj;
+};
 
 export const Section = enumify('custom', 'type', 'import', 'func', 'table', 'memory', 'global', 'export', 'start', 'element', 'code', 'data', 'data_count', 'tag');
 export const ExportDesc = enumify('func', 'table', 'mem', 'global', 'tag');
@@ -76,6 +85,7 @@ export const Opcodes = {
   i64_store8: 0x3c,
   i64_store16: 0x3d,
 
+  memory_size: 0x3f,
   memory_grow: 0x40,
 
   i32_const: 0x41,
@@ -107,6 +117,8 @@ export const Opcodes = {
   i32_shl: 0x74,
   i32_shr_s: 0x75,
   i32_shr_u: 0x76,
+  i32_rotl: 0x77,
+  i32_rotr: 0x78,
 
   i64_eqz: 0x50,
   i64_eq: 0x51,
@@ -130,6 +142,7 @@ export const Opcodes = {
   i64_shr_s: 0x87,
   i64_shr_u: 0x88,
   i64_rotl: 0x89,
+  i64_rotr: 0x8a,
 
   f64_eq: 0x61,
   f64_ne: 0x62,