porffor 0.0.0-05f898f → 0.0.0-1b0a5c6

package/README.md

@@ -1,6 +1,6 @@
 # porffor
 a basic experimental wip *aot* optimizing js -> wasm/c engine/compiler/runtime in js. not serious/intended for (real) use. (this is a straight forward, honest readme)<br>
-age: ~1 month
+age: ~2 months
 
 ## design
 porffor is a very unique js engine, due a very different approach. it is seriously limited, but what it can do, it does pretty well. key differences:
@@ -83,6 +83,8 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
 - truthy/falsy (eg `!'' == true`)
 - string comparison (eg `'a' == 'a'`, `'a' != 'b'`)
 - nullish coalescing operator (`??`)
+- `for...of` (arrays and strings)
+- array member setting (`arr[0] = 2`, `arr[0] += 2`, etc)
 
 ### built-ins
 
@@ -110,11 +112,9 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
 no particular order and no guarentees, just what could happen soon™
 
 - arrays
-  - member setting (`arr[0] = 2`)
   - more of `Array` prototype
   - arrays/strings inside arrays
   - destructuring
-  - for .. of
 - strings
   - member setting
 - objects
@@ -135,7 +135,7 @@ no particular order and no guarentees, just what could happen soon™
   - use data segments for initing arrays
 
 ## porfformance
-*for the things it supports*, porffor is blazingly faster compared to most interpreters, and engines running without JIT. for those with JIT, it is not that much slower like a traditional interpreter would be.
+*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.
 
 ![Screenshot of comparison chart](https://github.com/CanadaHonk/porffor/assets/19228318/76c75264-cc68-4be1-8891-c06dc389d97a)
 

package/compiler/builtins.js

@@ -26,6 +26,12 @@ export const importedFuncs = [
     import: 't',
     params: 0,
     returns: 1
+  },
+  {
+    name: 'printStr',
+    import: 's',
+    params: 1,
+    returns: 0
   }
 ];
 

package/compiler/codeGen.js

