porffor 0.34.5 → 0.34.6

package/compiler/codegen.js

@@ -615,148 +615,22 @@ const concatStrings = (scope, left, right, leftType, rightType, allBytestrings =
   ];
 };
 
-const compareStrings = (scope, left, right, leftType, rightType, allBytestrings = false, skipTypeCheck = false) => {
-  // todo: this should be rewritten into a func
-  // todo: convert left and right to strings if not
-  // todo: optimize by looking up names in arrays and using that if exists?
-  // todo: optimize this if using literals/known lengths?
-
-  const leftPointer = localTmp(scope, 'compare_left_pointer', Valtype.i32);
-  const leftLength = localTmp(scope, 'compare_left_length', Valtype.i32);
-  const rightPointer = localTmp(scope, 'compare_right_pointer', Valtype.i32);
-
-  const index = localTmp(scope, 'compare_index', Valtype.i32);
-  const indexEnd = localTmp(scope, 'compare_index_end', Valtype.i32);
-
-  if (!skipTypeCheck && !allBytestrings) includeBuiltin(scope, '__Porffor_bytestringToString');
+const compareStrings = (scope, left, right, leftType, rightType) => {
+  // todo/perf: add mode to use strcmp instead
   return [
-    // setup pointers
-    ...(left.length === 0 ? [
-      Opcodes.i32_to_u,
-      [ Opcodes.local_set, rightPointer ],
-
-      Opcodes.i32_to_u,
-      [ Opcodes.local_set, leftPointer ],
-
-      [ Opcodes.local_get, leftPointer ],
-      [ Opcodes.local_get, rightPointer ],
-    ] : [
-      ...left,
-      Opcodes.i32_to_u,
-      [ Opcodes.local_tee, leftPointer ],
-
-      ...right,
-      Opcodes.i32_to_u,
-      [ Opcodes.local_tee, rightPointer ],
-    ]),
-
-    // fast path: check leftPointer == rightPointer
-    // use if (block) for everything after to "return" a value early
-    [ Opcodes.i32_ne ],
-    [ Opcodes.if, Valtype.i32 ],
-
-    // get lengths
-    [ Opcodes.local_get, leftPointer ],
-    [ Opcodes.i32_load, 0, 0 ],
-    [ Opcodes.local_tee, leftLength ],
-
-    [ Opcodes.local_get, rightPointer ],
-    [ Opcodes.i32_load, 0, 0 ],
-
-    ...(skipTypeCheck || allBytestrings ? [] : [
-      ...leftType,
-      ...number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-      [ Opcodes.if, Blocktype.void ],
-      [ Opcodes.local_get, leftPointer ],
-      [ Opcodes.local_get, leftLength ],
-      [ Opcodes.call, funcIndex.__Porffor_bytestringToString ],
-      [ Opcodes.local_set, leftPointer ],
-      [ Opcodes.end ],
-
-      ...rightType,
-      ...number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-      [ Opcodes.if, Blocktype.void ],
-      [ Opcodes.local_get, rightPointer ],
-      [ Opcodes.local_get, rightPointer ],
-      [ Opcodes.i32_load, 0, 0 ],
-      [ Opcodes.call, funcIndex.__Porffor_bytestringToString ],
-      [ Opcodes.local_set, rightPointer ],
-      [ Opcodes.end ]
-    ]),
-
-    // fast path: check leftLength != rightLength
-    [ Opcodes.i32_ne ],
-    [ Opcodes.if, Blocktype.void ],
-    ...number(0, Valtype.i32),
-    [ Opcodes.br, 1 ],
-    [ Opcodes.end ],
-
-    // no fast path for length = 0 as it would probably be slower for most of the time?
-
-    // tmp could have already been used
-    ...number(0, Valtype.i32),
-    [ Opcodes.local_set, index ],
-
-    // setup index end as length * sizeof valtype (1 for bytestring, 2 for string)
-    // we do this instead of having to do mul/div each iter for perf™
-    [ Opcodes.local_get, leftLength ],
-    ...(allBytestrings ? [] : [
-      ...number(ValtypeSize.i16, Valtype.i32),
-      [ Opcodes.i32_mul ],
-    ]),
-    [ Opcodes.local_set, indexEnd ],
-
-    // iterate over each char and check if eq
-    [ Opcodes.loop, Blocktype.void ],
-
-    // fetch left
-    [ Opcodes.local_get, index ],
-    [ Opcodes.local_get, leftPointer ],
-    [ Opcodes.i32_add ],
-    allBytestrings ?
-      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ] :
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
-
-    // fetch right
-    [ Opcodes.local_get, index ],
-    [ Opcodes.local_get, rightPointer ],
-    [ Opcodes.i32_add ],
-    allBytestrings ?
-      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ] :
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
-
-    // not equal, "return" false
-    [ Opcodes.i32_ne ],
-    [ Opcodes.if, Blocktype.void ],
-    ...number(0, Valtype.i32),
-    [ Opcodes.br, 2 ],
-    [ Opcodes.end ],
-
-    // index += sizeof valtype (1 for bytestring, 2 for string)
-    [ Opcodes.local_get, index ],
-    ...number(allBytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
-    [ Opcodes.i32_add ],
-    [ Opcodes.local_tee, index ],
-
-    // if index < index end (length * sizeof valtype), loop
-    [ Opcodes.local_get, indexEnd ],
-    [ Opcodes.i32_lt_s ],
-    [ Opcodes.br_if, 0 ],
-    [ Opcodes.end ],
+    ...left,
+    ...(valtypeBinary === Valtype.i32 ? [ [ Opcodes.f64_convert_i32_s ] ] : []),
+    ...leftType,
 
-    // no failed checks, so true!
-    ...number(1, Valtype.i32),
+    ...right,
+    ...(valtypeBinary === Valtype.i32 ? [ [ Opcodes.f64_convert_i32_s ] ] : []),
+    ...rightType,
 
-    // pointers match, so true
-    [ Opcodes.else ],
-    ...number(1, Valtype.i32),
-    [ Opcodes.end ],
+    [ Opcodes.call, includeBuiltin(scope, '__Porffor_compareStrings').index ],
+    [ Opcodes.drop ],
 
-    // convert i32 result to valtype
-    // do not do as automatically added by binary exp gen for equality ops
-    // Opcodes.i32_from_u
+    // convert valtype result to i32 as i32 output expected
+    Opcodes.i32_trunc_sat_f64_u
   ];
 };
 
