porffor 0.2.0-c7b7423 → 0.2.0-c908b46

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

@@ -1,8 +1,9 @@
 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 { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128, ieee754_binary64, unsignedLEB128_into, signedLEB128_into, ieee754_binary64_into } from './encoding.js';
+// import { number } from './embedding.js';
 import { importedFuncs } from './builtins.js';
 import { log } from "./log.js";
+import Prefs from './prefs.js';
 
 const createSection = (type, data) => [
   type,
@@ -26,12 +27,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 +45,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();
@@ -79,11 +80,11 @@ export default (funcs, globals, tags, pages, data, flags) => {
   }
   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(
@@ -95,18 +96,65 @@ export default (funcs, globals, tags, pages, data, flags) => {
   // https://github.com/WebAssembly/design/issues/1473#issuecomment-1431274746
   const chSection = !compileHints ? [] : customSection(
     'compilationHints',
-    // for now just do everything as optimise eager
+    // for now just do everything as optimize eager
     encodeVector(funcs.map(_ => chHint(0x02, 0x02, 0x02)))
   );
 
-  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 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;
@@ -150,7 +198,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
       if (typeCount !== 0) localDecl.push(encodeLocal(typeCount, lastType));
 
-      return encodeVector([ ...encodeVector(localDecl), ...x.wasm.flat().filter(x => x <= 0xff), Opcodes.end ]);
+      return encodeVector([ ...encodeVector(localDecl), ...x.wasm.flat().filter(x => x != null && x <= 0xff), Opcodes.end ]);
     }))
   );
 
@@ -169,7 +217,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)),

package/compiler/builtins/annexb_string.js

