porffor 0.2.0-e562242 → 0.2.0-eeb45f8

package/README.md

@@ -143,8 +143,8 @@ No particular order and no guarentees, just what could happen soon™
   - [`do` expressions](https://github.com/tc39/proposal-do-expressions)
   - [String Trim Characters](https://github.com/Kingwl/proposal-string-trim-characters)
 - Posts
-  - Type annotations for performance
   - Inlining investigation
+- Self hosted testing?
 
 ## Performance
 *For the things 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 not that much slower like a traditional interpreter would be; mostly the same or a bit faster/slower depending on what.
@@ -209,10 +209,13 @@ Porffor can run Test262 via some hacks/transforms which remove unsupported featu
 - `test262`: test262 runner and utils
 
 ## Usecases
-Basically none (other than giving people headaches). Potential ideas to come?
+Basically none right now (other than giving people headaches). Potential ideas:
+- Safety. As Porffor is written in JS, a memory-safe language\*, and compiles JS to Wasm, a fully sandboxed environment\*, it is quite safe. (\* These rely on the underlying implementations being secure. You could also run Wasm, or even Porffor itself, with an interpreter instead of a JIT for bonus security points too.)
+- Compiling JS to native binaries. This is still very early, [`2c`](#2c) is not that good yet :(
+- More in future probably?
 
 ## Usage
-Basically nothing will work :). See files in `test` for examples.
+Basically nothing will work :). See files in `test` and `bench` for examples.
 
 1. Clone repo
 2. `npm install`

package/compiler/builtins.js

@@ -1,4 +1,4 @@
-import { Blocktype, Opcodes, Valtype } from "./wasmSpec.js";
+import { Blocktype, Opcodes, Valtype, ValtypeSize } from "./wasmSpec.js";
 import { number, i32x4 } from "./embedding.js";
 
 export const importedFuncs = [
@@ -29,6 +29,21 @@ for (let i = 0; i < importedFuncs.length; i++) {
 
 const char = c => number(c.charCodeAt(0));
 
+const printStaticStr = str => {
+  const out = [];
+
+  for (let i = 0; i < str.length; i++) {
+    out.push(
+      // ...number(str.charCodeAt(i)),
+      ...number(str.charCodeAt(i), Valtype.i32),
+      Opcodes.i32_from_u,
+      [ Opcodes.call, importedFuncs.printChar ]
+    );
+  }
+
+  return out;
+};
+
 // todo: somehow diff between these (undefined != null) while remaining falsey in wasm as a number value
 export const UNDEFINED = 0;
 export const NULL = 0;
@@ -187,12 +202,125 @@ export const BuiltinFuncs = function() {
 
 
   this.__console_log = {
-    params: [ valtypeBinary ],
-    locals: [],
+    params: [ valtypeBinary, Valtype.i32 ],
+    typedParams: true,
+    locals: [ Valtype.i32, Valtype.i32 ],
     returns: [],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.call, importedFuncs.print ],
+    wasm: (scope, { TYPES, typeSwitch }) => [
+      ...typeSwitch(scope, [ [ Opcodes.local_get, 1 ] ], {
+        [TYPES.number]: [
+          [ Opcodes.local_get, 0 ],
+          [ Opcodes.call, importedFuncs.print ],
+        ],
+        [TYPES.boolean]: [
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.if, Blocktype.void ],
+          ...printStaticStr('true'),
+          [ Opcodes.else ],
+          ...printStaticStr('false'),
+          [ Opcodes.end ]
+        ],
+        [TYPES.string]: [
+          // simply print a string :))
+          // cache input pointer as i32
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.local_tee, 2 ],
+
+          // make end pointer
+          [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+          ...number(ValtypeSize.i16, Valtype.i32),
+          [ Opcodes.i32_mul ],
+
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_set, 3 ],
+
+          [ Opcodes.loop, Blocktype.void ],
+
+          // print current char
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+          Opcodes.i32_from_u,
+          [ Opcodes.call, importedFuncs.printChar ],
+
+          // increment pointer by sizeof i16
+          [ Opcodes.local_get, 2 ],
+          ...number(ValtypeSize.i16, Valtype.i32),
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_tee, 2 ],
+
+          // if pointer != end pointer, loop
+          [ Opcodes.local_get, 3 ],
+          [ Opcodes.i32_ne ],
+          [ Opcodes.br_if, 0 ],
+
+          [ Opcodes.end ]
+        ],
+        [TYPES._array]: [
+          ...printStaticStr('[ '),
+
+          // cache input pointer as i32
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.local_tee, 2 ],
+
+          // make end pointer
+          [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+          ...number(ValtypeSize[valtype], Valtype.i32),
+          [ Opcodes.i32_mul ],
+
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_set, 3 ],
+
+          [ Opcodes.loop, Blocktype.void ],
+
+          // print current char
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.load, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+          [ Opcodes.call, importedFuncs.print ],
+
+          // increment pointer by sizeof valtype
+          [ Opcodes.local_get, 2 ],
+          ...number(ValtypeSize[valtype], Valtype.i32),
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_tee, 2 ],
+
+          // if pointer != end pointer, print separator and loop
+          [ Opcodes.local_get, 3 ],
+          [ Opcodes.i32_ne ],
+          [ Opcodes.if, Blocktype.void ],
+          ...printStaticStr(', '),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
+
+          [ Opcodes.end ],
+
+          ...printStaticStr(' ]'),
+        ],
+        [TYPES.undefined]: [
+          ...printStaticStr('undefined')
+        ],
+        [TYPES.function]: [
+          ...printStaticStr('function () {}')
+        ],
+        [TYPES.object]: [
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.if, Blocktype.void ],
+          ...printStaticStr('{}'),
+          [ Opcodes.else ],
+          ...printStaticStr('null'),
+          [ Opcodes.end ]
+        ],
+        default: [
+          [ Opcodes.local_get, 0 ],
+          [ Opcodes.call, importedFuncs.print ],
+        ]
+      }, Blocktype.void),
+
       ...char('\n'),
       [ Opcodes.call, importedFuncs.printChar ]
     ]

package/compiler/codeGen.js

@@ -55,7 +55,7 @@ const todo = msg => {
 };
 
 const isFuncType = type => type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