@@ -109,8 +109,8 @@ const generate = (scope, decl, global = false, name = undefined) => {
     case 'WhileStatement':
       return generateWhile(scope, decl);
 
-    /* case 'ForOfStatement':
-      return generateForOf(scope, decl); */
+    case 'ForOfStatement':
+      return generateForOf(scope, decl);
 
     case 'BreakStatement':
       return generateBreak(scope, decl);
@@ -152,44 +152,65 @@ const generate = (scope, decl, global = false, name = undefined) => {
 
       return [];
 
-    case 'TaggedTemplateExpression':
-      // hack for inline asm
-      if (decl.tag.name !== 'asm') return todo('tagged template expressions not implemented');
+    case 'TaggedTemplateExpression': {
+      const funcs = {
+        asm: str => {
+          let out = [];
 
-      const str = decl.quasi.quasis[0].value.raw;
-      let out = [];
+          for (const line of str.split('\n')) {
+            const asm = line.trim().split(';;')[0].split(' ');
+            if (asm[0] === '') continue; // blank
 
-      for (const line of str.split('\n')) {
-        const asm = line.trim().split(';;')[0].split(' ');
-        if (asm[0] === '') continue; // blank
+            if (asm[0] === 'local') {
+              const [ name, idx, type ] = asm.slice(1);
+              scope.locals[name] = { idx: parseInt(idx), type: Valtype[type] };
+              continue;
+            }
 
-        if (asm[0] === 'local') {
-          const [ name, idx, type ] = asm.slice(1);
-          scope.locals[name] = { idx: parseInt(idx), type: Valtype[type] };
-          continue;
-        }
+            if (asm[0] === 'returns') {
+              scope.returns = asm.slice(1).map(x => Valtype[x]);
+              continue;
+            }
 
-        if (asm[0] === 'returns') {
-          scope.returns = asm.slice(1).map(x => Valtype[x]);
-          continue;
-        }
+            if (asm[0] === 'memory') {
+              allocPage('asm instrinsic');
+              // todo: add to store/load offset insts
+              continue;
+            }
 
-        if (asm[0] === 'memory') {
-          allocPage('asm instrinsic');
-          // todo: add to store/load offset insts
-          continue;
-        }
+            let inst = Opcodes[asm[0].replace('.', '_')];
+            if (!inst) throw new Error(`inline asm: inst ${asm[0]} not found`);
+
+            if (!Array.isArray(inst)) inst = [ inst ];
+            const immediates = asm.slice(1).map(x => parseInt(x));
+
+            out.push([ ...inst, ...immediates ]);
+          }
 
-        let inst = Opcodes[asm[0].replace('.', '_')];
-        if (!inst) throw new Error(`inline asm: inst ${asm[0]} not found`);
+          return out;
+        },
 
-        if (!Array.isArray(inst)) inst = [ inst ];
-        const immediates = asm.slice(1).map(x => parseInt(x));
+        __internal_print_type: str => {
+          const type = getType(scope, str) - TYPES.number;
 
-        out.push([ ...inst, ...immediates ]);
+          return [
+            ...number(type),
+            [ Opcodes.call, importedFuncs.print ],
+
+            // newline
+            ...number(10),
+            [ Opcodes.call, importedFuncs.printChar ]
+          ];
+        }
       }
 
-      return out;
+      const name = decl.tag.name;
+      // hack for inline asm
+      if (!funcs[name]) return todo('tagged template expressions not implemented');
+
+      const str = decl.quasi.quasis[0].value.raw;
+      return funcs[name](str);
+    }
 
     default:
       return todo(`no generation for ${decl.type}!`);
@@ -665,29 +686,44 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 
   if (codeLog && (!leftType || !rightType)) log('codegen', 'untracked type in op', op, _name, '\n' + new Error().stack.split('\n').slice(1).join('\n'));
 
-  // if strict (in)equal and known types mismatch, return false (===)/true (!==)
-  if ((op === '===' || op === '!==') && leftType && rightType && leftType !== rightType) {
+  const eqOp = ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op);
+
+  if (leftType && rightType && (
+    // if strict (in)equal and known types mismatch, return false (===)/true (!==)
+    ((op === '===' || op === '!==') && leftType !== rightType) ||
+
+    // if equality op and an operand is undefined, return false
+    (eqOp && leftType === TYPES.undefined ^ rightType === TYPES.undefined)
+  )) {
+    // undefined == null
+    if (((leftType === TYPES.undefined && rightType === TYPES.object) || (leftType === TYPES.object && rightType === TYPES.undefined)) && (op === '==' || op === '!=')) return [
+      ...(leftType === TYPES.object ? left : right),
+      ...Opcodes.eqz,
+      ...(op === '!=' ? [ [ Opcodes.i32_eqz ] ] : [])
+    ];
+
     return [
       ...left,
-      ...right,
-
-      // drop values
       [ Opcodes.drop ],
+
+      ...right,
       [ Opcodes.drop ],
 
-      // return false (===)/true (!==)
-      ...number(op === '===' ? 0 : 1, Valtype.i32)
+      // return true (!=/!==) or false (else)
+      ...number(op === '!=' || op === '!==' ? 1 : 0, Valtype.i32)
     ];
   }
 
+  // todo: niche null hell with 0
+
   if (leftType === TYPES.string || rightType === TYPES.string) {
     if (op === '+') {
       // string concat (a + b)
       return concatStrings(scope, left, right, _global, _name, assign);
     }
 
-    // any other math op, NaN
-    if (!['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op)) return number(NaN);
+    // not an equality op, NaN
+    if (!eqOp) return number(NaN);
 
     // else leave bool ops
     // todo: convert string to number if string and number/bool
@@ -732,17 +768,11 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
   ];
 };
 
-let binaryExpDepth = 0;
 const generateBinaryExp = (scope, decl, _global, _name) => {
-  binaryExpDepth++;
-
-  const out = [
-    ...performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name)
-  ];
+  const out = performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name);
 
   if (valtype !== 'i32' && ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(decl.operator)) out.push(Opcodes.i32_from_u);
 
-  binaryExpDepth--;
   return out;
 };
 
@@ -999,6 +1029,8 @@ const countLeftover = wasm => {
           } else count--;
           if (func) count += func.returns.length;
         } else count--;
+
+    // console.log(count, decompile([ inst ]).slice(0, -1));
   }
 
   return count;