@@ -0,0 +1,72 @@
+export default () => {
+  let out = `// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+`;
+
+  const annexB_noArgs = (a0, a1) => out += `
+export const __String_prototype_${a0} = (_this: string) => {
+  let out: string = Porffor.s\`<${a1}>\`;
+
+  let outPtr: i32 = Porffor.wasm\`local.get \${out}\` + ${(2 + a1.length) * 2};
+
+  let thisPtr: i32 = Porffor.wasm\`local.get \${_this}\`;
+  let thisLen: i32 = _this.length;
+  let endPtr: i32 = thisPtr + thisLen * 2;
+
+  while (thisPtr < endPtr) {
+    let chr: i32 = Porffor.wasm.i32.load16_u(thisPtr, 0, 4);
+    Porffor.wasm.i32.store16(outPtr, chr, 0, 4);
+
+    thisPtr += 2;
+    outPtr += 2;
+  }
+
+  Porffor.wasm.i32.store16(outPtr, 60, 0, 4); // <
+  Porffor.wasm.i32.store16(outPtr, 47, 0, 6); // /
+
+${[...a1].map((x, i) => `  Porffor.wasm.i32.store16(outPtr, ${x.charCodeAt(0)}, 0, ${8 + i * 2}); // ${x}`).join('\n')}
+
+  Porffor.wasm.i32.store16(outPtr, 62, 0, ${8 + a1.length * 2}); // >
+
+  out.length = thisLen + ${a1.length * 2 + 2 + 3};
+
+  return out;
+};
+export const __ByteString_prototype_${a0} = (_this: bytestring) => {
+  let out: bytestring = Porffor.bs\`<${a1}>\`;
+
+  let outPtr: i32 = Porffor.wasm\`local.get \${out}\` + ${2 + a1.length};
+
+  let thisPtr: i32 = Porffor.wasm\`local.get \${_this}\`;
+  let thisLen: i32 = _this.length;
+  let endPtr: i32 = thisPtr + thisLen;
+
+  while (thisPtr < endPtr) {
+    let chr: i32 = Porffor.wasm.i32.load8_u(thisPtr++, 0, 4);
+    Porffor.wasm.i32.store8(outPtr++, chr, 0, 4);
+  }
+
+  Porffor.wasm.i32.store8(outPtr, 60, 0, 4); // <
+  Porffor.wasm.i32.store8(outPtr, 47, 0, 5); // /
+
+${[...a1].map((x, i) => `  Porffor.wasm.i32.store8(outPtr, ${x.charCodeAt(0)}, 0, ${6 + i}); // ${x}`).join('\n')}
+
+  Porffor.wasm.i32.store8(outPtr, 62, 0, ${6 + a1.length}); // >
+
+  out.length = thisLen + ${a1.length * 2 + 2 + 3};
+
+  return out;
+};
+`;
+
+  annexB_noArgs('big', 'big');
+  annexB_noArgs('blink', 'blink');
+  annexB_noArgs('bold', 'b');
+  annexB_noArgs('fixed', 'tt');
+  annexB_noArgs('italics', 'i');
+  annexB_noArgs('small', 'small');
+  annexB_noArgs('strike', 'strike');
+  annexB_noArgs('sub', 'sub');
+  annexB_noArgs('sup', 'sup');
+
+  return out;
+};

package/compiler/builtins/annexb_string.ts

@@ -0,0 +1,18 @@
+// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+
+export const __String_prototype_trimLeft = (_this: string) => {
+  return __String_prototype_trimStart(_this);
+};
+
+export const __ByteString_prototype_trimLeft = (_this: string) => {
+  return __ByteString_prototype_trimStart(_this);
+};
+
+
+export const __String_prototype_trimRight = (_this: string) => {
+  return __String_prototype_trimEnd(_this);
+};
+
+export const __ByteString_prototype_trimEnd = (_this: string) => {
+  return __ByteString_prototype_trimRight(_this);
+};

package/compiler/builtins/array.ts

@@ -0,0 +1,145 @@
+// @porf --funsafe-no-unlikely-proto-checks
+
+export const __Array_isArray = (x: unknown): boolean =>
+  // Porffor.wasm`local.get ${x+1}` == Porffor.TYPES.array;
+  Porffor.rawType(x) == Porffor.TYPES.array;
+
+export const __Array_prototype_slice = (_this: any[], start: number, end: number) => {
+  const len: i32 = _this.length;
+  if (Porffor.rawType(end) == Porffor.TYPES.undefined) end = len;
+
+  start |= 0;
+  end |= 0;
+
+  if (start < 0) {
+    start = len + start;
+    if (start < 0) start = 0;
+  }
+  if (start > len) start = len;
+  if (end < 0) {
+    end = len + end;
+    if (end < 0) end = 0;
+  }
+  if (end > len) end = len;
+
+  let out: any[] = [];
+
+  if (start > end) return out;
+
+  let outPtr: i32 = Porffor.wasm`local.get ${out}`;
+  let thisPtr: i32 = Porffor.wasm`local.get ${_this}`;
+
+  const thisPtrEnd: i32 = thisPtr + end * 8;
+
+  thisPtr += start * 8;
+
+  while (thisPtr < thisPtrEnd) {
+    Porffor.wasm.f64.store(outPtr, Porffor.wasm.f64.load(thisPtr, 0, 4), 0, 4);
+    thisPtr += 8;
+    outPtr += 8;
+  }
+
+  out.length = end - start;
+
+  return out;
+};
+
+export const __Array_prototype_indexOf = (_this: any[], searchElement: any, position: number) => {
+  const len: i32 = _this.length;
+  if (position > 0) {
+    if (position > len) position = len;
+      else position |= 0;
+  } else position = 0;
+
+  for (let i: i32 = position; i < len; i++) {
+    if (_this[i] == searchElement) return i;
+  }
+
+  return -1;
+};
+
+export const __Array_prototype_lastIndexOf = (_this: any[], searchElement: any, position: number) => {
+  const len: i32 = _this.length;
+  if (position > 0) {
+    if (position > len) position = len;
+      else position |= 0;
+  } else position = 0;
+
+  for (let i: i32 = len - 1; i >= position; i--) {
+    if (_this[i] == searchElement) return i;
+  }
+
+  return -1;
+};
+
+export const __Array_prototype_includes = (_this: any[], searchElement: any, position: number) => {
+  const len: i32 = _this.length;
+  if (position > 0) {
+    if (position > len) position = len;
+      else position |= 0;
+  } else position = 0;
+
+  for (let i: i32 = position; i < len; i++) {
+    if (_this[i] == searchElement) return true;
+  }
+
+  return false;
+};
+
+export const __Array_prototype_with = (_this: any[], index: number, value: any) => {
+  const len: i32 = _this.length;
+  if (index < 0) {
+    index = len + index;
+    if (index < 0) {
+      // todo: throw RangeError: Invalid index
+      return null;
+    }
+  }
+
+  if (index > len) {
+    // todo: throw RangeError: Invalid index
+    return null;
+  }
+
+  // todo: allocator is bad here?
+  let out: any[] = [];
+
+  Porffor.clone(_this, out);
+
+  out[index] = value;
+
+  return out;
+};
+
+export const __Array_prototype_reverse = (_this: any[]) => {
+  const len: i32 = _this.length;
+
+  let start: i32 = 0;
+  let end: i32 = len - 1;
+
+  while (start < end) {
+    const tmp: i32 = _this[start];
+    _this[start++] = _this[end];
+    _this[end--] = tmp;
+  }
+
+  return _this;
+};
+
+// todo: this has memory/allocation bugs so sometimes crashes :(
+export const __Array_prototype_toReversed = (_this: any[]) => {
+  const len: i32 = _this.length;
+
+  let start: i32 = 0;
+  let end: i32 = len - 1;
+
+  let out: any[] = [];
+  out.length = len;
+
+  while (start < end) {
+    out[start] = _this[end];
+    out[end--] = _this[start++];
+  }
+
+  return out;
+};

package/compiler/builtins/base64.ts

@@ -0,0 +1,76 @@
+// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+
+export const btoa = (input: bytestring): bytestring => {
+  const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+  const keyStrPtr: i32 = Porffor.wasm`local.get ${keyStr}`;
+
+  let len: i32 = input.length;
+  let output: bytestring = '';
+  output.length = 4 * (len / 3 + !!(len % 3));
+
+  let i: i32 = Porffor.wasm`local.get ${input}`,
+      j: i32 = Porffor.wasm`local.get ${output}`;
+
+  // todo/perf: add some per 6 char variant using bitwise magic
+
+  const endPtr = i + len;
+  while (i < endPtr) {
+    const chr1: i32 = Porffor.wasm.i32.load8_u(i++, 0, 4);
+    const chr2: i32 = i < endPtr ? Porffor.wasm.i32.load8_u(i++, 0, 4) : -1;
+    const chr3: i32 = i < endPtr ? Porffor.wasm.i32.load8_u(i++, 0, 4) : -1;
+
+    const enc1: i32 = chr1 >> 2;
+    const enc2: i32 = ((chr1 & 3) << 4) | (chr2 == -1 ? 0 : (chr2 >> 4));
+    let enc3: i32 = ((chr2 & 15) << 2) | (chr3 == -1 ? 0 : (chr3 >> 6));
+    let enc4: i32 = chr3 & 63;
+
+    if (chr2 == -1) {
+      enc3 = 64;
+      enc4 = 64;
+    } else if (chr3 == -1) {
+      enc4 = 64;
+    }
+
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc1, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc2, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc3, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc4, 0, 4), 0, 4);
+  }
+
+  return output;
+};
+
+// todo: impl atob by converting below to "porf ts"
+/* var atob = function (input) {
+  const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+  let output = "";
+  let chr1, chr2, chr3;
+  let enc1, enc2, enc3, enc4;
+  let i = 0;
+
+  while (i < input.length) {
+    enc1 = keyStr.indexOf(input.charAt(i++));
+    enc2 = keyStr.indexOf(input.charAt(i++));
+    enc3 = keyStr.indexOf(input.charAt(i++));
+    enc4 = keyStr.indexOf(input.charAt(i++));
+
+    chr1 = (enc1 << 2) | (enc2 >> 4);
+    chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+    chr3 = ((enc3 & 3) << 6) | enc4;
+
+    // output += String.fromCharCode(chr1);
+    Porffor.bytestring.appendCharCode(output, chr1);
+
+    if (enc3 != 64) {
+      // output += String.fromCharCode(chr2);
+      Porffor.bytestring.appendCharCode(output, chr2);
+    }
+    if (enc4 != 64) {
+      // output += String.fromCharCode(chr3);
+      Porffor.bytestring.appendCharCode(output, chr3);
+    }
+  }
+
+  return output;
+}; */

package/compiler/builtins/boolean.ts

@@ -0,0 +1,21 @@
+// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+
+// 20.3.3.2 Boolean.prototype.toString ()
+// https://tc39.es/ecma262/#sec-boolean.prototype.tostring
+export const __Boolean_prototype_toString = (_this: boolean) => {
+  // 1. Let b be ? ThisBooleanValue(this value).
+  // 2. If b is true, return "true"; else return "false".
+
+  let out: bytestring = '';
+  if (_this) out = 'true';
+    else out = 'false';
+
+  return out;
+};
+
+// 20.3.3.3 Boolean.prototype.valueOf ()
+// https://tc39.es/ecma262/#sec-boolean.prototype.valueof
+export const __Boolean_prototype_valueOf = (_this: boolean) => {
+  // 1. Return ? ThisBooleanValue(this value).
+  return _this;
+};

package/compiler/builtins/crypto.ts

@@ -0,0 +1,120 @@
+// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+
+export const __crypto_randomUUID = (): bytestring => {
+  let bytes: bytestring = '................';
+
+  const bytesPtr: i32 = Porffor.wasm`local.get ${bytes}`;
+
+  let a: i32 = bytesPtr;
+  let aEndPtr: i32 = a + 16;
+  while (a < aEndPtr) {
+    Porffor.wasm.i32.store8(a++, Porffor.randomByte(), 0, 4);
+  }
+
+  // bytes[6] = (bytes[6] & 0b00001111) | 0b01000000
+  Porffor.wasm.i32.store8(
+    bytesPtr,
+    (Porffor.wasm.i32.load8_u(bytesPtr, 0, 10) & 0b00001111) | 0b01000000,
+    0,
+    10 // 4 + 6
+  );
+
+  // bytes[8] = (bytes[8] & 0b00111111) | 0b10000000
+  Porffor.wasm.i32.store8(
+    bytesPtr,
+    (Porffor.wasm.i32.load8_u(bytesPtr, 0, 12) & 0b00111111) | 0b10000000,
+    0,
+    12 // 4 + 8
+  );
+
+  let output: bytestring = '------------------------------------';
+
+  let i: i32 = Porffor.wasm`local.get ${output}`;
+  let j: i32 = bytesPtr;
+
+  // bytes[0..4]-bytes[4..6]-bytes[6..8]-bytes[8..10]-bytes[10..15]
+  // 00112233-4455-6677-8899-aabbccddeeff
+
+  // bytes[0..4]-
+  let endPtr: i32 = i + 8;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[4..6]-
+  endPtr = i + 4;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[6..8]-
+  endPtr = i + 4;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[8..10]-
+  endPtr = i + 4;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[10..15]
+  endPtr = i + 12;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+
+  return output;
+};