-const generate = (scope, decl, global = false, name = undefined) => {
+const generate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
   switch (decl.type) {
     case 'BinaryExpression':
       return generateBinaryExp(scope, decl, global, name);
@@ -68,7 +68,12 @@ const generate = (scope, decl, global = false, name = undefined) => {
 
     case 'ArrowFunctionExpression':
     case 'FunctionDeclaration':
-      generateFunc(scope, decl);
+      const func = generateFunc(scope, decl);
+
+      if (decl.type.endsWith('Expression')) {
+        return number(func.index);
+      }
+
       return [];
 
     case 'BlockStatement':
@@ -81,7 +86,7 @@ const generate = (scope, decl, global = false, name = undefined) => {
       return generateExp(scope, decl);
 
     case 'CallExpression':
-      return generateCall(scope, decl, global, name);
+      return generateCall(scope, decl, global, name, valueUnused);
 
     case 'NewExpression':
       return generateNew(scope, decl, global, name);
@@ -680,6 +685,15 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
         [ Opcodes.i32_eqz ], */
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
       ],
+      [TYPES._bytestring]: [ // duplicate of string
+        [ Opcodes.local_get, tmp ],
+        ...(intIn ? [] : [ Opcodes.i32_to_u ]),
+
+        // get length
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+
+        ...(intOut ? [] : [ Opcodes.i32_from_u ])
+      ],
       default: def
     }, intOut ? Valtype.i32 : valtypeBinary)
   ];
@@ -707,6 +721,17 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
         [ Opcodes.i32_eqz ],
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
       ],
+      [TYPES._bytestring]: [ // duplicate of string
+        [ Opcodes.local_get, tmp ],
+        ...(intIn ? [] : [ Opcodes.i32_to_u ]),
+
+        // get length
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+
+        // if length == 0
+        [ Opcodes.i32_eqz ],
+        ...(intOut ? [] : [ Opcodes.i32_from_u ])
+      ],
       default: [
         // if value == 0
         [ Opcodes.local_get, tmp ],
@@ -947,6 +972,18 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     locals[nameParam(i)] = { idx: i, type: allLocals[i] };
   }
 