@@ -1185,24 +1217,34 @@ const generateCall = (scope, decl, _global, _name) => {
     // use local for cached i32 length as commonly used
     let lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
 
+    let lengthI32CacheUsed = false;
+
+    const protoOut = protoFunc(pointer, {
+      getCachedI32: () => {
+        lengthI32CacheUsed = true;
+        return [ [ Opcodes.local_get, lengthLocal ] ]
+      },
+      setCachedI32: () => [ [ Opcodes.local_set, lengthLocal ] ],
+      get: () => arrayUtil.getLength(pointer),
+      getI32: () => arrayUtil.getLengthI32(pointer),
+      set: value => arrayUtil.setLength(pointer, value),
+      setI32: value => arrayUtil.setLengthI32(pointer, value)
+    }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, (length, itemType) => {
+      return makeArray(scope, {
+        rawElements: new Array(length)
+      }, _global, _name, true, itemType);
+    });
+
     return [
       ...out,
 
-      ...arrayUtil.getLengthI32(pointer),
-      [ Opcodes.local_set, lengthLocal ],
+      ...(!lengthI32CacheUsed ? [] : [
+        ...arrayUtil.getLengthI32(pointer),
+        [ Opcodes.local_set, lengthLocal ],
+      ]),
 
       [ Opcodes.block, valtypeBinary ],
-      ...protoFunc(pointer, {
-        cachedI32: [ [ Opcodes.local_get, lengthLocal ] ],
-        get: arrayUtil.getLength(pointer),
-        getI32: arrayUtil.getLengthI32(pointer),
-        set: value => arrayUtil.setLength(pointer, value),
-        setI32: value => arrayUtil.setLengthI32(pointer, value)
-      }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, (length, itemType) => {
-        return makeArray(scope, {
-          rawElements: new Array(length)
-        }, _global, _name, true, itemType);
-      }),
+      ...protoOut,
       [ Opcodes.end ]
     ];
   }
