porffor 0.16.0-a8f23d010 → 0.16.0-b099006b8

package/CONTRIBUTING.md

@@ -26,7 +26,7 @@ You can also swap out `node` in the alias to use another runtime like Deno (`den
 
 ### Precompile
 
-**If you update any file inside `compiler/builtins` you will need to do this for it to update inside Porffor otherwise your changes will have no effect.** Run `./porf precompile` to precompile. It may error during this, if so, you might have an error in your code or there could be a compiler error with Porffor (feel free to ask for help as soon as you encounter any errors with it).
+**If you update any file inside `compiler/builtins` you will need to do this for it to update inside Porffor otherwise your changes will have no effect.** Run `node compiler/precompile.js` to precompile. It may error during this, if so, you might have an error in your code or there could be a compiler error with Porffor (feel free to ask for help as soon as you encounter any errors with it).
 
 <br>
 

package/compiler/codegen.js

@@ -1,4 +1,4 @@
-import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
+import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from './wasmSpec.js';
 import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from './encoding.js';
 import { operatorOpcode } from './expression.js';
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
@@ -181,6 +181,12 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
               continue;
             }
 
+            if (asm[0] === 'memory') {
+              allocPage(scope, 'asm instrinsic');
+              // todo: add to store/load offset insts
+              continue;
+            }
+
             let inst = Opcodes[asm[0].replace('.', '_')];
             if (inst == null) throw new Error(`inline asm: inst ${asm[0]} not found`);
 
@@ -427,6 +433,57 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
   const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
   const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
 
+  if (assign && Prefs.aotPointerOpt) {
+    const pointer = scope.arrays?.get(name ?? '$undeclared');
+
+    return [
+      // setup right
+      ...right,
+      Opcodes.i32_to_u,
+      [ Opcodes.local_set, rightPointer ],
+
+      // calculate length
+      ...number(0, Valtype.i32), // base 0 for store later
+
+      ...number(pointer, Valtype.i32),
+      [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
+      [ Opcodes.local_tee, leftLength ],
+
+      [ Opcodes.local_get, rightPointer ],
+      [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
+      [ Opcodes.local_tee, rightLength ],
+
+      [ Opcodes.i32_add ],
+
+      // store length
+      [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ],
+
+      // copy right
+      // dst = out pointer + length size + current length * sizeof valtype
+      ...number(pointer + ValtypeSize.i32, Valtype.i32),
+
+      [ Opcodes.local_get, leftLength ],
+      ...number(bytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_mul ],
+      [ Opcodes.i32_add ],
+
+      // src = right pointer + length size
+      [ Opcodes.local_get, rightPointer ],
+      ...number(ValtypeSize.i32, Valtype.i32),
+      [ Opcodes.i32_add ],
+
+      // size = right length * sizeof valtype
+      [ Opcodes.local_get, rightLength ],
+      ...number(bytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_mul ],
+
+      [ ...Opcodes.memory_copy, 0x00, 0x00 ],
+
+      // return new string (page)
+      ...number(pointer)
+    ];
+  }
+
   const leftPointer = localTmp(scope, 'concat_left_pointer', Valtype.i32);
 
   // alloc/assign array
@@ -2058,6 +2115,7 @@ const brTable = (input, bc, returns) => {
   }
 
   for (let i = 0; i < count; i++) {
+    // if (i === 0) out.push([ Opcodes.block, returns, 'br table start' ]);
     if (i === 0) out.push([ Opcodes.block, returns ]);
       else out.push([ Opcodes.block, Blocktype.void ]);
   }
@@ -2091,8 +2149,10 @@ const brTable = (input, bc, returns) => {
     [ Opcodes.br_table, ...encodeVector(table), 0 ]
   );
 
-  // sort the wrong way and then reverse
-  // so strings ('default') are at the start before any numbers
+  // if you can guess why we sort the wrong way and then reverse
+  // (instead of just sorting the correct way)
+  // dm me and if you are correct and the first person
+  // I will somehow shout you out or something
   const orderedBc = keys.sort((a, b) => b - a).reverse();
 
   br = count - 1;
@@ -2118,7 +2178,7 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
     return bc[known] ?? bc.default;
   }
 
-  if (Prefs.typeswitchBrtable)
+  if (Prefs.typeswitchUseBrtable)
     return brTable(type, bc, returns);
 
   const tmp = localTmp(scope, '#typeswitch_tmp' + (Prefs.typeswitchUniqueTmp ? randId() : ''), Valtype.i32);
@@ -2339,12 +2399,19 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
   // hack: .length setter
   if (decl.left.type === 'MemberExpression' && decl.left.property.name === 'length') {
+    const name = decl.left.object.name;
+    const pointer = scope.arrays?.get(name);
+
+    const aotPointer = Prefs.aotPointerOpt && pointer != null;
+
     const newValueTmp = localTmp(scope, '__length_setter_tmp');
     const pointerTmp = op === '=' ? null : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
 
     return [
-      ...generate(scope, decl.left.object),
-      Opcodes.i32_to_u,
+      ...(aotPointer ? number(0, Valtype.i32) : [
+        ...generate(scope, decl.left.object),
+        Opcodes.i32_to_u
+      ]),
       ...(!pointerTmp ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
       ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
@@ -2355,7 +2422,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
       [ Opcodes.local_tee, newValueTmp ],
 
       Opcodes.i32_to_u,
-      [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ],
+      [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
 
       [ Opcodes.local_get, newValueTmp ]
     ];
@@ -2363,14 +2430,21 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
   // arr[i]
   if (decl.left.type === 'MemberExpression' && decl.left.computed) {
+    const name = decl.left.object.name;
+    const pointer = scope.arrays?.get(name);
+
+    const aotPointer = Prefs.aotPointerOpt && pointer != null;
+
     const newValueTmp = localTmp(scope, '__member_setter_val_tmp');
     const pointerTmp = op === '=' ? -1 : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
 
     return [
       ...typeSwitch(scope, getNodeType(scope, decl.left.object), {
         [TYPES.array]: [
-          ...generate(scope, decl.left.object),
-          Opcodes.i32_to_u,
+          ...(aotPointer ? [] : [
+            ...generate(scope, decl.left.object),
+            Opcodes.i32_to_u
+          ]),
 
           // get index as valtype
           ...generate(scope, decl.left.property),
@@ -2379,22 +2453,39 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
           // turn into byte offset by * valtypeSize (4 for i32, 8 for i64/f64)
           ...number(ValtypeSize[valtype] + 1, Valtype.i32),
           [ Opcodes.i32_mul ],
-          [ Opcodes.i32_add ],
+          ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
           ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
           ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
             [ Opcodes.local_get, pointerTmp ],
-            [ Opcodes.load, 0, ValtypeSize.i32 ]
+            [ Opcodes.load, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
           ], generate(scope, decl.right), [
             [ Opcodes.local_get, pointerTmp ],
-            [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
+            [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
           ], getNodeType(scope, decl.right), false, name, true)),
           [ Opcodes.local_tee, newValueTmp ],
 
-          [ Opcodes.store, 0, ValtypeSize.i32 ]
+          [ Opcodes.store, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
         ],
 
         default: internalThrow(scope, 'TypeError', `Cannot assign member with non-array`)
+
+        // [TYPES.string]: [
+        //   // turn into byte offset by * sizeof i16
+        //   ...number(ValtypeSize.i16, Valtype.i32),
+        //   [ Opcodes.i32_mul ],
+        //   ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
+        //   ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+        //   ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+        //     [ Opcodes.local_get, pointerTmp ],
+        //     [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+        //   ], generate(scope, decl.right), number(TYPES.string, Valtype.i32), getNodeType(scope, decl.right))),
+        //   [ Opcodes.local_tee, newValueTmp ],
+
+        //   Opcodes.i32_to_u,
+        //   [ StoreOps.i16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+        // ]
       }, Blocktype.void),
 
       [ Opcodes.local_get, newValueTmp ]
@@ -3116,6 +3207,16 @@ const allocPage = (scope, reason, type) => {
   return ind;
 };
 
+// todo: add scope.pages
+const freePage = reason => {
+  const { ind } = pages.get(reason);
+  pages.delete(reason);
+
+  if (Prefs.allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
+
+  return ind;
+};
+
 const itemTypeToValtype = {
   i32: 'i32',
   i64: 'i64',
@@ -3169,7 +3270,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     firstAssign = true;
 
     // todo: can we just have 1 undeclared array? probably not? but this is not really memory efficient
-    const uniqueName = name === '$undeclared' ? name + randId() : name;
+    const uniqueName = name === '$undeclared' ? name + Math.random().toString().slice(2) : name;
 
     let page;
     if (Prefs.scopedPageNames) page = allocPage(scope, `${getAllocType(itemType)}: ${scope.name}/${uniqueName}`, itemType);
@@ -3190,7 +3291,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   const valtype = itemTypeToValtype[itemType];
   const length = elements.length;
 
-  if (Prefs.data && firstAssign && useRawElements) {
+  if (firstAssign && useRawElements && !Prefs.noData) {
     // if length is 0 memory/data will just be 0000... anyway
     if (length !== 0) {
       let bytes = compileBytes(length, 'i32');
@@ -3258,7 +3359,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   return [ out, pointer ];
 };
 
-const storeArray = (scope, array, index, element) => {
+const storeArray = (scope, array, index, element, aotPointer = null) => {
   if (!Array.isArray(element)) element = generate(scope, element);
   if (typeof index === 'number') index = number(index);
 
@@ -3270,25 +3371,26 @@ const storeArray = (scope, array, index, element) => {
     Opcodes.i32_to_u,
     ...number(ValtypeSize[valtype] + 1, Valtype.i32),
     [ Opcodes.i32_mul ],
-
-    ...array,
-    Opcodes.i32_to_u,
-    [ Opcodes.i32_add ],
+    ...(aotPointer ? [] : [
+      ...array,
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_add ],
+    ]),
     [ Opcodes.local_set, offset ],
 
     // store value
     [ Opcodes.local_get, offset ],
     ...generate(scope, element),
-    [ Opcodes.store, 0, ValtypeSize.i32 ],
+    [ Opcodes.store, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
     // store type
     [ Opcodes.local_get, offset ],
     ...getNodeType(scope, element),
-    [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
+    [ Opcodes.i32_store8, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
   ];
 };
 
-const loadArray = (scope, array, index) => {
+const loadArray = (scope, array, index, aotPointer = null) => {
   if (typeof index === 'number') index = number(index);
 
   const offset = localTmp(scope, '#loadArray_offset', Valtype.i32);
@@ -3299,19 +3401,20 @@ const loadArray = (scope, array, index) => {
     Opcodes.i32_to_u,
     ...number(ValtypeSize[valtype] + 1, Valtype.i32),
     [ Opcodes.i32_mul ],
-
-    ...array,
-    Opcodes.i32_to_u,
-    [ Opcodes.i32_add ],
+    ...(aotPointer ? [] : [
+      ...array,
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_add ],
+    ]),
     [ Opcodes.local_set, offset ],
 
     // load value
     [ Opcodes.local_get, offset ],
-    [ Opcodes.load, 0, ValtypeSize.i32 ],
+    [ Opcodes.load, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
     // load type
     [ Opcodes.local_get, offset ],
-    [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
+    [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
   ];
 };
 
@@ -3362,6 +3465,9 @@ const withType = (scope, wasm, type) => [
 
 const generateMember = (scope, decl, _global, _name) => {
   const name = decl.object.name;
+  const pointer = scope.arrays?.get(name);
+
+  const aotPointer = Prefs.aotPointerOpt && pointer;
 
   // hack: .name
   if (decl.property.name === 'name') {
@@ -3402,10 +3508,12 @@ const generateMember = (scope, decl, _global, _name) => {
     if (Prefs.fastLength) {
       // presume valid length object
       return [
-        ...generate(scope, decl.object),
-        Opcodes.i32_to_u,
+        ...(aotPointer ? number(0, Valtype.i32) : [
+          ...generate(scope, decl.object),
+          Opcodes.i32_to_u
+        ]),
 
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
         Opcodes.i32_from_u
       ];
     }
@@ -3414,10 +3522,12 @@ const generateMember = (scope, decl, _global, _name) => {
     const known = knownType(scope, type);
     if (known != null) {
       if ([ TYPES.string, TYPES.bytestring, TYPES.array ].includes(known)) return [
-        ...generate(scope, decl.object),
-        Opcodes.i32_to_u,
+        ...(aotPointer ? number(0, Valtype.i32) : [
+          ...generate(scope, decl.object),
+          Opcodes.i32_to_u
+        ]),
 
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
         Opcodes.i32_from_u
       ];
 
@@ -3427,10 +3537,12 @@ const generateMember = (scope, decl, _global, _name) => {
     return [
       ...typeIsOneOf(getNodeType(scope, decl.object), [ TYPES.string, TYPES.bytestring, TYPES.array ]),
       [ Opcodes.if, valtypeBinary ],
-        ...generate(scope, decl.object),
-        Opcodes.i32_to_u,
+        ...(aotPointer ? number(0, Valtype.i32) : [
+          ...generate(scope, decl.object),
+          Opcodes.i32_to_u
+        ]),
 
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
         Opcodes.i32_from_u,
 
         ...setLastType(scope, TYPES.number),
@@ -3482,7 +3594,7 @@ const generateMember = (scope, decl, _global, _name) => {
 
   return typeSwitch(scope, getNodeType(scope, decl.object), {
     [TYPES.array]: [
-      ...loadArray(scope, object, property),
+      ...loadArray(scope, object, property, aotPointer),
       ...setLastType(scope)
     ],
 
@@ -3499,12 +3611,14 @@ const generateMember = (scope, decl, _global, _name) => {
       ...number(ValtypeSize.i16, Valtype.i32),
       [ Opcodes.i32_mul ],
 
-      ...object,
-      Opcodes.i32_to_u,
-      [ Opcodes.i32_add ],
+      ...(aotPointer ? [] : [
+        ...object,
+        Opcodes.i32_to_u,
+        [ Opcodes.i32_add ]
+      ]),
 
       // load current string ind {arg}
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
       // store to new string ind 0
       [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
@@ -3523,12 +3637,14 @@ const generateMember = (scope, decl, _global, _name) => {
       ...property,
       Opcodes.i32_to_u,
 
-      ...object,
-      Opcodes.i32_to_u,
-      [ Opcodes.i32_add ],
+      ...(aotPointer ? [] : [
+        ...object,
+        Opcodes.i32_to_u,
+        [ Opcodes.i32_add ]
+      ]),
 
       // load current string ind {arg}
-      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
       // store to new string ind 0
       [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
@@ -3542,7 +3658,7 @@ const generateMember = (scope, decl, _global, _name) => {
   });
 };
 
-const randId = () => Math.random().toString(16).slice(1, -2).padEnd(12, '0');
+const randId = () => Math.random().toString(16).slice(0, -4);
 
 const objectHack = node => {
   if (!node) return node;
@@ -3594,7 +3710,7 @@ const generateFunc = (scope, decl) => {
   if (decl.async) return todo(scope, 'async functions are not supported');
   if (decl.generator) return todo(scope, 'generator functions are not supported');
 
-  const name = decl.id ? decl.id.name : `anonymous${randId()}`;
+  const name = decl.id ? decl.id.name : `anonymous_${randId()}`;
   const params = decl.params ?? [];
 
   // TODO: share scope/locals between !!!

package/compiler/cyclone.js

@@ -246,7 +246,7 @@ export default wasm => {
         const [ b, a ] = pop2();
         const v = bool(a === b);
 
-        replaceVal(v, Valtype.i32);
+        replaceVal(v, Valtype.f64);
         push(v);
         break;
       }
@@ -255,7 +255,7 @@ export default wasm => {
         const [ b, a ] = pop2();
         const v = bool(a !== b);
 
-        replaceVal(v, Valtype.i32);
+        replaceVal(v, Valtype.f64);
         push(v);
         break;
       }
@@ -264,7 +264,7 @@ export default wasm => {
         const [ b, a ] = pop2();
         const v = bool(a < b);
 
-        replaceVal(v, Valtype.i32);
+        replaceVal(v, Valtype.f64);
         push(v);
         break;
       }
@@ -273,7 +273,7 @@ export default wasm => {
         const [ b, a ] = pop2();
         const v = bool(a <= b);
 
-        replaceVal(v, Valtype.i32);
+        replaceVal(v, Valtype.f64);
         push(v);
         break;
       }
@@ -282,7 +282,7 @@ export default wasm => {
         const [ b, a ] = pop2();
         const v = bool(a > b);
 
-        replaceVal(v, Valtype.i32);
+        replaceVal(v, Valtype.f64);
         push(v);
         break;
       }
@@ -291,7 +291,7 @@ export default wasm => {
         const [ b, a ] = pop2();
         const v = bool(a >= b);
 
-        replaceVal(v, Valtype.i32);
+        replaceVal(v, Valtype.f64);
         push(v);
         break;
       }
@@ -404,7 +404,7 @@ export default wasm => {
       case Opcodes.f64_max: {
         if (stack.length < 2) { empty(); break; };
         const [ b, a ] = pop2();
-        const v = Math.max(a, b);
+        const v = a + b;
 
         replaceVal(v, Valtype.f64);
         push(v);
@@ -467,9 +467,9 @@ export default wasm => {
     // i32.const 1
     // i32.add
     // local.set 7 ;; $i (i32)
-    if (i >= 2 &&
-      ((opcode >= 0xa0 && opcode <= 0xa3) || // main f64 math op
-      (opcode >= 0x61 && opcode <= 0x66)) // main f64 eq op
+    if (
+      (opcode >= 0xa0 && opcode <= 0xa3) || // main f64 math op
+      (opcode >= 0x61 && opcode <= 0x66) // main f64 eq op
     ) {
       const o2 = wasm[i - 1][0];
       if (o2 === Opcodes.f64_const) { // f64.const
@@ -500,7 +500,7 @@ export default wasm => {
       }
     }
 
-    if ((opcode === 0xfc02 || opcode === 0xfc03) && i >= 3) { // i32.trunc_sat_f64_s/u
+    if ((opcode === 0xfc02 || opcode === 0xfc03) && i > 3) { // i32.trunc_sat_f64_s/u
       const o2 = wasm[i - 1][0];
       if (
         (o2 >= 0xa0 && o2 <= 0xa3) || // main f64 math op

package/compiler/opt.js

@@ -172,14 +172,14 @@ export default (funcs, globals, pages, tags, exceptions) => {
           }
         }
 
-        if (inst[inst.length - 1] === 'string_only' && !pages.hasAnyString && Prefs.rmUnusedTypes) {
+        if (inst[inst.length - 1] === 'string_only' && !pages.hasAnyString && !Prefs.noRmUnusedTypes) {
           // remove this inst
           wasm.splice(i, 1);
           if (i > 0) i--;
           inst = wasm[i];
         }
 
-        if (inst[inst.length - 1] === 'string_only|start' && !pages.hasAnyString && Prefs.rmUnusedTypes) {
+        if (inst[inst.length - 1] === 'string_only|start' && !pages.hasAnyString&& !Prefs.noRmUnusedTypes) {
           let j = i;
           for (; j < wasm.length; j++) {
             const op = wasm[j];
@@ -193,7 +193,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           inst = wasm[i];
         }
 
-        if (inst[0] === Opcodes.if && typeof inst[2] === 'string' && Prefs.rmUnusedTypes) {
+        if (inst[0] === Opcodes.if && typeof inst[2] === 'string' && !Prefs.noRmUnusedTypes) {
           // remove unneeded typeswitch checks
 
           const type = inst[2].split('|')[1];

package/compiler/parse.js

@@ -43,7 +43,7 @@ export default (input, flags) => {
       webcompat: true,
 
       // babel
-      plugins: types || flags.includes('typed') ? ['estree', 'typescript'] : ['estree'],
+      plugins: types ? ['estree', 'typescript'] : ['estree'],
 
       // multiple
       sourceType: flags.includes('module') ? 'module' : 'script',

package/compiler/pgo.js

@@ -11,7 +11,7 @@ export const setup = () => {
 
   // enable these prefs by default for pgo
   Prefs.typeswitchUniqueTmp = Prefs.typeswitchUniqueTmp === false ? false : true;
-  Prefs.cyclone = Prefs.cyclone === false ? false : true;
+  Prefs.cyclone = Prefs.cyclone === false ? false : true;;
 };
 
 export const run = obj => {
@@ -131,18 +131,16 @@ export const run = obj => {
     func.localValues = localValues;
 
     let counts = new Array(10).fill(0);
-    const consistents = localData[i].map((x, j) => {
-      if (j < func.params.length) return false; // param
-      if (x.length === 0 || !x.every((y, i) => i < 1 ? true : y === x[i - 1])) return false; // not consistent
+    const consistents = localData[i].map(x => {
+      if (x.length === 0 || !x.every((y, i) => i < 1 ? true : y === x[i - 1])) return false;
 
       counts[0]++;
       return x[0];
     });
 
     const integerOnlyF64s = localData[i].map((x, j) => {
-      if (j < func.params.length) return false; // param
       if (localValues[j].type === Valtype.i32) return false; // already i32
-      if (x.length === 0 || !x.every(y => Number.isInteger(y))) return false; // not all integer values
+      if (x.length === 0 || !x.every(y => Number.isInteger(y))) return false;
 
       counts[1]++;
       return true;
@@ -153,14 +151,14 @@ export const run = obj => {
 
     log += `  ${func.name}: identified ${counts[0]}/${total} locals as consistent${Prefs.verbosePgo ? ':' : ''}\n`;
     if (Prefs.verbosePgo) {
-      for (let j = func.params.length; j < localData[i].length; j++) {
+      for (let j = 0; j < localData[i].length; j++) {
         log += `    ${consistents[j] !== false ? '\u001b[92m' : '\u001b[91m'}${localKeys[j]}\u001b[0m: ${new Set(localData[i][j]).size} unique values set\n`;
       }
     }
 
     log += `  ${func.name}: identified ${counts[1]}/${localValues.reduce((acc, x) => acc + (x.type === Valtype.f64 ? 1 : 0), 0)} f64 locals as integer usage only${Prefs.verbosePgo ? ':' : ''}\n`;
     if (Prefs.verbosePgo) {
-      for (let j = func.params.length; j < localData[i].length; j++) {
+      for (let j = 0; j < localData[i].length; j++) {
         if (localValues[j].type !== Valtype.f64) continue;
         log += `    ${integerOnlyF64s[j] ? '\u001b[92m' : '\u001b[91m'}${localKeys[j]}\u001b[0m\n`;
       }
@@ -180,6 +178,7 @@ export const run = obj => {
     for (let i = 0; i < x.integerOnlyF64s.length; i++) {
       const c = x.integerOnlyF64s[i];
       if (c === false) continue;
+      if (i < x.params.length) continue;
 
       targets.push(i);
     }
@@ -192,6 +191,7 @@ export const run = obj => {
     for (let i = 0; i < x.consistents.length; i++) {
       const c = x.consistents[i];
       if (c === false) continue;
+      if (i < x.params.length) continue;
 
       targets.push(i);
 

package/compiler/precompile.js

@@ -26,7 +26,7 @@ const compile = async (file, [ _funcs, _globals ]) => {
 
   const porfCompile = (await import(`./index.js?_=${Date.now()}`)).default;
 
-  let { funcs, globals, data, exceptions } = porfCompile(source, ['module', 'typed']);
+  let { funcs, globals, data, exceptions } = porfCompile(source, ['module']);
 
   const allocated = new Set();
 
@@ -87,8 +87,6 @@ const compile = async (file, [ _funcs, _globals ]) => {
 };
 
 const precompile = async () => {
-  if (globalThis._porf_loadParser) await globalThis._porf_loadParser('@babel/parser');
-
   const dir = join(__dirname, 'builtins');
 
   let funcs = [], globals = [];

package/compiler/prefs.js

@@ -1,4 +1,4 @@
-const onByDefault = [ 'bytestring', 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls', 'optUnused', 'data', 'rmUnusedTypes' ];
+const onByDefault = [ 'bytestring', 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls', 'optUnused' ];
 
 let cache = {};
 const obj = new Proxy({}, {

package/compiler/wrap.js

@@ -128,7 +128,7 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
 
   if (source.includes?.('export ')) flags.push('module');
 
-  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (Prefs.profileCompiler) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.16.0-a8f23d010",
+  "version": "0.16.0-b099006b8",
   "author": "CanadaHonk",
   "license": "MIT",
-  "scripts": {},
+  "scripts": {
+    "precompile": "node ./compiler/precompile.js"
+  },
   "dependencies": {
     "acorn": "^8.11.3",
     "node-repl-polyfill": "^0.1.1"
@@ -26,5 +28,5 @@
   "bugs": {
     "url": "https://github.com/CanadaHonk/porffor/issues"
   },
-  "homepage": "https://porffor.dev"
+  "homepage": "https://porffor.goose.icu"
 }

package/runner/index.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+
+import compile from '../compiler/wrap.js';
 import fs from 'node:fs';
 
 const start = performance.now();
@@ -57,15 +59,10 @@ if (process.argv.includes('--help')) {
 }
 
 let file = process.argv.slice(2).find(x => x[0] !== '-');
-if (['precompile', 'run', 'wasm', 'native', 'c', 'profile', 'debug', 'debug-wasm'].includes(file)) {
+if (['run', 'wasm', 'native', 'c', 'profile', 'debug', 'debug-wasm'].includes(file)) {
   // remove this arg
   process.argv.splice(process.argv.indexOf(file), 1);
 
-  if (file === 'precompile') {
-    await import('../compiler/precompile.js');
-    await new Promise(() => {}); // do nothing for the rest of this file
-  }
-
   if (file === 'profile') {
     await import('./profile.js');
     await new Promise(() => {}); // do nothing for the rest of this file
@@ -108,8 +105,6 @@ if (!file) {
 
 const source = fs.readFileSync(file, 'utf8');
 
-const compile = (await import('../compiler/wrap.js')).default;
-
 let cache = '';
 const print = str => {
   /* cache += str;

package/compiler/allocators/static.js

@@ -1,41 +0,0 @@
-import { Valtype } from '../wasmSpec.js';
-import { number } from './embedding.js';
-import { log } from './log.js';
-import Prefs from './prefs.js';
-
-let pages = new Set();
-export const setup = () => {
-  pages = new Set();
-};
-
-const getAllocType = itemType => {
-  switch (itemType) {
-    case 'i8': return 'bytestring';
-    case 'i16': return 'string';
-
-    default: return 'array';
-  }
-};
-
-export const alloc = ({ scope }, name, itemType) => {
-  const reason = Prefs.scopedPageNames ? `${getAllocType(itemType)}: ${scope.name}/${name}` : `${getAllocType(itemType)}: ${name}`;
-
-  if (pages.has(reason)) return number(pages.get(reason).ind, Valtype.i32);
-
-  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 });
-
-  scope.pages ??= new Map();
-  scope.pages.set(reason, { ind, type });
-
-  if (Prefs.allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason} (type: ${type})`);
-
-  return number(ind, Valtype.i32);
-};
-
-export const getStaticPages = () => pages;