porffor 0.47.5 → 0.47.7

package/README.md

@@ -82,107 +82,6 @@ Rhemyn is Porffor's own regex engine; it compiles literal regex to Wasm bytecode
 ### 2c
 2c is Porffor's own Wasm -> C compiler, using generated Wasm bytecode and internal info to generate specific and efficient/fast C code. Little boilerplate/preluded code or required external files, just for CLI binaries (not like wasm2c very much).
 
-## Supported
-See [optimizations](#optimizations) for opts implemented/supported.
-
-### Proposals
-These include some early (stage 1/0) and/or dead (last commit years ago) proposals but *I* think they are pretty neat, so.
-
-#### `Math` proposals (stage 1/0)
-
-- [`Math.clamp` Proposal](https://github.com/Richienb/proposal-math-clamp): `Math.clamp` (stage 0 - last commit april 2023)
-- [`Math` Extensions Proposal](https://github.com/rwaldron/proposal-math-extensions): `Math.scale`, `Math.radians`, `Math.degrees`, `Math.RAD_PER_DEG`, `Math.DEG_PER_RAD` (stage 1 - last commit september 2020)
-- [`Math.signbit` Proposal](https://github.com/tc39/proposal-Math.signbit): `Math.signbit` (stage 1 - last commit february 2020)
-
-### Language
-
-- Number literals
-- Declaring functions
-- Calling functions
-- `return`
-- Basic declarations (`let`/`const`/`var`)
-- Some basic integer operators (`+-/*%`)
-- Some basic integer bitwise operators (`&|`)
-- Equality operators (`==`, `!=`, etc)
-- GT/LT operators (`>`, `<`, `>=`, etc)
-- Some unary operators (`!`, `+`, `-`)
-- Logical operators (`&&`, `||`)
-- Declaring multiple variables in one (`let a, b = 0`)
-- Array destructuring (`let [a, ...b] = foo`)
-- Global variables (`var`/none in top scope)
-- Booleans
-- `if` and `if ... else`
-- Anonymous functions
-- Setting functions using vars (`const foo = function() { ... }`)
-- Arrow functions
-- `undefined`/`null`
-- Update expressions (`a++`, `++b`, `c--`, etc)
-- `for` loops (`for (let i = 0; i < N; i++)`, etc)
-- Basic objects (no prototypes)
-- `console.log`
-- `while` loops
-- `break` and `continue`
-- Named export funcs
-- IIFE support
-- Assignment operators (`+=`, `-=`, `>>=`, `&&=`, etc)
-- Conditional/ternary operator (`cond ? a : b`)
-- Recursive functions
-- Bare returns (`return`)
-- `throw` (literals only, hack for `new Error`)
-- Basic `try { ... } catch { ... }` (no error given)
-- Calling functions with non-matching arguments (eg `f(a, b); f(0); f(1, 2, 3);`)
-- `typeof`
-- Runtime errors for undeclared variables (`ReferenceError`), not functions (`TypeError`)
-- Array creation via `[]` (eg `let arr = [ 1, 2, 3 ]`)
-- Array member access via `arr[ind]` (eg `arr[0]`)
-- String literals (`'hello world'`)
-- String member (char) access via `str[ind]` (eg `str[0]`)
-- String concat (`+`) (eg `'a' + 'b'`)
-- Truthy/falsy (eg `!'' == true`)
-- String comparison (eg `'a' == 'a'`, `'a' != 'b'`)
-- Nullish coalescing operator (`??`)
-- `for...of` (arrays and strings)
-- `for...in`
-- Array member setting (`arr[0] = 2`, `arr[0] += 2`, etc)
-- Array constructor (`Array(5)`, `new Array(1, 2, 3)`)
-- Labelled statements (`foo: while (...)`)
-- `do...while` loops
-- Optional parameters (`(foo = 'bar') => { ... }`)
-- Rest parameters (`(...foo) => { ... }`)
-- `this`
-- Constructors (`new Foo`)
-- Classes (`class A {}`)
-- Await (`await promise`)
-
-### Built-ins
-
-- `NaN` and `Infinity`
-- `isNaN()` and `isFinite()`
-- Most of `Number` (`MAX_VALUE`, `MIN_VALUE`, `MAX_SAFE_INTEGER`, `MIN_SAFE_INTEGER`, `POSITIVE_INFINITY`, `NEGATIVE_INFINITY`, `EPSILON`, `NaN`, `isNaN`, `isFinite`, `isInteger`, `isSafeInteger`)
-- Most `Math` funcs (`sqrt`, `abs`, `floor`, `sign`, `round`, `trunc`, `clz32`, `fround`, `random`, `exp`, `log`, `log2`, `log10`, `pow`, `expm1`, `log1p`, `sqrt`, `cbrt`, `hypot`, `sin`, `cos`, `tan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `asin`, `acos`, `atan`, `atan2`)
-- Basic `globalThis` support
-- Basic `Boolean` and `Number`
-- Basic `eval` for literals
-- `Math.random()` using self-made xorshift128+ PRNG
-- Some of `performance` (`now()`, `timeOrigin`)
-- Most of `Array.prototype` (`at`, `push`, `pop`, `shift`, `fill`, `slice`, `indexOf`, `lastIndexOf`, `includes`, `with`, `reverse`, `toReversed`, `forEach`, `filter`, `map`, `find`, `findLast`, `findIndex`, `findLastIndex`, `every`, `some`, `reduce`, `reduceRight`, `join`, `toString`)
-- Most of `Array` (`of`, `isArray`)
-- Most of `String.prototype` (`at`, `charAt`, `charCodeAt`, `toUpperCase`, `toLowerCase`, `startsWith`, `endsWith`, `indexOf`, `lastIndexOf`, `includes`, `padStart`, `padEnd`, `substring`, `substr`, `slice`, `trimStart`, `trimEnd`, `trim`, `toString`, `big`, `blink`, `bold`, `fixed`, `italics`, `small`, `strike`, `sub`, `sup`,  `trimLeft`, `trimRight`, `trim`)
-- Some of `crypto` (`randomUUID`)
-- `escape`
-- `btoa`
-- Most of `Number.prototype` (`toString`, `toFixed`, `toExponential`)
-- `parseInt`
-- Spec-compliant `Date`
-- WIP typed arrays (`Uint8Array`, `Int32Array`, etc)
-- Synchronous `Promise`
-
-### Custom
-
-- Supports i32, i64, and f64 for valtypes
-- Intrinsic functions (see below)
-- Inlining wasm via ``asm`...``\` "macro"
-
 ## Versioning
 Porffor uses a unique versioning system, here's an example: `0.18.2+2aa3f0589`. Let's break it down:
 1. `0` - major, always `0` as Porffor is not ready yet
@@ -193,33 +92,6 @@ Porffor uses a unique versioning system, here's an example: `0.18.2+2aa3f0589`.
 ## Performance
 *For the features it supports most of the time*, Porffor is *blazingly fast* compared to most interpreters and common engines running without JIT. For those with JIT, it is usually slower by default, but can catch up with compiler arguments and typed input, even more so when compiling to native binaries.
 
-## Optimizations
-Mostly for reducing size. I do not really care about compiler perf/time as long as it is reasonable. We do not use/rely on external opt tools (`wasm-opt`, etc), instead doing optimization inside the compiler itself creating even smaller code sizes than `wasm-opt` itself can produce as we have more internal information.
-
-### Traditional opts
-- Inlining functions (WIP, limited)
-- Inline const math ops
-- Tail calls (behind flag `--tail-call`)
-
-### Wasm transforms
-- `local.set`, `local.get` -> `local.tee`
-- `i32.const 0`, `i32.eq` -> `i32.eqz`
-- `i64.extend_i32_s`, `i32.wrap_i64` -> ``
-- `f64.convert_i32_u`, `i32.trunc_sat_f64_s` -> ``
-- `return`, `end` -> `end`
-- Change const, convert to const of converted valtype (eg `f64.const`, `i32.trunc_sat_f64_s` -> `i32.const`)
-- Remove some redundant sets/gets
-- Remove unneeded single just used vars
-- Remove unneeded blocks (no `br`s inside)
-- Remove unused imports
-- Use data segments for initing arrays/strings
-- (Likely more not documented yet, todo)
-
-### Wasm module
-- Type cache/index (no repeated types)
-- No main func if empty (and other exports)
-- No tags if unused/optimized out
-
 ## Test262
 Porffor can run Test262 via some hacks/transforms which remove unsupported features whilst still doing the same asserts (eg simpler error messages using literals only). It currently passes >14% (see latest commit desc for latest and details). Use `node test262` to test, it will also show a difference of overall results between the last commit and current results.
 

package/compiler/2c.js

@@ -2,7 +2,7 @@ import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from '.
 import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
 import { operatorOpcode } from './expression.js';
 import { log } from './log.js';
-import {} from './prefs.js';
+import './prefs.js';
 
 const CValtype = {
   i8: 'u8',
@@ -222,7 +222,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
   const activeData = data.filter(x => x.page != null);
   if (activeData.length > 0) {
-    const dataOffset = x => pages.get(x.page).ind * pageSize;
+    const dataOffset = x => pages.allocs.get(x.page) ?? (pages.get(x.page) * pageSize);
     if (Prefs['2cMemcpy']) {
       prependMain.set('_data', activeData.map(x => `memcpy(_memory + ${dataOffset(x)}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n  '));
     } else {
@@ -857,7 +857,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
             const name = invOpcodes[i[0]];
             const func = CMemFuncs[i[0]];
             if (!prepend.has(name)) {
-              prepend.set(name, `${func.returns || 'void'} ${name}(i32 align, i32 offset, ${func.args.map((x, i) => `${func.argTypes[i]} ${x}`).join(', ')}) {\n  ${func.c.replaceAll('\n', '\n  ')}\n}\n`);
+              prepend.set(name, `inline ${func.returns || 'void'} ${name}(i32 align, i32 offset, ${func.args.map((x, i) => `${func.argTypes[i]} ${x}`).join(', ')}) {\n  ${func.c.replaceAll('\n', '\n  ')}\n}\n`);
             }
 
             const immediates = [ i[1], read_unsignedLEB128(i.slice(2)) ];
@@ -915,5 +915,5 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
   const makeIncludes = includes => [...includes.keys()].map(x => `#include <${x}>\n`).join('');
   out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + alwaysPreface + [...prepend.values()].join('\n') + '\n\n' + out;
 
-  return `// generated by porffor ${globalThis.version ?? '0.17.0'}\n` + out.trim();
+  return `// generated by porffor ${globalThis.version}\n` + out.trim();
 };

package/compiler/allocator.js

@@ -0,0 +1,64 @@
+import { PageSize } from './wasmSpec.js';
+import './prefs.js';
+
+const pagePtr = ind => {
+  if (ind === 0) return 16;
+  return ind * PageSize;
+};
+
+export const nameToReason = (scope, name) => {
+  let scopeName = scope.name;
+  if (globalThis.precompile && scopeName === 'main') scopeName = globalThis.precompile;
+
+  return `${Prefs.scopedPageNames ? (scopeName + '/') : ''}${name}`;
+};
+
+export const allocPage = ({ scope, pages }, name) => {
+  const reason = nameToReason(scope, name);
+
+  if (pages.has(reason)) {
+    return pagePtr(pages.get(reason));
+  }
+
+  const ind = pages.size;
+  pages.set(reason, ind);
+
+  scope.pages ??= new Map();
+  scope.pages.set(reason, ind);
+
+  return pagePtr(ind);
+};
+
+export const allocBytes = ({ scope, pages }, reason, bytes) => {
+  const allocs = pages.allocs ??= new Map();
+  const bins = pages.bins ??= [];
+
+  if (allocs.has(reason)) {
+    return allocs.get(reason);
+  }
+
+  let bin = bins.find(x => (PageSize - x.used) >= bytes);
+  if (!bin) {
+    // new bin
+    const page = pages.size;
+    bin = {
+      used: 0,
+      page
+    };
+
+    const id = bins.push(bin);
+    pages.set(`#bin_${id}`, page);
+  }
+
+  const ptr = pagePtr(bin.page) + bin.used;
+  bin.used += bytes;
+
+  allocs.set(reason, ptr);
+  return ptr;
+};
+
+export const allocStr = ({ scope, pages }, str, bytestring) => {
+  // basic string interning for ~free
+  const bytes = 4 + str.length * (bytestring ? 1 : 2);
+  return allocBytes({ scope, pages }, str, bytes);
+};

package/compiler/assemble.js

@@ -2,7 +2,7 @@ import { Valtype, FuncType, ExportDesc, Section, Magic, ModuleVersion, Opcodes,
 import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128, unsignedLEB128_into, signedLEB128_into, ieee754_binary64, ieee754_binary64_into } from './encoding.js';
 import { importedFuncs } from './builtins.js';
 import { log } from './log.js';
-import {} from './prefs.js';
+import './prefs.js';
 
 const createSection = (type, data) => [
   type,
@@ -372,7 +372,7 @@ export default (funcs, globals, tags, pages, data, noTreeshake = false) => {
       const bytes = unsignedLEB128(x.bytes.length).concat(x.bytes);
       if (x.page != null) {
         // type: active
-        let offset = pages.get(x.page).ind * pageSize;
+        let offset = pages.allocs.get(x.page) ?? (pages.get(x.page) * pageSize);
         if (offset === 0) offset = 16;
         bytes.unshift(0x00, Opcodes.i32_const, ...signedLEB128(offset), Opcodes.end);
       } else {

package/compiler/builtins/__internal_string.ts

@@ -158,44 +158,127 @@ end`;
       return true;
     } else {
       // string, string
-      let ap: i32 = a - 4;
-      let bp: i32 = b - 4;
+      // change char lengths to byte lengths
+      al *= 2;
+      bl *= 2;
+
+      // copied from bytestring, bytestring
+      let ap32: i32 = a - 28;
+      let bp32: i32 = b - 28;
+      let ap8: i32 = a - 4;
+      let bp8: i32 = b - 4;
       Porffor.wasm`
-loop 64
-  local.get ${ap}
-  local.get ${al}
-  i32.const 2
-  i32.mul
-  i32.add
-  i64.load 0 0
-
-  local.get ${bp}
-  local.get ${al}
-  i32.const 2
-  i32.mul
-  i32.add
-  i64.load 0 0
-
-  i64.ne
-  if 64
-    i32.const 0
-    i32.const 2
-    return
+;; load in 2 i64x2 chunks while length >= 32
+local.get ${al}
+i32.const 32
+i32.ge_s
+if 64
+  loop 64
+    local.get ${ap32}
+    local.get ${al}
+    i32.add
+    v128.load 0 0
+
+    local.get ${bp32}
+    local.get ${al}
+    i32.add
+    v128.load 0 0
+    v128.xor
+
+    local.get ${ap32}
+    local.get ${al}
+    i32.add
+    v128.load 0 16
+
+    local.get ${bp32}
+    local.get ${al}
+    i32.add
+    v128.load 0 16
+    v128.xor
+
+    v128.or
+    v128.any_true
+    if 64
+      i32.const 0
+      i32.const 2
+      return
+    end
+
+    local.get ${al}
+    i32.const 32
+    i32.sub
+    local.tee ${al}
+    i32.const 32
+    i32.ge_s
+    br_if 0
   end
+end
 
-  local.get ${al}
-  i32.const 4
-  i32.sub
-  local.tee ${al}
-  i32.const 4
-  i32.ge_s
-  br_if 0
-end`;
+;; load in i64 chunks while length >= 8
+local.get ${al}
+i32.const 8
+i32.ge_s
+if 64
+  loop 64
+    local.get ${ap8}
+    local.get ${al}
+    i32.add
+    i64.load 0 0
 
-      for (let i: i32 = 0; i < al; i++) {
-        if (Porffor.wasm.i32.load16_u(Porffor.wasm`local.get ${a}` + i*2, 0, 4) !=
-            Porffor.wasm.i32.load16_u(Porffor.wasm`local.get ${b}` + i*2, 0, 4)) return false;
-      }
+    local.get ${bp8}
+    local.get ${al}
+    i32.add
+    i64.load 0 0
+
+    i64.ne
+    if 64
+      i32.const 0
+      i32.const 2
+      return
+    end
+
+    local.get ${al}
+    i32.const 8
+    i32.sub
+    local.tee ${al}
+    i32.const 8
+    i32.ge_s
+    br_if 0
+  end
+end
+
+;; load in u16 chunks while length >= 2
+local.get ${al}
+i32.const 2
+i32.ge_s
+if 64
+  loop 64
+    local.get ${a}
+    local.get ${al}
+    i32.add
+    i32.load16_u 0 2
+
+    local.get ${b}
+    local.get ${al}
+    i32.add
+    i32.load16_u 0 2
+
+    i32.ne
+    if 64
+      i32.const 0
+      i32.const 2
+      return
+    end
+
+    local.get ${al}
+    i32.const 2
+    i32.sub
+    local.tee ${al}
+    i32.const 2
+    i32.ge_s
+    br_if 0
+  end
+end`;
       return true;
     }
   }

package/compiler/builtins/function.ts

@@ -1,7 +1,16 @@
 import type {} from './porffor.d.ts';
 
 export const __Function_prototype_toString = (_this: Function) => {
-  // todo: actually use source
-  let out: bytestring = 'function () {}';
+  const out: bytestring = Porffor.allocate();
+
+  const prefix: bytestring = 'function ';
+  Porffor.bytestring.appendStr(out, prefix);
+
+  Porffor.bytestring.appendStr(out, _this.name);
+
+  const postfix: bytestring = '() { [native code] }';
+  Porffor.bytestring.appendStr(out, postfix);
   return out;
-};
+};
+
+export const __Function_prototype_toLocaleString = (_this: Function) => __Function_prototype_toString(_this);

package/compiler/builtins.js

@@ -3,7 +3,7 @@ import ObjectBuiltins from './builtins_objects.js';
 import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
 import { number } from './embedding.js';
 import { TYPES, TYPE_NAMES } from './types.js';
-import {} from './prefs.js';
+import './prefs.js';
 import { unsignedLEB128 } from './encoding.js';
 
 export const importedFuncs = [
@@ -860,7 +860,7 @@ export const BuiltinFuncs = function() {
     wasm: (scope, { typeSwitch, makeString }) => {
       const bc = {};
       for (const x in TYPE_NAMES) {
-        bc[x] = makeString(scope, TYPE_NAMES[x], false, '#Porffor_type_result');
+        bc[x] = makeString(scope, TYPE_NAMES[x]);
       }
 
       return typeSwitch(scope, [ [ Opcodes.local_get, 1 ] ], bc);

package/compiler/builtins_objects.js

@@ -64,7 +64,7 @@ export default function({ builtinFuncs }, Prefs) {
             getPtr,
             ...number(existingFunc ? TYPES.function : TYPES.object, Valtype.i32),
 
-            ...makeString(scope, x, false, `#builtin_object_${name}_${x}`),
+            ...makeString(scope, x),
             Opcodes.i32_to_u,
             ...number(TYPES.bytestring, Valtype.i32),
 
@@ -109,7 +109,7 @@ export default function({ builtinFuncs }, Prefs) {
         }
 
         if (typeof d.value === 'string') {
-          this[k] = (scope, { makeString }) => makeString(scope, d.value, false, k);
+          this[k] = (scope, { makeString }) => makeString(scope, d.value);
           this[k].type = TYPES.bytestring;
           continue;
         }