@@ -999,9 +873,7 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     // string comparison
     if (op === '===' || op === '==' || op === '!==' || op === '!=') {
       return [
-        ...left,
-        ...right,
-        ...compareStrings(scope, [], [], leftType, rightType, false, knownLeft === TYPES.string && knownRight === TYPES.string),
+        ...compareStrings(scope, left, right, leftType, rightType),
         ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : [])
       ];
     }
@@ -1027,9 +899,7 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     // string comparison
     if (op === '===' || op === '==' || op === '!==' || op === '!=') {
       return [
-        ...left,
-        ...right,
-        ...compareStrings(scope, [], [], leftType, rightType, knownLeft === TYPES.bytestring && knownRight === TYPES.bytestring),
+        ...compareStrings(scope, left, right, leftType, rightType),
         ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : [])
       ];
     }
@@ -1118,43 +988,19 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     tmpRight = localTmp(scope, '__tmpop_right');
 
     ops.unshift(...stringOnly([
-      // if left is bytestring
+      // if left or right are string or bytestring
       ...leftType,
+      ...number(TYPE_FLAGS.parity, Valtype.i32),
+      [ Opcodes.i32_or ],
       ...number(TYPES.bytestring, Valtype.i32),
       [ Opcodes.i32_eq ],
 
-      // if right is bytestring
       ...rightType,
-      ...number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-
-      // if both are true
-      [ Opcodes.i32_and ],
-      [ Opcodes.if, Blocktype.void ],
-      ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ], leftType, rightType, true),
-      ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : []),
-      [ Opcodes.br, 1 ],
-      [ Opcodes.end ],
-
-      // if left is string or bytestring
-      ...leftType,
-      ...number(TYPES.string, Valtype.i32),
-      [ Opcodes.i32_eq ],
-      ...leftType,
-      ...number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
+      ...number(TYPE_FLAGS.parity, Valtype.i32),
       [ Opcodes.i32_or ],
-
-      // if right is string or bytestring
-      ...rightType,
-      ...number(TYPES.string, Valtype.i32),
-      [ Opcodes.i32_eq ],
-      ...rightType,
       ...number(TYPES.bytestring, Valtype.i32),
       [ Opcodes.i32_eq ],
-      [ Opcodes.i32_or ],
 
-      // if either
       [ Opcodes.i32_or ],
       [ Opcodes.if, Blocktype.void ],
       ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ], leftType, rightType),
@@ -2589,7 +2435,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
             // get if func we are calling is a constructor or not
             [ Opcodes.local_get, funcLocal ],
-            ...number(128, Valtype.i32),
+            ...number(64, Valtype.i32),
             [ Opcodes.i32_mul ],
             ...number(4, Valtype.i32),
             [ Opcodes.i32_add ],
@@ -2615,7 +2461,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
             // [ Opcodes.call, 1 ],
 
             // [ Opcodes.local_get, funcLocal ],
-            // ...number(128, Valtype.i32),
+            // ...number(64, Valtype.i32),
             // [ Opcodes.i32_mul ],
             // [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ],
             // Opcodes.i32_from_u,