@@ -1262,7 +1304,7 @@ const generateCall = (scope, decl, _global, _name) => {
   if (func && func.throws) scope.throws = true;
 
   for (const arg of args) {
-    out.push(...generate(scope, arg));
+    out = out.concat(generate(scope, arg));
   }
 
   out.push([ Opcodes.call, idx ]);
@@ -1402,13 +1444,60 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
+  const op = decl.operator.slice(0, -1) || '=';
+
+  // arr[i] | str[i]
+  if (decl.left.type === 'MemberExpression' && decl.left.computed) {
+    const name = decl.left.object.name;
+    const pointer = arrays.get(name);
+
+    const aotPointer = pointer != null;
+
+    const newValueTmp = localTmp(scope, '__member_setter_val_tmp');
+    const pointerTmp = op === '=' ? -1 : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
+
+    const parentType = getNodeType(scope, decl.left.object);
+
+    return [
+      ...(aotPointer ? [] : [
+        ...generate(scope, decl.left.object),
+        Opcodes.i32_to_u
+      ]),
+
+      // get index as valtype
+      ...generate(scope, decl.left.property),
+
+      // convert to i32 and turn into byte offset by * valtypeSize (4 for i32, 8 for i64/f64)
+      Opcodes.i32_to_u,
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_mul ],
+      ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
+      ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+      ...(op === '=' ? generate(scope, decl.right, false, name) : performOp(scope, op, [
+        [ Opcodes.local_get, pointerTmp ],
+        [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+      ], generate(scope, decl.right), parentType === TYPES._array ? TYPES.number : TYPES.string, getNodeType(scope, decl.right), false, name, true)),
+      [ Opcodes.local_tee, newValueTmp ],
+
+      ...(parentType === TYPES._array ? [
+        [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+      ] : [
+        Opcodes.i32_to_u,
+        [ StoreOps.i16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+      ]),
+
+      [ Opcodes.local_get, newValueTmp ]
+    ];
+  }
+
   const [ local, isGlobal ] = lookupName(scope, name);
 
   if (local === undefined) {
     // todo: this should be a devtools/repl/??? only thing
 
     // only allow = for this
-    if (decl.operator !== '=') return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`);
+    if (op !== '=') return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`);
 
     if (builtinVars[name]) {
       // just return rhs (eg `NaN = 2`)
@@ -1422,8 +1511,10 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
-  if (decl.operator === '=') {
-    typeStates[name] = getNodeType(scope, decl.right);
+  typeStates[name] = getNodeType(scope, decl.right);
+
+  if (op === '=') {
+    // typeStates[name] = getNodeType(scope, decl.right);
 
     return [
       ...generate(scope, decl.right, isGlobal, name),
@@ -1432,7 +1523,6 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
-  const op = decl.operator.slice(0, -1);
   if (op === '||' || op === '&&' || op === '??') {
     // todo: is this needed?
     // for logical assignment ops, it is not left @= right ~= left = left @ right
@@ -1567,7 +1657,7 @@ const generateUpdate = (scope, decl) => {
 };
 
 const generateIf = (scope, decl) => {
-  const out = truthy(scope, generate(scope, decl.test), decl.test);
+  const out = truthy(scope, generate(scope, decl.test), getNodeType(scope, decl.test));
 
   out.push(Opcodes.i32_to, [ Opcodes.if, Blocktype.void ]);
   depth.push('if');
@@ -1660,18 +1750,106 @@ const generateWhile = (scope, decl) => {
 const generateForOf = (scope, decl) => {
   const out = [];
 
+  const rightType = getNodeType(scope, decl.right);
+  const valtypeSize = rightType === TYPES._array ? ValtypeSize[valtype] : ValtypeSize.i16; // presume array (:()
+
+  // todo: for of inside for of might fuck up?
+  const pointer = localTmp(scope, 'forof_base_pointer', Valtype.i32);
+  const length = localTmp(scope, 'forof_length', Valtype.i32);
+  const counter = localTmp(scope, 'forof_counter', Valtype.i32);
+
+  out.push(
+    // set pointer as right
+    ...generate(scope, decl.right),
+    Opcodes.i32_to_u,
+    [ Opcodes.local_set, pointer ],
+
+    // get length
+    [ Opcodes.local_get, pointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+    [ Opcodes.local_set, length ]
+  );
+
   out.push([ Opcodes.loop, Blocktype.void ]);
-  depth.push('while');
+  depth.push('forof');
 
-  out.push(...generate(scope, decl.test));
-  out.push(Opcodes.i32_to, [ Opcodes.if, Blocktype.void ]);
-  depth.push('if');
+  // setup local for left
+  generate(scope, decl.left);
 
-  out.push(...generate(scope, decl.body));
+  const leftName = decl.left.declarations[0].id.name;
 
-  out.push([ Opcodes.br, 1 ]);
-  out.push([ Opcodes.end ], [ Opcodes.end ]);
-  depth.pop(); depth.pop();
+  // set type for local
+  typeStates[leftName] = rightType === TYPES._array ? TYPES.number : TYPES.string;
+
+  const [ local, isGlobal ] = lookupName(scope, leftName);
+
+  if (rightType === TYPES._array) { // array
+    out.push(
+      [ Opcodes.local_get, pointer ],
+      [ Opcodes.load, Math.log2(valtypeSize) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+    );
+  } else { // string
+    const [ newOut, newPointer ] = makeArray(scope, {
+      rawElements: new Array(1)
+    }, isGlobal, leftName, true, 'i16');
+
+    out.push(
+      // setup new/out array
+      ...newOut,
+      [ Opcodes.drop ],
+
+      ...number(0, Valtype.i32), // base 0 for store after
+
+      // load current string ind {arg}
+      [ Opcodes.local_get, pointer ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      // store to new string ind 0
+      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+      // return new string (page)
+      ...number(newPointer)
+    );
+  }
+
+  // set left value
+  out.push([ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ]);
+
+  out.push(
+    [ Opcodes.block, Blocktype.void ],
+    [ Opcodes.block, Blocktype.void ]
+  );
+  depth.push('block');
+  depth.push('block');
+
+  out.push(
+    ...generate(scope, decl.body),
+    [ Opcodes.end ]
+  );
+  depth.pop();
+
+  out.push(
+    // increment iter pointer by valtype size
+    [ Opcodes.local_get, pointer ],
+    ...number(valtypeSize, Valtype.i32),
+    [ Opcodes.i32_add ],
+    [ Opcodes.local_set, pointer ],
+
+    // increment counter by 1
+    [ Opcodes.local_get, counter ],
+    ...number(1, Valtype.i32),
+    [ Opcodes.i32_add ],
+    [ Opcodes.local_tee, counter ],
+
+    // loop if counter != length
+    [ Opcodes.local_get, length ],
+    [ Opcodes.i32_ne ],
+    [ Opcodes.br_if, 1 ],
+
+    [ Opcodes.end ], [ Opcodes.end ]
+  );
+  depth.pop();
+  depth.pop();
 
   return out;
 };
@@ -1791,7 +1969,7 @@ const itemTypeToValtype = {
   i16: 'i32'
 };
 
-const storeOps = {
+const StoreOps = {
   i32: Opcodes.i32_store,
   i64: Opcodes.i64_store,
   f64: Opcodes.f64_store,
@@ -1823,7 +2001,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ]
   );
 
-  const storeOp = storeOps[itemType];
+  const storeOp = StoreOps[itemType];
   const valtype = itemTypeToValtype[itemType];
 
   if (!initEmpty) for (let i = 0; i < length; i++) {
@@ -2148,10 +2326,10 @@ const generateFunc = (scope, decl) => {
 };
 
 const generateCode = (scope, decl) => {
-  const out = [];
+  let out = [];
 
   for (const x of decl.body) {
-    out.push(...generate(scope, x));
+    out = out.concat(generate(scope, x));
   }
 
   return out;

package/compiler/index.js

@@ -78,7 +78,7 @@ export default (code, flags) => {
     const wasmPages = Math.ceil((pages.size * pageSize) / 65536);
     const bytes = wasmPages * 65536;
     log('alloc', `\x1B[1mallocated ${bytes / 1024}KiB\x1B[0m for ${pages.size} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}`);
-    // console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n'));
+    console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n') + '\n');
   }
 
   const out = { wasm: sections, funcs, globals, tags, exceptions, pages };

package/compiler/opt.js

@@ -317,28 +317,24 @@ export default (funcs, globals) => {
         continue;
       }
 
-      if (i < 2) continue;
-      const lastLastInst = wasm[i - 2];
+      // remove unneeded before get with update exprs (n++, etc) when value is unused
+      if (i < wasm.length - 4 && lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_get && inst[0] === Opcodes.local_get && wasm[i + 1][0] === Opcodes.const && [Opcodes.add, Opcodes.sub].includes(wasm[i + 2][0]) && wasm[i + 3][0] === Opcodes.local_set && wasm[i + 3][1] === inst[1] && (wasm[i + 4][0] === Opcodes.drop || wasm[i + 4][0] === Opcodes.br)) {
+        // local.get 1
+        // local.get 1
+        // -->
+        // local.get 1
 
-      if (depth.length === 2) {
-        // hack to remove unneeded before get in for loops with (...; i++)
-        if (lastLastInst[0] === Opcodes.end && lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_get && inst[0] === Opcodes.local_get) {
-          // local.get 1
-          // local.get 1
-          // -->
-          // local.get 1
-
-          // remove drop at the end as well
-          if (wasm[i + 4][0] === Opcodes.drop) {
-            wasm.splice(i + 4, 1);
-          }
+        // remove drop at the end as well
+        if (wasm[i + 4][0] === Opcodes.drop) wasm.splice(i + 4, 1);
 
-          wasm.splice(i, 1); // remove this inst (second get)
-          i--;
-          continue;
-        }
+        wasm.splice(i, 1); // remove this inst (second get)
+        i--;
+        continue;
       }
 
+      if (i < 2) continue;
+      const lastLastInst = wasm[i - 2];
+
       if (lastLastInst[1] === inst[1] && inst[0] === Opcodes.local_get && lastInst[0] === Opcodes.local_tee && lastLastInst[0] === Opcodes.local_set) {
         // local.set x
         // local.tee y

package/compiler/prototype.js

@@ -23,6 +23,9 @@ const TYPES = {
 
 export const PrototypeFuncs = function() {
   const noUnlikelyChecks = process.argv.includes('-funsafe-no-unlikely-proto-checks');
+  let zeroChecks = process.argv.find(x => x.startsWith('-funsafe-zero-proto-checks='));
+  if (zeroChecks) zeroChecks = zeroChecks.split('=')[1].split(',').reduce((acc, x) => { acc[x.toLowerCase()] = true; return acc; }, {});
+    else zeroChecks = {};
 
   this[TYPES._array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
@@ -36,7 +39,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_lt_s ],
       [ Opcodes.if, Blocktype.void ],
       [ Opcodes.local_get, iTmp ],
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_add ],
       [ Opcodes.local_set, iTmp ],
       [ Opcodes.end ],
@@ -47,7 +50,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_lt_s ],
 
       [ Opcodes.local_get, iTmp ],
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_ge_s ],
       [ Opcodes.i32_or ],
 
@@ -67,7 +70,7 @@ export const PrototypeFuncs = function() {
     // todo: only for 1 argument
     push: (pointer, length, wNewMember) => [
       // get memory offset of array at last index (length)
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
@@ -79,17 +82,17 @@ export const PrototypeFuncs = function() {
 
       // bump array length by 1 and return it
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_add ]
       ]),
 
-      ...length.get
+      ...length.get()
     ],
 
     pop: (pointer, length) => [
       // if length == 0, noop
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
@@ -100,13 +103,13 @@ export const PrototypeFuncs = function() {
 
       // decrement length by 1
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ]
       ]),
 
       // load last element
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
@@ -115,7 +118,7 @@ export const PrototypeFuncs = function() {
 
     shift: (pointer, length) => [
       // if length == 0, noop
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       Opcodes.i32_eqz,
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
@@ -126,7 +129,7 @@ export const PrototypeFuncs = function() {
 
       // decrement length by 1
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ]
       ]),
@@ -140,11 +143,66 @@ export const PrototypeFuncs = function() {
       ...number(pointer + ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32), // src = base array index + length size + an index
       ...number(pageSize - ValtypeSize.i32 - ValtypeSize[valtype], Valtype.i32), // size = PageSize - length size - an index
       [ ...Opcodes.memory_copy, 0x00, 0x00 ]
+    ],
+
+    fill: (pointer, length, wElement, iTmp) => [
+      ...wElement,
+      [ Opcodes.local_set, iTmp ],
+
+      // use cached length i32 as pointer
+      ...length.getCachedI32(),
+
+      // length - 1 for indexes
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_sub ],
+
+      // * sizeof value
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_mul ],
+
+      ...length.setCachedI32(),
+
+      ...(noUnlikelyChecks ? [] : [
+        ...length.getCachedI32(),
+        ...number(0, Valtype.i32),
+        [ Opcodes.i32_lt_s ],
+        [ Opcodes.if, Blocktype.void ],
+        ...number(pointer),
+        [ Opcodes.br, 1 ],
+        [ Opcodes.end ]
+      ]),
+
+      [ Opcodes.loop, Blocktype.void ],
+
+      // set element using pointer
+      ...length.getCachedI32(),
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+
+      // pointer - sizeof value
+      ...length.getCachedI32(),
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_sub ],
+
+      ...length.setCachedI32(),
+
+      // if pointer >= 0, loop
+      ...length.getCachedI32(),
+      ...number(0, Valtype.i32),
+      [ Opcodes.i32_ge_s ],
+      [ Opcodes.br_if, 0 ],
+
+      [ Opcodes.end ],
+
+      // return this array
+      ...number(pointer)
     ]
   };
 
   this[TYPES._array].at.local = Valtype.i32;
   this[TYPES._array].push.noArgRetLength = true;
+  this[TYPES._array].fill.local = valtypeBinary;
+  this[TYPES._array].fill.returnType = TYPES._array;
 
   this[TYPES.string] = {
     at: (pointer, length, wIndex, iTmp, arrayShell) => {
@@ -166,7 +224,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_lt_s ],
         [ Opcodes.if, Blocktype.void ],
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         [ Opcodes.i32_add ],
         [ Opcodes.local_set, iTmp ],
         [ Opcodes.end ],
@@ -177,7 +235,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_lt_s ],
 
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         [ Opcodes.i32_ge_s ],
         [ Opcodes.i32_or ],
 
@@ -233,27 +291,31 @@ export const PrototypeFuncs = function() {
       return [
         ...wIndex,
         Opcodes.i32_to,
-        [ Opcodes.local_set, iTmp ],
 
-        // index < 0
-        ...(noUnlikelyChecks ? [] : [
+        ...(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 ],
-          ...number(0, Valtype.i32),
-          [ Opcodes.i32_lt_s ],
-        ]),
+          ...length.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
 
-        // index >= length
-        [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
-        [ Opcodes.i32_ge_s ],
+          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+          [ Opcodes.if, Blocktype.void ],
+          ...number(NaN),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
 
-        ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
-        [ Opcodes.if, Blocktype.void ],
-        ...number(NaN),
-        [ Opcodes.br, 1 ],
-        [ Opcodes.end ],
+          [ Opcodes.local_get, iTmp ],
+        ]),
 
-        [ Opcodes.local_get, iTmp ],
         ...number(ValtypeSize.i16, Valtype.i32),
         [ Opcodes.i32_mul ],
 

package/compiler/wrap.js

@@ -34,11 +34,18 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
   times.push(performance.now() - t1);
   if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
+  const getString = pointer => {
+    const length = new Int32Array(memory.buffer, pointer, 1);
+
+    return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
+  };
+
   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)),
+      s: valtype === 'i64' ? i => print(getString(Number(i))) : i => print(getString(i)),
       a: c => { if (!Number(c)) throw new Error(`assert failed`); },
       t: _ => performance.now(),
       ...customImports

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.0.0-05f898f",
+  "version": "0.0.0-1b0a5c6",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/r.js

@@ -1 +1,39 @@
-print(performance.now());
+compareArray.isSameValue = function(a, b) {
+  if (a === 0 && b === 0) return 1 / a === 1 / b;
+  if (a !== a && b !== b) return true;
+
+  return a === b;
+};
+
+function compareArray(a, b) {
+  // if either are nullish
+  if (a == null || b == null) return false;
+
+  // megahack: all arrays from now on will be >0 pointer
+  const _hack = '';
+
+  // hack: enforce type inference of being arrays
+  a ??= [];
+  b ??= [];
+
+  if (b.length !== a.length) {
+    return false;
+  }
+
+  for (var i = 0; i < a.length; i++) {
+    if (!compareArray.isSameValue(b[i], a[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+console.log(compareArray(null, []));
+console.log(compareArray(undefined, []));
+
+console.log(compareArray([], []));
+console.log(compareArray([ 1 ], []));
+console.log(compareArray([ 1 ], [ 1 ]));
+console.log(compareArray([ 1, 2 ], [ 1 ]));
+console.log(compareArray([ 1, 2 ], [ 1, 2 ]));

package/rhemyn/compile.js

@@ -21,7 +21,7 @@ const generate = (node, negated = false, get = true, func = 'test') => {
       out = [
         // set length local
         [ Opcodes.local_get, BasePointer ],
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(0) ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
         [ Opcodes.local_set, Length ],
 
         // set iter pointer local as base + sizeof i32 initially

package/runner/index.js

@@ -34,12 +34,14 @@ const source = fs.readFileSync(file, 'utf8');
 
 let cache = '';
 const print = str => {
-  cache += str;
+  /* cache += str;
 
   if (str === '\n') {
     process.stdout.write(cache);
     cache = '';
-  } else print('\n');
+  } */
+
+  process.stdout.write(str);
 };
 
 try {
@@ -49,5 +51,5 @@ try {
   if (cache) process.stdout.write(cache);
 } catch (e) {
   if (cache) process.stdout.write(cache);
-  console.error(`${e.constructor.name}: ${e.message}`);
+  console.error(process.argv.includes('-i') ? e : `${e.constructor.name}: ${e.message}`);
 }

package/runner/info.js

@@ -36,7 +36,7 @@ const print = str => {
 };
 
 const t0 = performance.now();
-const { wasm, exports } = await compile(source, raw ? [ 'module' ] : [ 'module', 'info' ], {}, print);
+const { wasm, exports, pages } = await compile(source, raw ? [ 'module' ] : [ 'module', 'info' ], {}, print);
 
 if (!raw && typeof Deno === 'undefined') fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
@@ -51,4 +51,39 @@ if (!process.argv.includes('-no-run')) {
 }
 
 if (!raw) console.log(bold(`wasm binary is ${wasm.byteLength} bytes`));
-if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);
+if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);
+
+if (!raw && process.argv.includes('-mem') && exports.$) {
+  console.log();
+
+  let lastMemory, lastPages;
+  const PageSize = 65536;
+  const memoryToString = mem => {
+    let out = '';
+    const pages = lastPages.length;
+    const wasmPages = mem.buffer.byteLength / PageSize;
+
+    out += `\x1B[1mallocated ${mem.buffer.byteLength / 1024}KiB\x1B[0m for ${pages} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}\n`;
+
+    const buf = new Uint8Array(mem.buffer);
+
+    for (let i = 0; i < pages; i++) {
+      out += `\x1B[36m${lastPages[i]}\x1B[2m | \x1B[0m`;
+
+      for (let j = 0; j < 50; j++) {
+        const val = buf[i * pageSize + j];
+        if (val === 0) out += '\x1B[2m';
+        out += val.toString(16).padStart(2, '0');
+        if (val === 0) out += '\x1B[0m';
+        out += ' ';
+      }
+      out += '\n';
+    }
+
+    return out;
+  };
+
+  lastPages = [...pages.keys()];
+  lastMemory = exports.$;
+  console.log(memoryToString(lastMemory));
+}