porffor 0.1.0

package/compiler/prototype.js

@@ -0,0 +1,272 @@
+import { Opcodes, Blocktype, Valtype, ValtypeSize, PageSize } from "./wasmSpec.js";
+import { number } from "./embedding.js";
+import { unsignedLEB128 } from "./encoding.js";
+import { UNDEFINED } from "./builtins.js";
+
+// todo: do not duplicate this
+const TYPES = {
+  number: 0xffffffffffff0,
+  boolean: 0xffffffffffff1,
+  string: 0xffffffffffff2,
+  undefined: 0xffffffffffff3,
+  object: 0xffffffffffff4,
+  function: 0xffffffffffff5,
+  symbol: 0xffffffffffff6,
+  bigint: 0xffffffffffff7,
+
+  // these are not "typeof" types but tracked internally
+  _array: 0xffffffffffff8
+};
+
+// todo: turn these into built-ins once arrays and these become less hacky
+
+export const PrototypeFuncs = function() {
+  const noUnlikelyChecks = process.argv.includes('-funsafe-no-unlikely-proto-checks');
+
+  this[TYPES._array] = {
+    // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
+    // todo: out of bounds (>) properly
+    at: (pointer, length, wIndex, iTmp) => [
+      ...wIndex,
+      Opcodes.i32_to,
+      [ Opcodes.local_tee, iTmp ],
+
+      // if index < 0: access index + array length
+      ...number(0, Valtype.i32),
+      [ Opcodes.i32_lt_s ],
+      [ Opcodes.if, Blocktype.void ],
+      [ Opcodes.local_get, iTmp ],
+      ...length.cachedI32,
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp ],
+      [ Opcodes.end ],
+
+      // if still < 0 or >= length: return undefined
+      [ Opcodes.local_get, iTmp ],
+      ...number(0, Valtype.i32),
+      [ Opcodes.i32_lt_s ],
+
+      [ Opcodes.local_get, iTmp ],
+      ...length.cachedI32,
+      [ Opcodes.i32_ge_s ],
+      [ Opcodes.i32_or ],
+
+      [ Opcodes.if, Blocktype.void ],
+      ...number(UNDEFINED),
+      [ Opcodes.br, 1 ],
+      [ Opcodes.end ],
+
+      [ Opcodes.local_get, iTmp ],
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_mul ],
+
+      // read from memory
+      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ]
+    ],
+
+    // todo: only for 1 argument
+    push: (pointer, length, wNewMember) => [
+      // get memory offset of array at last index (length)
+      ...length.cachedI32,
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_mul ],
+
+      // generated wasm for new member
+      ...wNewMember,
+
+      // store in memory
+      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+
+      // bump array length by 1 and return it
+      ...length.setI32([
+        ...length.cachedI32,
+        ...number(1, Valtype.i32),
+        [ Opcodes.i32_add ]
+      ]),
+
+      ...length.get
+    ],
+
+    pop: (pointer, length) => [
+      // if length == 0, noop
+      ...length.cachedI32,
+      [ Opcodes.i32_eqz ],
+      [ Opcodes.if, Blocktype.void ],
+      ...number(UNDEFINED),
+      [ Opcodes.br, 1 ],
+      [ Opcodes.end ],
+
+      // todo: should we store 0/undefined in "removed" element?
+
+      // decrement length by 1
+      ...length.setI32([
+        ...length.cachedI32,
+        ...number(1, Valtype.i32),
+        [ Opcodes.i32_sub ]
+      ]),
+
+      // load last element
+      ...length.cachedI32,
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_mul ],
+
+      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32 - ValtypeSize[valtype]) ]
+    ],
+
+    shift: (pointer, length) => [
+      // if length == 0, noop
+      ...length.cachedI32,
+      Opcodes.i32_eqz,
+      [ Opcodes.if, Blocktype.void ],
+      ...number(UNDEFINED),
+      [ Opcodes.br, 1 ],
+      [ Opcodes.end ],
+
+      // todo: should we store 0/undefined in "removed" element?
+
+      // decrement length by 1
+      ...length.setI32([
+        ...length.cachedI32,
+        ...number(1, Valtype.i32),
+        [ Opcodes.i32_sub ]
+      ]),
+
+      // load first element
+      ...number(0, Valtype.i32),
+      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+
+      // offset all elements by -1 ind
+      ...number(pointer + ValtypeSize.i32, Valtype.i32), // dst = base array index + length size
+      ...number(pointer + ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32), // src = base array index + length size + an index
+      ...number(pageSize - ValtypeSize.i32 - ValtypeSize[valtype], Valtype.i32), // size = PageSize - length size - an index
+      [ ...Opcodes.memory_copy, 0x00, 0x00 ]
+    ]
+  };
+
+  this[TYPES._array].at.local = Valtype.i32;
+  this[TYPES._array].push.noArgRetLength = true;
+
+  this[TYPES.string] = {
+    // todo: out of bounds properly
+    at: (pointer, length, wIndex, iTmp, arrayShell) => {
+      const [ newOut, newPointer ] = arrayShell(1, 'i16');
+
+      return [
+        // setup new/out array
+        ...newOut,
+        [ Opcodes.drop ],
+
+        ...number(0, Valtype.i32), // base 0 for store later
+        Opcodes.i32_to_u,
+
+        ...wIndex,
+        [ Opcodes.local_tee, iTmp ],
+
+        // if index < 0: access index + array length
+        ...number(0, Valtype.i32),
+        [ Opcodes.i32_lt_s ],
+        [ Opcodes.if, Blocktype.void ],
+        [ Opcodes.local_get, iTmp ],
+        ...length.cachedI32,
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_set, iTmp ],
+        [ Opcodes.end ],
+
+        // if still < 0 or >= length: return undefined
+        [ Opcodes.local_get, iTmp ],
+        ...number(0, Valtype.i32),
+        [ Opcodes.i32_lt_s ],
+
+        [ Opcodes.local_get, iTmp ],
+        ...length.cachedI32,
+        [ Opcodes.i32_ge_s ],
+        [ Opcodes.i32_or ],
+
+        [ Opcodes.if, Blocktype.void ],
+        ...number(UNDEFINED),
+        [ Opcodes.br, 1 ],
+        [ Opcodes.end ],
+
+        [ Opcodes.local_get, iTmp ],
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_mul ],
+
+        // load current string ind {arg}
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+
+        // store to new string ind 0
+        [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+        // return new string (pointer)
+        ...number(newPointer)
+      ];
+    },
+
+    // todo: out of bounds properly
+    charAt: (pointer, length, wIndex, _, arrayShell) => {
+      const [ newOut, newPointer ] = arrayShell(1, 'i16');
+
+      return [
+        // setup new/out array
+        ...newOut,
+        [ Opcodes.drop ],
+
+        ...number(0, Valtype.i32), // base 0 for store later
+
+        ...wIndex,
+
+        Opcodes.i32_to,
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_mul ],
+
+        // load current string ind {arg}
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+
+        // store to new string ind 0
+        [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+        // return new string (page)
+        ...number(newPointer)
+      ];
+    },
+
+    charCodeAt: (pointer, length, wIndex, iTmp) => {
+      return [
+        ...wIndex,
+        Opcodes.i32_to,
+        [ Opcodes.local_set, iTmp ],
+
+        // index < 0
+        ...(noUnlikelyChecks ? [] : [
+          [ Opcodes.local_get, iTmp ],
+          ...number(0, Valtype.i32),
+          [ Opcodes.i32_lt_s ],
+        ]),
+
+        // index >= length
+        [ Opcodes.local_get, iTmp ],
+        ...length.cachedI32,
+        [ Opcodes.i32_ge_s ],
+
+        ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+        [ Opcodes.if, Blocktype.void ],
+        ...number(NaN),
+        [ Opcodes.br, 1 ],
+        [ Opcodes.end ],
+
+        [ Opcodes.local_get, iTmp ],
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_mul ],
+
+        // load current string ind {arg}
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+        Opcodes.i32_from_u
+      ];
+    },
+  };
+
+  this[TYPES.string].at.local = valtypeBinary;
+  this[TYPES.string].at.returnType = TYPES.string;
+  this[TYPES.string].charAt.returnType = TYPES.string;
+  this[TYPES.string].charCodeAt.local = Valtype.i32;
+};