+  if (typeof wasm === 'function') {
+    const scope = {
+      name,
+      params,
+      locals,
+      returns,
+      localInd: allLocals.length,
+    };
+
+    wasm = wasm(scope, { TYPES, typeSwitch, makeArray });
+  }
+
   let baseGlobalIdx, i = 0;
   for (const type of globalTypes) {
     if (baseGlobalIdx === undefined) baseGlobalIdx = globalInd;
@@ -1027,7 +1064,8 @@ const TYPES = {
 
   // these are not "typeof" types but tracked internally
   _array: 0x10,
-  _regexp: 0x11
+  _regexp: 0x11,
+  _bytestring: 0x12
 };
 
 const TYPE_NAMES = {
@@ -1041,7 +1079,8 @@ const TYPE_NAMES = {
   [TYPES.bigint]: 'BigInt',
 
   [TYPES._array]: 'Array',
-  [TYPES._regexp]: 'RegExp'
+  [TYPES._regexp]: 'RegExp',
+  [TYPES._bytestring]: 'ByteString'
 };
 
 const getType = (scope, _name) => {
@@ -1094,6 +1133,8 @@ const getNodeType = (scope, node) => {
     if (node.type === 'Literal') {
       if (node.regex) return TYPES._regexp;
 
+      if (typeof node.value === 'string' && byteStringable(node.value)) return TYPES._bytestring;
+
       return TYPES[typeof node.value];
     }
 
@@ -1107,6 +1148,15 @@ const getNodeType = (scope, node) => {
 
     if (node.type === 'CallExpression' || node.type === 'NewExpression') {
       const name = node.callee.name;
+      if (!name) {
+        // iife
+        if (scope.locals['#last_type']) return [ getLastType(scope) ];
+
+        // presume
+        // todo: warn here?
+        return TYPES.number;
+      }
+
       const func = funcs.find(x => x.name === name);
 
       if (func) {
@@ -1201,7 +1251,7 @@ const getNodeType = (scope, node) => {
       if (node.operator === '!') return TYPES.boolean;
       if (node.operator === 'void') return TYPES.undefined;
       if (node.operator === 'delete') return TYPES.boolean;
-      if (node.operator === 'typeof') return TYPES.string;
+      if (node.operator === 'typeof') return process.argv.includes('-bytestring') ? TYPES._bytestring : TYPES.string;
 
       return TYPES.number;
     }
@@ -1210,7 +1260,9 @@ const getNodeType = (scope, node) => {
       // hack: if something.length, number type
       if (node.property.name === 'length') return TYPES.number;
 
-      // we cannot guess
+      if (scope.locals['#last_type']) return [ getLastType(scope) ];
+
+      // presume
       return TYPES.number;
     }
 
@@ -1261,16 +1313,7 @@ const generateLiteral = (scope, decl, global, name) => {
       return number(decl.value ? 1 : 0);
 
     case 'string':
-      const str = decl.value;
-      const rawElements = new Array(str.length);
-      let j = 0;
-      for (let i = 0; i < str.length; i++) {
-        rawElements[i] = str.charCodeAt(i);
-      }
-
-      return makeArray(scope, {
-        rawElements
-      }, global, name, false, 'i16')[0];
+      return makeString(scope, decl.value, global, name);
 
     default:
       return todo(`cannot generate literal of type ${typeof decl.value}`);
@@ -1291,9 +1334,9 @@ const countLeftover = wasm => {
 
     if (depth === 0)
       if ([Opcodes.throw,Opcodes.drop, Opcodes.local_set, Opcodes.global_set].includes(inst[0])) count--;
-        else if ([null, Opcodes.i32_eqz, Opcodes.i64_eqz, Opcodes.f64_ceil, Opcodes.f64_floor, Opcodes.f64_trunc, Opcodes.f64_nearest, Opcodes.f64_sqrt, Opcodes.local_tee, Opcodes.i32_wrap_i64, Opcodes.i64_extend_i32_s, Opcodes.i64_extend_i32_u, Opcodes.f32_demote_f64, Opcodes.f64_promote_f32, Opcodes.f64_convert_i32_s, Opcodes.f64_convert_i32_u, Opcodes.i32_clz, Opcodes.i32_ctz, Opcodes.i32_popcnt, Opcodes.f64_neg, Opcodes.end, Opcodes.i32_trunc_sat_f64_s[0], Opcodes.i32x4_extract_lane, Opcodes.i16x8_extract_lane, Opcodes.i32_load, Opcodes.i64_load, Opcodes.f64_load, Opcodes.v128_load, Opcodes.i32_load16_u, Opcodes.i32_load16_s, Opcodes.memory_grow].includes(inst[0]) && (inst[0] !== 0xfc || inst[1] < 0x0a)) {}
+        else if ([null, Opcodes.i32_eqz, Opcodes.i64_eqz, Opcodes.f64_ceil, Opcodes.f64_floor, Opcodes.f64_trunc, Opcodes.f64_nearest, Opcodes.f64_sqrt, Opcodes.local_tee, Opcodes.i32_wrap_i64, Opcodes.i64_extend_i32_s, Opcodes.i64_extend_i32_u, Opcodes.f32_demote_f64, Opcodes.f64_promote_f32, Opcodes.f64_convert_i32_s, Opcodes.f64_convert_i32_u, Opcodes.i32_clz, Opcodes.i32_ctz, Opcodes.i32_popcnt, Opcodes.f64_neg, Opcodes.end, Opcodes.i32_trunc_sat_f64_s[0], Opcodes.i32x4_extract_lane, Opcodes.i16x8_extract_lane, Opcodes.i32_load, Opcodes.i64_load, Opcodes.f64_load, Opcodes.v128_load, Opcodes.i32_load16_u, Opcodes.i32_load16_s, Opcodes.i32_load8_u, Opcodes.i32_load8_s, Opcodes.memory_grow].includes(inst[0]) && (inst[0] !== 0xfc || inst[1] < 0x0a)) {}
         else if ([Opcodes.local_get, Opcodes.global_get, Opcodes.f64_const, Opcodes.i32_const, Opcodes.i64_const, Opcodes.v128_const].includes(inst[0])) count++;
-        else if ([Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store, Opcodes.i32_store16].includes(inst[0])) count -= 2;
+        else if ([Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store, Opcodes.i32_store16, Opcodes.i32_store8].includes(inst[0])) count -= 2;
         else if (Opcodes.memory_copy[0] === inst[0] && Opcodes.memory_copy[1] === inst[1]) count -= 3;
         else if (inst[0] === Opcodes.return) count = 0;
         else if (inst[0] === Opcodes.call) {
@@ -1319,7 +1362,7 @@ const disposeLeftover = wasm => {
 const generateExp = (scope, decl) => {
   const expression = decl.expression;
 
-  const out = generate(scope, expression);
+  const out = generate(scope, expression, undefined, undefined, true);
   disposeLeftover(out);
 
   return out;
@@ -1377,7 +1420,7 @@ const RTArrayUtil = {
   ]
 };
 
-const generateCall = (scope, decl, _global, _name) => {
+const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   /* const callee = decl.callee;
   const args = decl.arguments;
 
@@ -1496,10 +1539,18 @@ const generateCall = (scope, decl, _global, _name) => {
       // use local for cached i32 length as commonly used
       const lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
       const pointerLocal = localTmp(scope, '__proto_pointer_cache', Valtype.i32);
-      const getPointer = [ [ Opcodes.local_get, pointerLocal ] ];
 
       // TODO: long-term, prototypes should be their individual separate funcs
 
+      const rawPointer = [
+        ...generate(scope, target),
+        Opcodes.i32_to_u
+      ];
+
+      const usePointerCache = !Object.values(protoCands).every(x => x.noPointerCache === true);
+      const getPointer = usePointerCache ? [ [ Opcodes.local_get, pointerLocal ] ] : rawPointer;
+
+      let allOptUnused = true;
       let lengthI32CacheUsed = false;
       const protoBC = {};
       for (const x in protoCands) {
@@ -1519,6 +1570,7 @@ const generateCall = (scope, decl, _global, _name) => {
         const protoLocal = protoFunc.local ? localTmp(scope, `__${protoName}_tmp`, protoFunc.local) : -1;
         const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${protoName}_tmp2`, protoFunc.local2) : -1;
 
+        let optUnused = false;
         const protoOut = protoFunc(getPointer, {
           getCachedI32: () => {
             lengthI32CacheUsed = true;
@@ -1533,10 +1585,15 @@ const generateCall = (scope, decl, _global, _name) => {
           return makeArray(scope, {
             rawElements: new Array(length)
           }, _global, _name, true, itemType);
+        }, () => {
+          optUnused = true;
+          return unusedValue;
         });
 
+        if (!optUnused) allOptUnused = false;
+
         protoBC[x] = [
-          [ Opcodes.block, valtypeBinary ],
+          [ Opcodes.block, unusedValue && optUnused ? Blocktype.void : valtypeBinary ],
           ...protoOut,
 
           ...number(protoFunc.returnType ?? TYPES.number, Valtype.i32),
@@ -1545,11 +1602,13 @@ const generateCall = (scope, decl, _global, _name) => {
         ];
       }
 
-      return [
-        ...generate(scope, target),
+      // todo: if some cands use optUnused and some don't, we will probably crash
 
-        Opcodes.i32_to_u,
-        [ Opcodes.local_set, pointerLocal ],
+      return [
+        ...(usePointerCache ? [
+          ...rawPointer,
+          [ Opcodes.local_set, pointerLocal ],
+        ] : []),
 
         ...(!lengthI32CacheUsed ? [] : [
           ...RTArrayUtil.getLengthI32(getPointer),
@@ -1561,7 +1620,7 @@ const generateCall = (scope, decl, _global, _name) => {
 
           // TODO: error better
           default: internalThrow(scope, 'TypeError', `'${protoName}' proto func tried to be called on a type without an impl`)
-        }, valtypeBinary),
+        }, allOptUnused && unusedValue ? Blocktype.void : valtypeBinary),
       ];
     }
   }
@@ -1608,7 +1667,9 @@ const generateCall = (scope, decl, _global, _name) => {
   const func = funcs.find(x => x.index === idx);
 
   const userFunc = (funcIndex[name] && !importedFuncs[name] && !builtinFuncs[name] && !internalConstrs[name]) || idx === -1;
-  const paramCount = func && (userFunc ? func.params.length / 2 : func.params.length);
+  const typedParams = userFunc || builtinFuncs[name]?.typedParams;
+  const typedReturn = userFunc || builtinFuncs[name]?.typedReturn;
+  const paramCount = func && (typedParams ? func.params.length / 2 : func.params.length);
 
   let args = decl.arguments;
   if (func && args.length < paramCount) {
@@ -1626,12 +1687,12 @@ const generateCall = (scope, decl, _global, _name) => {
   let out = [];
   for (const arg of args) {
     out = out.concat(generate(scope, arg));
-    if (userFunc) out = out.concat(getNodeType(scope, arg));
+    if (typedParams) out = out.concat(getNodeType(scope, arg));
   }
 
   out.push([ Opcodes.call, idx ]);
 
-  if (!userFunc) {
+  if (!typedReturn) {
     // let type;
     // if (builtinFuncs[name]) type = TYPES[builtinFuncs[name].returnType ?? 'number'];
     // if (internalConstrs[name]) type = internalConstrs[name].type;
@@ -1767,6 +1828,8 @@ const brTable = (input, bc, returns) => {
 };
 
 const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
+  if (!process.argv.includes('-bytestring')) delete bc[TYPES._bytestring];
+
   const known = knownType(scope, type);
   if (known != null) {
     return bc[known] ?? bc.default;
@@ -2157,6 +2220,8 @@ const generateUnary = (scope, decl) => {
         [TYPES.undefined]: makeString(scope, 'undefined', false, '#typeof_result'),
         [TYPES.function]: makeString(scope, 'function', false, '#typeof_result'),
 
+        [TYPES._bytestring]: makeString(scope, 'string', false, '#typeof_result'),
+
         // object and internal types
         default: makeString(scope, 'object', false, '#typeof_result'),
       });
@@ -2338,13 +2403,14 @@ const generateForOf = (scope, decl) => {
   // // todo: we should only do this for strings but we don't know at compile-time :(
   // hack: this is naughty and will break things!
   let newOut = number(0, Valtype.f64), newPointer = -1;
-  if (pages.hasString) {
+  if (pages.hasAnyString) {
     0, [ newOut, newPointer ] = makeArray(scope, {
       rawElements: new Array(1)
     }, isGlobal, leftName, true, 'i16');
   }
 
   // set type for local
+  // todo: optimize away counter and use end pointer
   out.push(...typeSwitch(scope, getNodeType(scope, decl.right), {
     [TYPES._array]: [
       ...setType(scope, leftName, TYPES.number),
@@ -2530,6 +2596,8 @@ const allocPage = (reason, type) => {
 
   if (reason.startsWith('array:')) pages.hasArray = true;
   if (reason.startsWith('string:')) pages.hasString = true;
+  if (reason.startsWith('bytestring:')) pages.hasByteString = true;
+  if (reason.includes('string:')) pages.hasAnyString = true;
 
   const ind = pages.size;
   pages.set(reason, { ind, type });
@@ -2563,7 +2631,8 @@ const StoreOps = {
   f64: Opcodes.f64_store,
 
   // expects i32 input!
-  i16: Opcodes.i32_store16
+  i8: Opcodes.i32_store8,
+  i16: Opcodes.i32_store16,
 };
 
 let data = [];
@@ -2582,6 +2651,15 @@ const compileBytes = (val, itemType, signed = true) => {
   }
 };
 
+const getAllocType = itemType => {
+  switch (itemType) {
+    case 'i8': return 'bytestring';
+    case 'i16': return 'string';
+
+    default: return 'array';
+  }
+};
+
 const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false, itemType = valtype) => {
   const out = [];
 
@@ -2591,7 +2669,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
 
     // todo: can we just have 1 undeclared array? probably not? but this is not really memory efficient
     const uniqueName = name === '$undeclared' ? name + Math.random().toString().slice(2) : name;
-    arrays.set(name, allocPage(`${itemType === 'i16' ? 'string' : 'array'}: ${uniqueName}`, itemType) * pageSize);
+    arrays.set(name, allocPage(`${getAllocType(itemType)}: ${uniqueName}`, itemType) * pageSize);
   }
 
   const pointer = arrays.get(name);
@@ -2637,7 +2715,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     out.push(
       ...number(0, Valtype.i32),
       ...(useRawElements ? number(elements[i], Valtype[valtype]) : generate(scope, elements[i])),
-      [ storeOp, Math.log2(ValtypeSize[itemType]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32 + i * ValtypeSize[itemType]) ]
+      [ storeOp, (Math.log2(ValtypeSize[itemType]) || 1) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32 + i * ValtypeSize[itemType]) ]
     );
   }
 
@@ -2647,15 +2725,29 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   return [ out, pointer ];
 };
 
+const byteStringable = str => {
+  if (!process.argv.includes('-bytestring')) return false;
+
+  for (let i = 0; i < str.length; i++) {
+    if (str.charCodeAt(i) > 0xFF) return false;
+  }
+
+  return true;
+};
+
 const makeString = (scope, str, global = false, name = '$undeclared') => {
   const rawElements = new Array(str.length);
+  let byteStringable = process.argv.includes('-bytestring');
   for (let i = 0; i < str.length; i++) {
-    rawElements[i] = str.charCodeAt(i);
+    const c = str.charCodeAt(i);
+    rawElements[i] = c;
+
+    if (byteStringable && c > 0xFF) byteStringable = false;
   }
 
   return makeArray(scope, {
     rawElements
-  }, global, name, false, 'i16')[0];
+  }, global, name, false, byteStringable ? 'i8' : 'i16')[0];
 };
 
 let arrays = new Map();
@@ -2683,10 +2775,13 @@ export const generateMember = (scope, decl, _global, _name) => {
     ];
   }
 
+  const object = generate(scope, decl.object);
+  const property = generate(scope, decl.property);
+
   // // todo: we should only do this for strings but we don't know at compile-time :(
   // hack: this is naughty and will break things!
   let newOut = number(0, valtypeBinary), newPointer = -1;
-  if (pages.hasString) {
+  if (pages.hasAnyString) {
     0, [ newOut, newPointer ] = makeArray(scope, {
       rawElements: new Array(1)
     }, _global, _name, true, 'i16');
@@ -2695,7 +2790,7 @@ export const generateMember = (scope, decl, _global, _name) => {
   return typeSwitch(scope, getNodeType(scope, decl.object), {
     [TYPES._array]: [
       // get index as valtype
-      ...generate(scope, decl.property),
+      ...property,
 
       // convert to i32 and turn into byte offset by * valtypeSize (4 for i32, 8 for i64/f64)
       Opcodes.i32_to_u,
@@ -2703,7 +2798,7 @@ export const generateMember = (scope, decl, _global, _name) => {
       [ Opcodes.i32_mul ],
 
       ...(aotPointer ? [] : [
-        ...generate(scope, decl.object),
+        ...object,
         Opcodes.i32_to_u,
         [ Opcodes.i32_add ]
       ]),
@@ -2722,14 +2817,14 @@ export const generateMember = (scope, decl, _global, _name) => {
 
       ...number(0, Valtype.i32), // base 0 for store later
 
-      ...generate(scope, decl.property),
-
+      ...property,
       Opcodes.i32_to_u,
+
       ...number(ValtypeSize.i16, Valtype.i32),
       [ Opcodes.i32_mul ],
 
       ...(aotPointer ? [] : [
-        ...generate(scope, decl.object),
+        ...object,
         Opcodes.i32_to_u,
         [ Opcodes.i32_add ]
       ]),
@@ -2746,6 +2841,34 @@ export const generateMember = (scope, decl, _global, _name) => {
       ...number(TYPES.string, Valtype.i32),
       setLastType(scope)
     ],
+    [TYPES._bytestring]: [
+      // setup new/out array
+      ...newOut,
+      [ Opcodes.drop ],
+
+      ...number(0, Valtype.i32), // base 0 for store later
+
+      ...property,
+      Opcodes.i32_to_u,
+
+      ...(aotPointer ? [] : [
+        ...object,
+        Opcodes.i32_to_u,
+        [ Opcodes.i32_add ]
+      ]),
+
+      // load current string ind {arg}
+      [ Opcodes.i32_load8_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
+
+      // store to new string ind 0
+      [ Opcodes.i32_store8, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+      // return new string (page)
+      ...number(newPointer),
+
+      ...number(TYPES._bytestring, Valtype.i32),
+      setLastType(scope)
+    ],
 
     default: [ [ Opcodes.unreachable ] ]
   });
@@ -2827,10 +2950,8 @@ const generateFunc = (scope, decl) => {
   const func = {
     name,
     params: Object.values(innerScope.locals).slice(0, params.length * 2).map(x => x.type),
-    returns: innerScope.returns,
-    locals: innerScope.locals,
-    throws: innerScope.throws,
-    index: currentFuncIndex++
+    index: currentFuncIndex++,
+    ...innerScope
   };
   funcIndex[name] = func.index;
 

package/compiler/decompile.js

@@ -15,7 +15,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
   if (name) out += `${makeSignature(params, returns)} ;; $${name} (${ind})\n`;
 
   const justLocals = Object.values(locals).sort((a, b) => a.idx - b.idx).slice(params.length);
-  if (justLocals.length > 0) out += `  local ${justLocals.map(x => invValtype[x.type]).join(' ')}\n`;
+  if (name && justLocals.length > 0) out += `  local ${justLocals.map(x => invValtype[x.type]).join(' ')}\n`;
 
   let i = -1, lastInst;
   let byte = 0;
@@ -32,7 +32,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       inst = [ [ inst[0], inst[1] ], ...inst.slice(2) ];
     }
 
-    if (inst[0] === Opcodes.end || inst[0] === Opcodes.else || inst[0] === Opcodes.catch_all) depth--;
+    if (depth > 0 && (inst[0] === Opcodes.end || inst[0] === Opcodes.else || inst[0] === Opcodes.catch_all)) depth--;
 
     out += ' '.repeat(Math.max(0, depth * 2));
 
@@ -119,7 +119,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
 export const highlightAsm = asm => asm
   .replace(/(local|global|memory)\.[^\s]*/g, _ => `\x1B[31m${_}\x1B[0m`)
   .replace(/(i(8|16|32|64)x[0-9]+|v128)(\.[^\s]*)?/g, _ => `\x1B[34m${_}\x1B[0m`)
-  .replace(/[^m](i32|i64|f32|f64|drop)(\.[^\s]*)?/g, _ => `${_[0]}\x1B[36m${_.slice(1)}\x1B[0m`)
+  .replace(/(i32|i64|f32|f64|drop)(\.[^\s]*)?/g, _ => `\x1B[36m${_}\x1B[0m`)
   .replace(/(return_call|call|br_if|br|return|rethrow|throw)/g, _ => `\x1B[35m${_}\x1B[0m`)
   .replace(/(block|loop|if|end|else|try|catch_all|catch|delegate)/g, _ => `\x1B[95m${_}\x1B[0m`)
   .replace(/unreachable/g, _ => `\x1B[91m${_}\x1B[0m`)

package/compiler/opt.js

@@ -192,6 +192,7 @@ export default (funcs, globals, pages, tags) => {
           let missing = false;
           if (type === 'Array') missing = !pages.hasArray;
           if (type === 'String') missing = !pages.hasString;
+          if (type === 'ByteString') missing = !pages.hasByteString;
 
           if (missing) {
             let j = i, depth = 0;

package/compiler/prototype.js

@@ -16,7 +16,8 @@ const TYPES = {
 
   // these are not "typeof" types but tracked internally
   _array: 0x10,
-  _regexp: 0x11
+  _regexp: 0x11,
+  _bytestring: 0x12
 };
 
 // todo: turn these into built-ins once arrays and these become less hacky
@@ -71,7 +72,7 @@ export const PrototypeFuncs = function() {
     ],
 
     // todo: only for 1 argument
-    push: (pointer, length, wNewMember) => [
+    push: (pointer, length, wNewMember, _1, _2, _3, unusedValue) => [
       // get memory offset of array at last index (length)
       ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
@@ -92,22 +93,28 @@ export const PrototypeFuncs = function() {
         ...number(1, Valtype.i32),
         [ Opcodes.i32_add ],
 
-        ...length.setCachedI32(),
-        ...length.getCachedI32(),
+        ...(unusedValue() ? [] : [
+          ...length.setCachedI32(),
+          ...length.getCachedI32(),
+        ])
       ]),
 
-      ...length.getCachedI32(),
-      Opcodes.i32_from_u
+      ...(unusedValue() ? [] : [
+        ...length.getCachedI32(),
+        Opcodes.i32_from_u
+      ])
 
       // ...length.get()
     ],
 
-    pop: (pointer, length) => [
+    pop: (pointer, length, _1, _2, _3, _4, unusedValue) => [
       // if length == 0, noop
       ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
-      ...number(UNDEFINED),
+      ...(unusedValue() ? [] : [
+        ...number(UNDEFINED),
+      ]),
       [ Opcodes.br, 1 ],
       [ Opcodes.end ],
 
@@ -119,19 +126,23 @@ export const PrototypeFuncs = function() {
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ],
 
-        ...length.setCachedI32(),
-        ...length.getCachedI32(),
+        ...(unusedValue() ? [] : [
+          ...length.setCachedI32(),
+          ...length.getCachedI32(),
+        ])
       ]),
 
       // load last element
-      ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
-      [ Opcodes.i32_mul ],
+      ...(unusedValue() ? [] : [
+        ...length.getCachedI32(),
+        ...number(ValtypeSize[valtype], Valtype.i32),
+        [ Opcodes.i32_mul ],
 
-      ...pointer,
-      [ Opcodes.i32_add ],
+        ...pointer,
+        [ Opcodes.i32_add ],
 
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+        [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+      ])
     ],
 
     shift: (pointer, length) => [
@@ -472,8 +483,152 @@ export const PrototypeFuncs = function() {
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
   this[TYPES.string].charCodeAt.local = Valtype.i32;
+  this[TYPES.string].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
   this[TYPES.string].isWellFormed.local = Valtype.i32;
   this[TYPES.string].isWellFormed.local2 = Valtype.i32;
   this[TYPES.string].isWellFormed.returnType = TYPES.boolean;
+
+  if (process.argv.includes('-bytestring')) {
+    this[TYPES._bytestring] = {
+      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
+
+          ...wIndex,
+          Opcodes.i32_to_u,
+          [ 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.getCachedI32(),
+          [ 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.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
+          [ Opcodes.i32_or ],
+
+          [ Opcodes.if, Blocktype.void ],
+          ...number(UNDEFINED),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
+
+          [ Opcodes.local_get, iTmp ],
+
+          ...pointer,
+          [ Opcodes.i32_add ],
+
+          // load current string ind {arg}
+          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+          // store to new string ind 0
+          [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+          // return new string (pointer)
+          ...number(newPointer)
+        ];
+      },
+
+      // todo: out of bounds properly
+      charAt: (pointer, length, wIndex, _1, _2, 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,
+
+          ...pointer,
+          [ Opcodes.i32_add ],
+
+          // load current string ind {arg}
+          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+          // store to new string ind 0
+          [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+          // return new string (page)
+          ...number(newPointer)
+        ];
+      },
+
+      charCodeAt: (pointer, length, wIndex, iTmp) => {
+        return [
+          ...wIndex,
+          Opcodes.i32_to,
+
+          ...(zeroChecks.charcodeat ? [] : [
+            [ 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.getCachedI32(),
+            [ Opcodes.i32_ge_s ],
+
+            ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+            [ Opcodes.if, Blocktype.void ],
+            ...number(NaN),
+            [ Opcodes.br, 1 ],
+            [ Opcodes.end ],
+
+            [ Opcodes.local_get, iTmp ],
+          ]),
+
+          ...pointer,
+          [ Opcodes.i32_add ],
+
+          // load current string ind {arg}
+          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+          Opcodes.i32_from_u
+        ];
+      },
+
+      isWellFormed: () => {
+        return [
+          // we know it must be true as it is a bytestring lol
+          ...number(1)
+        ]
+      }
+    };
+
+    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;
+  }
 };

package/compiler/wasmSpec.js

@@ -57,9 +57,12 @@ export const Opcodes = {
   i64_load: 0x29,
   f64_load: 0x2b,
 
+  i32_load8_s: 0x2c,
+  i32_load8_u: 0x2d,
   i32_load16_s: 0x2e,
   i32_load16_u: 0x2f,
 
+  i32_store8: 0x3a,
   i32_store16: 0x3b,
 
   i32_store: 0x36,

package/compiler/wrap.js

@@ -1,6 +1,7 @@
 import compile from './index.js';
 import decompile from './decompile.js';
-import fs from 'node:fs';
+import { encodeVector, encodeLocal } from './encoding.js';
+// import fs from 'node:fs';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
@@ -18,7 +19,8 @@ const TYPES = {
 
   // internal
   [internalTypeBase]: '_array',
-  [internalTypeBase + 1]: '_regexp'
+  [internalTypeBase + 1]: '_regexp',
+  [internalTypeBase + 2]: '_bytestring'
 };
 
 export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
@@ -29,20 +31,104 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   if (source.includes('export function')) flags.push('module');
 
-  fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
   const t2 = performance.now();
-  const { instance } = await WebAssembly.instantiate(wasm, {
-    '': {
-      p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
-      c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
-      t: _ => performance.now(),
-      ...customImports
+
+  let instance;
+  try {
+    0, { instance } = await WebAssembly.instantiate(wasm, {
+      '': {
+        p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
+        c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
+        t: _ => performance.now(),
+        ...customImports
+      }
+    });
+  } catch (e) {
+    // only backtrace for runner, not test262/etc
+    if (!process.argv[1].includes('/runner')) throw e;
+
+    const funcInd = parseInt(e.message.match(/function #([0-9]+) /)[1]);
+    const blobOffset = parseInt(e.message.split('@')[1]);
+
+    // convert blob offset -> function wasm offset.
+    // this is not good code and is somewhat duplicated
+    // I just want it to work for debugging, I don't care about perf/yes
+
+    const func = funcs.find(x => x.index === funcInd);
+    const locals = Object.values(func.locals).sort((a, b) => a.idx - b.idx).slice(func.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));
+
+    const toFind = encodeVector(localDecl).concat(func.wasm.flat().filter(x => x != null && x <= 0xff).slice(0, 40));
+
+    let i = 0;
+    for (; i < wasm.length; i++) {
+      let mismatch = false;
+      for (let j = 0; j < toFind.length; j++) {
+        if (wasm[i + j] !== toFind[j]) {
+          mismatch = true;
+          break;
+        }
+      }
+
+      if (!mismatch) break;
+    }
+
+    if (i === wasm.length) throw e;
+
+    const offset = (blobOffset - i) + encodeVector(localDecl).length;
+
+    let cumLen = 0;
+    i = 0;
+    for (; i < func.wasm.length; i++) {
+      cumLen += func.wasm[i].filter(x => x != null && x <= 0xff).length;
+      if (cumLen === offset) break;
+    }
+
+    if (cumLen !== offset) throw e;
+
+    i -= 1;
+
+    console.log(`\x1B[35m\x1B[1mporffor backtrace\u001b[0m`);
+
+    console.log('\x1B[4m' + func.name + '\x1B[0m');
+
+    const surrounding = 6;
+
+    const decomp = decompile(func.wasm.slice(i - surrounding, i + surrounding + 1), '', 0, func.locals, func.params, func.returns, funcs, globals, exceptions).slice(0, -1).split('\n');
+
+    const noAnsi = s => s.replace(/\u001b\[[0-9]+m/g, '');
+    let longest = 0;
+    for (let j = 0; j < decomp.length; j++) {
+      longest = Math.max(longest, noAnsi(decomp[j]).length);
     }
-  });
+
+    const middle = Math.floor(decomp.length / 2);
+    decomp[middle] = `\x1B[47m\x1B[30m${noAnsi(decomp[middle])}${'\u00a0'.repeat(longest - noAnsi(decomp[middle]).length)}\x1B[0m`;
+
+    console.log('\x1B[90m...\x1B[0m');
+    console.log(decomp.join('\n'));
+    console.log('\x1B[90m...\x1B[0m\n');
+
+    throw e;
+  }
 
   times.push(performance.now() - t2);
   if (flags.includes('info')) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
@@ -95,6 +181,13 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
             return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
           }
 
+          case '_bytestring': {
+            const pointer = ret;
+            const length = new Int32Array(memory.buffer, pointer, 1);
+
+            return Array.from(new Uint8Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
+          }
+
           case 'function': {
             // wasm func index, including all imports
             const func = funcs.find(x => (x.originalIndex ?? x.index) === ret);

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.2.0-e562242",
+  "version": "0.2.0-eeb45f8",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/node_trace.1.log

@@ -1 +0,0 @@
-{"traceEvents":[{"pid":13264,"tid":15096,"ts":95423117674,"tts":0,"ph":"X","cat":"v8","name":"V8.DeserializeIsolate","dur":4531,"tdur":0,"args":{}},{"pid":13264,"tid":15096,"ts":95423122578,"tts":0,"ph":"X","cat":"v8","name":"V8.DeserializeContext","dur":3271,"tdur":0,"args":{}},{"pid":13264,"tid":15096,"ts":95423130539,"tts":0,"ph":"X","cat":"v8","name":"V8.DeserializeContext","dur":346,"tdur":0,"args":{}},{"pid":13264,"tid":15096,"ts":95423152512,"tts":0,"ph":"B","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":4996680,"type":"allocation failure"}},{"pid":13264,"tid":15096,"ts":95423152519,"tts":0,"ph":"X","cat":"v8","name":"V8.GCScavenger","dur":431,"tdur":0,"args":{}},{"pid":13264,"tid":15096,"ts":95423152969,"tts":0,"ph":"E","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":4389296}},{"pid":13264,"tid":15096,"ts":95423160029,"tts":0,"ph":"B","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":4924936,"type":"task"}},{"pid":13264,"tid":15096,"ts":95423160032,"tts":0,"ph":"X","cat":"v8","name":"V8.GCScavenger","dur":324,"tdur":0,"args":{}},{"pid":13264,"tid":15096,"ts":95423160367,"tts":0,"ph":"E","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":4440256}},{"pid":13264,"tid":15096,"ts":95423175256,"tts":67346,"ph":"B","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":6472768,"type":"allocation failure"}},{"pid":13264,"tid":15096,"ts":95423175267,"tts":67356,"ph":"X","cat":"v8","name":"V8.GCScavenger","dur":299,"tdur":300,"args":{}},{"pid":13264,"tid":15096,"ts":95423175578,"tts":67667,"ph":"E","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":5881080}},{"pid":13264,"tid":15096,"ts":95423188220,"tts":80241,"ph":"B","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":6928320,"type":"allocation failure"}},{"pid":13264,"tid":15096,"ts":95423188222,"tts":80243,"ph":"X","cat":"v8","name":"V8.GCScavenger","dur":363,"tdur":362,"args":{}},{"pid":13264,"tid":15096,"ts":95423188596,"tts":80616,"ph":"E","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":6372328}},{"pid":13264,"tid":15096,"ts":95423191843,"tts":83862,"ph":"B","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":8430312,"type":"allocation failure"}},{"pid":13264,"tid":15096,"ts":95423191845,"tts":83864,"ph":"X","cat":"v8","name":"V8.GCScavenger","dur":258,"tdur":239,"args":{}},{"pid":13264,"tid":15096,"ts":95423192113,"tts":84113,"ph":"E","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":6741768}},{"pid":13264,"tid":15096,"ts":95423199261,"tts":91198,"ph":"B","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":8882104,"type":"allocation failure"}},{"pid":13264,"tid":15096,"ts":95423199264,"tts":91200,"ph":"X","cat":"v8","name":"V8.GCScavenger","dur":256,"tdur":220,"args":{}},{"pid":13264,"tid":15096,"ts":95423199530,"tts":91430,"ph":"E","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":6991296}},{"pid":13264,"tid":15096,"ts":95423203033,"tts":94931,"ph":"B","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":9582528,"type":"allocation failure"}},{"pid":13264,"tid":15096,"ts":95423203035,"tts":94933,"ph":"X","cat":"v8","name":"V8.GCScavenger","dur":147,"tdur":128,"args":{}},{"pid":13264,"tid":15096,"ts":95423203191,"tts":95069,"ph":"E","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":7206184}},{"pid":13264,"tid":15096,"ts":95423207062,"tts":98940,"ph":"B","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":10032360,"type":"allocation failure"}},{"pid":13264,"tid":15096,"ts":95423207063,"tts":98941,"ph":"X","cat":"v8","name":"V8.GCScavenger","dur":98,"tdur":98,"args":{}},{"pid":13264,"tid":15096,"ts":95423207169,"tts":99046,"ph":"E","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":7617064}},{"pid":13264,"tid":15096,"ts":95423210148,"tts":102008,"ph":"B","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":10442184,"type":"allocation failure"}},{"pid":13264,"tid":15096,"ts":95423210149,"tts":102009,"ph":"X","cat":"v8","name":"V8.GCScavenger","dur":83,"tdur":82,"args":{}},{"pid":13264,"tid":15096,"ts":95423210241,"tts":102101,"ph":"E","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":7743728}},{"pid":13264,"tid":15096,"ts":95598120854,"tts":172740055,"ph":"B","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":10650144,"type":"allocation failure"}},{"pid":13264,"tid":15096,"ts":95598120861,"tts":172740060,"ph":"X","cat":"v8","name":"V8.GCScavenger","dur":188,"tdur":189,"args":{}},{"pid":13264,"tid":15096,"ts":95598121065,"tts":172740264,"ph":"E","cat":"devtools.timeline,v8","name":"MinorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":8016624}},{"pid":13264,"tid":15096,"ts":95707243189,"tts":280108308,"ph":"X","cat":"v8","name":"V8.DeoptimizeCode","dur":20,"tdur":19,"args":{}},{"pid":13264,"tid":15096,"ts":95707243201,"tts":280108319,"ph":"X","cat":"v8","name":"V8.DeoptimizeCode","dur":8,"tdur":8,"args":{}},{"pid":13264,"tid":15096,"ts":95707244259,"tts":280109369,"ph":"X","cat":"v8","name":"V8.DeoptimizeCode","dur":10,"tdur":8,"args":{}},{"pid":13264,"tid":15096,"ts":95707244265,"tts":280109374,"ph":"X","cat":"v8","name":"V8.DeoptimizeCode","dur":3,"tdur":3,"args":{}},{"pid":13264,"tid":15096,"ts":95707244376,"tts":280109452,"ph":"X","cat":"v8","name":"V8.DeoptimizeCode","dur":9,"tdur":8,"args":{}},{"pid":13264,"tid":15096,"ts":95707244381,"tts":280109456,"ph":"X","cat":"v8","name":"V8.DeoptimizeCode","dur":3,"tdur":4,"args":{}},{"pid":13264,"tid":15096,"ts":95707245192,"tts":280110267,"ph":"X","cat":"v8","name":"V8.GCIncrementalMarkingStart","dur":214,"tdur":214,"args":{"epoch":11,"reason":"memory reducer"}},{"pid":13264,"tid":15096,"ts":95707245464,"tts":280110540,"ph":"X","cat":"v8","name":"V8.GCIncrementalMarking","dur":7,"tdur":6,"args":{"epoch":11}},{"pid":13264,"tid":15096,"ts":95707245559,"tts":280110634,"ph":"B","cat":"devtools.timeline,v8","name":"MajorGC","dur":0,"tdur":0,"args":{"usedHeapSizeBefore":8366408,"type":"external finalize"}},{"pid":13264,"tid":15096,"ts":95707245561,"tts":280110635,"ph":"X","cat":"v8","name":"V8.GCFinalizeMCReduceMemory","dur":1914,"tdur":1617,"args":{}},{"pid":13264,"tid":15096,"ts":95707247497,"tts":280112273,"ph":"E","cat":"devtools.timeline,v8","name":"MajorGC","dur":0,"tdur":0,"args":{"usedHeapSizeAfter":6173808}},{"pid":13264,"tid":15096,"ts":95423116966,"tts":0,"ph":"M","cat":"__metadata","name":"process_name","dur":0,"tdur":0,"args":{"name":"Command Prompt - node  --trace-event-categories v8 runner/index.js bench/bf.js"}},{"pid":13264,"tid":15096,"ts":95423116967,"tts":0,"ph":"M","cat":"__metadata","name":"version","dur":0,"tdur":0,"args":{"node":"21.6.0"}},{"pid":13264,"tid":15096,"ts":95423116968,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"JavaScriptMainThread"}},{"pid":13264,"tid":15096,"ts":95423116978,"tts":0,"ph":"M","cat":"__metadata","name":"node","dur":0,"tdur":0,"args":{"process":{"versions":{"node":"21.6.0","v8":"11.8.172.17-node.19","uv":"1.47.0","zlib":"1.3.0.1-motley-40e35a7","brotli":"1.1.0","ares":"1.20.1","modules":"120","nghttp2":"1.58.0","napi":"9","llhttp":"9.1.3","uvwasi":"0.0.19","acorn":"8.11.3","simdjson":"3.6.3","simdutf":"4.0.8","ada":"2.7.4","undici":"5.28.2","cjs_module_lexer":"1.2.2","base64":"0.5.1","openssl":"3.0.12+quic","cldr":"44.0","icu":"74.1","tz":"2023c","unicode":"15.1","ngtcp2":"0.8.1","nghttp3":"0.7.0"},"arch":"x64","platform":"win32","release":{"name":"node"}}}},{"pid":13264,"tid":9152,"ts":95423117058,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"WorkerThreadsTaskRunner::DelayedTaskScheduler"}},{"pid":13264,"tid":12304,"ts":95423117145,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"PlatformWorkerThread"}},{"pid":13264,"tid":11816,"ts":95423117184,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"PlatformWorkerThread"}},{"pid":13264,"tid":5044,"ts":95423117206,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"PlatformWorkerThread"}},{"pid":13264,"tid":4032,"ts":95423117236,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"PlatformWorkerThread"}},{"pid":13264,"tid":15096,"ts":95423116966,"tts":0,"ph":"M","cat":"__metadata","name":"process_name","dur":0,"tdur":0,"args":{"name":"Command Prompt - node  --trace-event-categories v8 runner/index.js bench/bf.js"}},{"pid":13264,"tid":15096,"ts":95423116967,"tts":0,"ph":"M","cat":"__metadata","name":"version","dur":0,"tdur":0,"args":{"node":"21.6.0"}},{"pid":13264,"tid":15096,"ts":95423116968,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"JavaScriptMainThread"}},{"pid":13264,"tid":15096,"ts":95423116978,"tts":0,"ph":"M","cat":"__metadata","name":"node","dur":0,"tdur":0,"args":{"process":{"versions":{"node":"21.6.0","v8":"11.8.172.17-node.19","uv":"1.47.0","zlib":"1.3.0.1-motley-40e35a7","brotli":"1.1.0","ares":"1.20.1","modules":"120","nghttp2":"1.58.0","napi":"9","llhttp":"9.1.3","uvwasi":"0.0.19","acorn":"8.11.3","simdjson":"3.6.3","simdutf":"4.0.8","ada":"2.7.4","undici":"5.28.2","cjs_module_lexer":"1.2.2","base64":"0.5.1","openssl":"3.0.12+quic","cldr":"44.0","icu":"74.1","tz":"2023c","unicode":"15.1","ngtcp2":"0.8.1","nghttp3":"0.7.0"},"arch":"x64","platform":"win32","release":{"name":"node"}}}},{"pid":13264,"tid":9152,"ts":95423117058,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"WorkerThreadsTaskRunner::DelayedTaskScheduler"}},{"pid":13264,"tid":12304,"ts":95423117145,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"PlatformWorkerThread"}},{"pid":13264,"tid":11816,"ts":95423117184,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"PlatformWorkerThread"}},{"pid":13264,"tid":5044,"ts":95423117206,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"PlatformWorkerThread"}},{"pid":13264,"tid":4032,"ts":95423117236,"tts":0,"ph":"M","cat":"__metadata","name":"thread_name","dur":0,"tdur":0,"args":{"name":"PlatformWorkerThread"}}]}