@@ -2627,7 +2473,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
             ...brTable([
               // get argc of func we are calling
               [ Opcodes.local_get, funcLocal ],
-              ...number(128, Valtype.i32),
+              ...number(64, Valtype.i32),
               [ Opcodes.i32_mul ],
               [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ]
             ], tableBc, valtypeBinary)

package/compiler/wrap.js

@@ -318,7 +318,7 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
   const printDecomp = (middleIndex, func, funcs, globals, exceptions) => {
     console.log(`\x1B[35m\x1B[1mporffor backtrace\u001b[0m`);
 
-    const surrounding = Prefs.backtraceSurrounding ?? 5;
+    const surrounding = Prefs.backtraceSurrounding ?? 10;
     let min = middleIndex - surrounding;
     let max = middleIndex + surrounding + 1;
     if (Prefs.backtraceFunc || middleIndex == -1) {
@@ -350,7 +350,7 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
         Number.isNaN(funcInd) || Number.isNaN(blobOffset)) return false;
 
     // convert blob offset -> function wasm offset
-    const func = funcs.find(x => x.index === funcInd);
+    const func = funcs.find(x => x.asmIndex === funcInd);
     if (!func) return false;
 
     const { wasm: assembledWasmFlat, wasmNonFlat: assembledWasmOps, localDecl } = func.assembled;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.34.5+b927e0e77",
+  "version": "0.34.6+581b45353",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/r.js

@@ -0,0 +1,113 @@
+function $DONE(error) {
+  if (error) {
+    Porffor.printStatic('Test262:AsyncTestFailure:Error: unknown');
+  } else {
+    Porffor.printStatic('Test262:AsyncTestComplete');
+  }
+}
+function assert(mustBeTrue) {
+  if (mustBeTrue === true) {
+    return;
+  }
+
+  throw new Test262Error('assert failed');
+}
+
+assert.throws = function (expectedErrorConstructor, func) {
+  if (typeof func !== 'function') {
+    throw new Test262Error('assert.throws invoked with a non-function value');
+  }
+
+  try {
+    func();
+  } catch {
+    return;
+  }
+
+  throw new Test262Error('assert.throws failed');
+};
+
+assert._isSameValue = function (a, b) {
+  if (a === b) {
+    // Handle +/-0 vs. -/+0
+    return a !== 0 || 1 / a === 1 / b;
+  }
+
+  // Handle NaN vs. NaN
+  return a !== a && b !== b;
+};
+
+assert.sameValue = function (actual, expected) {
+  if (assert._isSameValue(actual, expected)) {
+    return;
+  }
+
+  throw new Test262Error('assert.sameValue failed');
+};
+
+assert.notSameValue = function (actual, unexpected) {
+  if (!assert._isSameValue(actual, unexpected)) {
+    return;
+  }
+
+  throw new Test262Error('assert.notSameValue failed');
+};
+// define our $262 here too
+var $262 = {
+  global: globalThis,
+  gc() { /* noop */ },
+  detachArrayBuffer(buffer) {
+    return Porffor.arraybuffer.detach(buffer);
+  },
+  getGlobal(name) {
+    return globalThis[name];
+  },
+  // todo: setGlobal
+  destroy() { /* noop */ },
+  agent: {}
+};
+
+function Test262Error() {}
+
+Test262Error.thrower = function (message) {
+  throw new Test262Error(message);
+};
+
+function $DONOTEVALUATE() {
+  throw 'Test262: This statement should not be evaluated.';
+}
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 25.4.5.3
+description: PerformPromiseThen on a rejected promise
+info: |
+    7. Return PerformPromiseThen(promise, onFulfilled, onRejected,
+       resultCapability).
+
+    25.4.5.3.1 PerformPromiseThen
+
+    [...]
+    9. Else if the value of promise's [[PromiseState]] internal slot is
+       "rejected",
+       a. Let reason be the value of promise's [[PromiseResult]] internal slot.
+       b. Perform EnqueueJob("PromiseJobs", PromiseReactionJob,
+          «rejectReaction, reason»).
+    [...]
+flags: [async]
+---*/
+
+var value = {};
+var p = new Promise(function(_, reject) {
+  reject(value);
+});
+
+p.then(function() {
+  $DONE('The `onFulfilled` handler should not be invoked.');
+}, function(x) {
+  if (x !== value) {
+    $DONE('The `onRejected` handler should be invoked with the promise result.');
+    return;
+  }
+  $DONE();
+});

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.34.5+b927e0e77';
+globalThis.version = '0.34.6+581b45353';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {

package/runner/repl.js

@@ -42,7 +42,7 @@ const memoryToString = mem => {
 
   const buf = new Uint8Array(mem.buffer);
 
-  let longestType = 0, longestName = 0;
+  let longestType = 4, longestName = 4;
   for (const x of lastPages) {
     const [ type, name ] = x.split(': ');
     if (type.length > longestType) longestType = type.length;