package/compiler/sections.js

@@ -0,0 +1,154 @@
+import { Valtype, FuncType, Empty, ExportDesc, Section, Magic, ModuleVersion, Opcodes, PageSize } from './wasmSpec.js';
+import { encodeVector, encodeString, encodeLocal } from './encoding.js';
+import { number } from './embedding.js';
+import { importedFuncs } from './builtins.js';
+
+const createSection = (type, data) => [
+  type,
+  ...encodeVector(data)
+];
+
+export default (funcs, globals, tags, pages, flags) => {
+  const types = [], typeCache = {};
+
+  const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
+
+  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 (optLevel >= 1 && 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 importFuncs = [];
+
+  if (optLevel < 1) {
+    importFuncs = importedFuncs;
+  } else {
+    let imports = new Map();
+
+    // tree shake imports
+    for (const f of funcs) {
+      for (const inst of f.wasm) {
+        if (inst[0] === Opcodes.call && inst[1] < importedFuncs.length) {
+          const idx = inst[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;
+        }
+      }
+    }
+
+    importFuncs = [...imports.values()];
+
+    // fix call indexes for non-imports
+    const delta = importedFuncs.length - importFuncs.length;
+    for (const f of funcs) {
+      f.index -= delta;
+
+      for (const inst of f.wasm) {
+        if (inst[0] === Opcodes.call && inst[1] >= importedFuncs.length) {
+          inst[1] -= delta;
+        }
+      }
+    }
+  }
+
+  if (optLog) log('sections', `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)) ]))
+  );
+
+  const funcSection = createSection(
+    Section.func,
+    encodeVector(funcs.map(x => getType(x.params, x.returns))) // type indexes
+  );
+
+  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 exports = funcs.filter(x => x.export).map((x, i) => [ ...encodeString(x.name === 'main' ? 'm' : x.name), ExportDesc.func, x.index ]);
+
+  const usesMemory = pages.size > 0;
+  const memorySection = !usesMemory ? [] : createSection(
+    Section.memory,
+    encodeVector([ [ 0x00, Math.ceil((pages.size * pageSize) / PageSize) ] ])
+  );
+
+  // export memory if used
+  if (usesMemory) exports.unshift([ ...encodeString('$'), ExportDesc.mem, 0x00 ]);
+
+  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 ]);
+
+  const exportSection = createSection(
+    Section.export,
+    encodeVector(exports)
+  );
+
+  const codeSection = createSection(
+    Section.code,
+    encodeVector(funcs.map(x => {
+      const locals = Object.values(x.locals).sort((a, b) => a.idx - b.idx).slice(x.params.length).sort((a, b) => a.idx - b.idx);
+
+      let localDecl = [], typeCount = 0, lastType;
+      for (let i = 0; i < locals.length; i++) {
+        const local = locals[i];
+        if (i !== 0 && local.type !== lastType) {
+          localDecl.push(encodeLocal(typeCount, lastType));
+          typeCount = 0;
+        }
+
+        typeCount++;
+        lastType = local.type;
+      }
+
+      if (typeCount !== 0) localDecl.push(encodeLocal(typeCount, lastType));
+
+      return encodeVector([ ...encodeVector(localDecl), ...x.wasm.flat().filter(x => x !== null), Opcodes.end ]);
+    }))
+  );
+
+  const typeSection = createSection(
+    Section.type,
+    encodeVector(types)
+  );
+
+  if (process.argv.includes('-sections')) console.log({
+    typeSection: typeSection.map(x => x.toString(16)),
+    importSection: importSection.map(x => x.toString(16)),
+    funcSection: funcSection.map(x => x.toString(16)),
+    globalSection: globalSection.map(x => x.toString(16)),
+    exportSection: exportSection.map(x => x.toString(16)),
+    codeSection: codeSection.map(x => x.toString(16))
+  });
+
+  return Uint8Array.from([
+    ...Magic,
+    ...ModuleVersion,
+    ...typeSection,
+    ...importSection,
+    ...funcSection,
+    ...memorySection,
+    ...tagSection,
+    ...globalSection,
+    ...exportSection,
+    ...codeSection
+  ]);
+};

package/compiler/wasmSpec.js

@@ -0,0 +1,200 @@
+import { enumify } from "../util/enum.js";
+
+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');
+
+export const Mut = enumify('const', 'var');
+
+export const Valtype = {
+  i32: 0x7f,
+  i64: 0x7e,
+  f64: 0x7c,
+  v128: 0x7b
+};
+
+export const Blocktype = {
+  void: 0x40,
+};
+
+export const Opcodes = {
+  unreachable: 0x00,
+  nop: 0x01,
+
+  block: 0x02,
+  loop: 0x03,
+  if: 0x04,
+  else: 0x05,
+
+  try: 0x06,
+  catch: 0x07,
+  catch_all: 0x19,
+  delegate: 0x18,
+  throw: 0x08,
+  rethrow: 0x09,
+
+  return: 0x0F,
+
+  call: 0x10,
+  call_indirect: 0x11,
+  return_call: 0x12,
+  return_call_indirect: 0x13,
+
+  end: 0x0b,
+  br: 0x0c,
+  br_if: 0x0d,
+  call: 0x10,
+  drop: 0x1a,
+
+  local_get: 0x20,
+  local_set: 0x21,
+  local_tee: 0x22, // set and return value (set and get combined)
+
+  global_get: 0x23,
+  global_set: 0x24,
+
+  i32_load: 0x28,
+  i64_load: 0x29,
+  f64_load: 0x2b,
+
+  i32_load16_s: 0x2e,
+  i32_load16_u: 0x2f,
+
+  i32_store16: 0x3b,
+
+  i32_store: 0x36,
+  i64_store: 0x37,
+  f64_store: 0x39,
+
+  memory_grow: 0x40,
+
+  i32_const: 0x41,
+  i64_const: 0x42,
+  f64_const: 0x44,
+
+  i32_eqz: 0x45,
+  i32_eq: 0x46,
+  i32_ne: 0x47,
+
+  i32_lt_s: 0x48,
+  i32_le_s: 0x4c,
+  i32_gt_s: 0x4a,
+  i32_ge_s: 0x4e,
+
+  i32_clz: 0x67,
+  i32_ctz: 0x68,
+  i32_popcnt: 0x69,
+
+  i32_add: 0x6a,
+  i32_sub: 0x6b,
+  i32_mul: 0x6c,
+  i32_div_s: 0x6d,
+  i32_rem_s: 0x6f,
+
+  i32_and: 0x71,
+  i32_or: 0x72,
+  i32_xor: 0x73,
+  i32_shl: 0x74,
+  i32_shr_s: 0x75,
+  i32_shr_u: 0x76,
+
+  i64_eqz: 0x50,
+  i64_eq: 0x51,
+  i64_ne: 0x52,
+
+  i64_lt_s: 0x53,
+  i64_le_s: 0x57,
+  i64_gt_s: 0x55,
+  i64_ge_s: 0x59,
+
+  i64_add: 0x7c,
+  i64_sub: 0x7d,
+  i64_mul: 0x7e,
+  i64_div_s: 0x7f,
+  i64_rem_s: 0x81,
+
+  i64_and: 0x83,
+  i64_or: 0x84,
+  i64_xor: 0x85,
+  i64_shl: 0x86,
+  i64_shr_s: 0x87,
+  i64_shr_u: 0x88,
+
+  f64_eq: 0x61,
+  f64_ne: 0x62,
+
+  f64_lt: 0x63,
+  f64_le: 0x65,
+  f64_gt: 0x64,
+  f64_ge: 0x66,
+
+  f64_abs: 0x99,
+  f64_neg: 0x9a,
+
+  f64_ceil: 0x9b,
+  f64_floor: 0x9c,
+  f64_trunc: 0x9d,
+  f64_nearest: 0x9e,
+
+  f64_sqrt: 0x9f,
+  f64_add: 0xa0,
+  f64_sub: 0xa1,
+  f64_mul: 0xa2,
+  f64_div: 0xa3,
+  f64_min: 0xa4,
+  f64_max: 0xa5,
+  f64_copysign: 0xa6,
+
+  i32_wrap_i64: 0xa7,
+  i64_extend_i32_s: 0xac,
+  i64_extend_i32_u: 0xad,
+
+  f32_demote_f64: 0xb6,
+  f64_promote_f32: 0xbb,
+
+  f64_convert_i32_s: 0xb7,
+  f64_convert_i32_u: 0xb8,
+  f64_convert_i64_s: 0xb9,
+  f64_convert_i64_u: 0xba,
+
+  i32_trunc_sat_f64_s: [ 0xfc, 0x02 ],
+  i32_trunc_sat_f64_u: [ 0xfc, 0x03 ],
+
+  memory_copy: [ 0xfc, 0x0a ],
+
+  // simd insts are 0xFD simdop: varuint32
+  v128_load: [ 0xfd, 0x00 ],
+  v128_const: [ 0xfd, 0x0c ],
+
+  i8x16_shuffle: [ 0xfd, 0x0d ],
+
+  i32x4_splat: [ 0xfd, 0x11 ],
+  i32x4_extract_lane: [ 0xfd, 0x1b ],
+  i32x4_replace_lane: [ 0xfd, 0x1c ],
+
+  i16x8_extract_lane: [ 0xfd, 0x18 ], // _s
+  i16x8_replace_lane: [ 0xfd, 0x1a ],
+
+  i32x4_add: [ 0xfd, 0xae, 0x01 ],
+  i32x4_sub: [ 0xfd, 0xb1, 0x01 ],
+  i32x4_mul: [ 0xfd, 0xb5, 0x01 ],
+
+  i32x4_dot_i16x8_s: [ 0xfd, 0xba, 0x01 ],
+};
+
+export const FuncType = 0x60;
+export const Empty = 0x00;
+
+export const Magic = [0x00, 0x61, 0x73, 0x6d];
+export const ModuleVersion = [0x01, 0x00, 0x00, 0x00];
+
+export const PageSize = 65536; // 64KiB (1024 * 8)
+
+export const ValtypeSize = {
+  i32: 4,
+  i64: 8,
+  f64: 8,
+
+  // special
+  i8: 1,
+  i16: 2
+};