porffor 0.16.0-fe07da0f4 → 0.17.0-048c6f2ee

package/compiler/codegen.js

@@ -1,5 +1,5 @@
-import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from './wasmSpec.js';
-import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from './encoding.js';
+import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
+import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector, read_signedLEB128 } from './encoding.js';
 import { operatorOpcode } from './expression.js';
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
 import { PrototypeFuncs } from './prototype.js';
@@ -9,15 +9,16 @@ import * as Rhemyn from '../rhemyn/compile.js';
 import parse from './parse.js';
 import { log } from './log.js';
 import Prefs from './prefs.js';
+import makeAllocator from './allocators.js';
 
 let globals = {};
-let globalInd = 0;
 let tags = [];
 let funcs = [];
 let exceptions = [];
 let funcIndex = {};
 let currentFuncIndex = importedFuncs.length;
 let builtinFuncs = {}, builtinVars = {}, prototypeFuncs = {};
+let allocator;
 
 class TodoError extends Error {
   constructor(message) {
@@ -32,11 +33,6 @@ const todo = (scope, msg, expectsValue = undefined) => {
 
     case 'runtime':
       return internalThrow(scope, 'TodoError', msg, expectsValue);
-
-      // return [
-      //   ...debug(`todo! ${msg}`),
-      //   [ Opcodes.unreachable ]
-      // ];
   }
 };
 
@@ -181,12 +177,6 @@ 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`);
 
@@ -274,10 +264,12 @@ const internalThrow = (scope, constructor, message, expectsValue = Prefs.alwaysV
     argument: {
       type: 'NewExpression',
       callee: {
+        type: 'Identifier',
         name: constructor
       },
       arguments: [
         {
+          type: 'Literal',
           value: message
         }
       ]
@@ -433,63 +425,12 @@ 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
-  const [ , pointer ] = makeArray(scope, {
+  const [ out, pointer ] = makeArray(scope, {
     rawElements: new Array(0)
-  }, global, name, true, 'i16');
+  }, assign ? false : global, assign ? undefined : name, true, 'i16', true);
 
   return [
     // setup left
@@ -503,7 +444,7 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
     [ Opcodes.local_set, rightPointer ],
 
     // calculate length
-    ...number(0, Valtype.i32), // base 0 for store later
+    ...out,
 
     [ Opcodes.local_get, leftPointer ],
     [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
@@ -516,11 +457,13 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
     [ Opcodes.i32_add ],
 
     // store length
-    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ],
+    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ],
 
     // copy left
     // dst = out pointer + length size
-    ...number(pointer + ValtypeSize.i32, Valtype.i32),
+    ...pointer,
+    ...number(ValtypeSize.i32, Valtype.i32),
+    [ Opcodes.i32_add ],
 
     // src = left pointer + length size
     [ Opcodes.local_get, leftPointer ],
@@ -533,7 +476,9 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
 
     // copy right
     // dst = out pointer + length size + left length * sizeof valtype
-    ...number(pointer + ValtypeSize.i32, Valtype.i32),
+    ...pointer,
+    ...number(ValtypeSize.i32, Valtype.i32),
+    [ Opcodes.i32_add ],
 
     [ Opcodes.local_get, leftLength ],
     ...number(bytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
@@ -553,7 +498,8 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
     [ ...Opcodes.memory_copy, 0x00, 0x00 ],
 
     // return new string (page)
-    ...number(pointer)
+    ...pointer,
+    Opcodes.i32_from_u
   ];
 };
 
@@ -669,10 +615,10 @@ const compareStrings = (scope, left, right, bytestrings = false) => {
 };
 
 const truthy = (scope, wasm, type, intIn = false, intOut = false, forceTruthyMode = undefined) => {
-  if (isIntToFloatOp(wasm[wasm.length - 1])) return [
-    ...wasm,
-    ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
-  ];
+  // if (isIntToFloatOp(wasm[wasm.length - 1])) return [
+  //   ...wasm,
+  //   ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
+  // ];
   // if (isIntOp(wasm[wasm.length - 1])) return [ ...wasm ];
 
   // todo/perf: use knownType and custom bytecode here instead of typeSwitch
@@ -1014,12 +960,9 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
       [ Opcodes.end ],
     ]));
 
-    // if not already in block, add a block
-    // if (endOut.length === 0) {
-      startOut.push(stringOnly([ Opcodes.block, Valtype.i32 ]));
-      // endOut.push(stringOnly([ Opcodes.end ]));
-      endOut.unshift(stringOnly([ Opcodes.end ]));
-    // }
+    // add a surrounding block
+    startOut.push(stringOnly([ Opcodes.block, Valtype.i32 ]));
+    endOut.unshift(stringOnly([ Opcodes.end ]));
   }
 
   return finalize([
@@ -1054,7 +997,7 @@ const asmFuncToAsm = (func, scope) => {
   });
 };
 
-const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [], data: _data = [], table = false }) => {
+const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits = [], returns, returnType, localNames = [], globalNames = [], data: _data = [], table = false }) => {
   const existing = funcs.find(x => x.name === name);
   if (existing) return existing;
 
@@ -1068,7 +1011,7 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
 
   for (const x of _data) {
     const copy = { ...x };
-    copy.offset += pages.size * pageSize;
+    if (copy.offset != null) copy.offset += pages.size * pageSize;
     data.push(copy);
   }
 
@@ -1078,7 +1021,7 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     locals,
     localInd: allLocals.length,
     returns,
-    returnType: returnType ?? TYPES.number,
+    returnType,
     internal: true,
     index: currentFuncIndex++,
     table
@@ -1091,9 +1034,9 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
 
   let baseGlobalIdx, i = 0;
   for (const type of globalTypes) {
-    if (baseGlobalIdx === undefined) baseGlobalIdx = globalInd;
+    if (baseGlobalIdx === undefined) baseGlobalIdx = globals['#ind'];
 
-    globals[globalNames[i] ?? `${name}_global_${i}`] = { idx: globalInd++, type, init: globalInits[i] ?? 0 };
+    globals[globalNames[i] ?? `${name}_global_${i}`] = { idx: globals['#ind']++, type, init: globalInits[i] ?? 0 };
     i++;
   }
 
@@ -1106,11 +1049,15 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     }
   }
 
-  if (table) for (const inst of wasm) {
-    if (inst[0] === Opcodes.i32_load16_u && inst.at(-1) === 'read_argc') {
-      inst.splice(2, 99);
-      inst.push(...unsignedLEB128(allocPage({}, 'func argc lut') * pageSize));
+  if (table) {
+    for (const inst of wasm) {
+      if (inst[0] === Opcodes.i32_load16_u && inst.at(-1) === 'read_argc') {
+        inst.splice(2, 99);
+        inst.push(...unsignedLEB128(allocPage({}, 'func argc lut') * pageSize));
+      }
     }
+
+    funcs.table = true;
   }
 
   func.wasm = wasm;
@@ -1254,7 +1201,7 @@ const getNodeType = (scope, node) => {
       const func = funcs.find(x => x.name === name);
 
       if (func) {
-        if (func.returnType) return func.returnType;
+        if (func.returnType != null) return func.returnType;
       }
 
       if (builtinFuncs[name] && !builtinFuncs[name].typedReturns) return builtinFuncs[name].returnType ?? TYPES.number;
@@ -1270,15 +1217,7 @@ const getNodeType = (scope, node) => {
         const func = spl[spl.length - 1];
         const protoFuncs = Object.keys(prototypeFuncs).filter(x => x != TYPES.bytestring && prototypeFuncs[x][func] != null);
         if (protoFuncs.length === 1) {
-          if (protoFuncs[0].returnType) return protoFuncs[0].returnType;
-        }
-
-        if (protoFuncs.length > 0) {
-          if (scope.locals['#last_type']) return getLastType(scope);
-
-          // presume
-          // todo: warn here?
-          return TYPES.number;
+          if (protoFuncs[0].returnType != null) return protoFuncs[0].returnType;
         }
       }
 
@@ -1326,7 +1265,15 @@ const getNodeType = (scope, node) => {
     }
 
     if (node.type === 'AssignmentExpression') {
-      return getNodeType(scope, node.right);
+      const op = node.operator.slice(0, -1) || '=';
+      if (op === '=') return getNodeType(scope, node.right);
+
+      return getNodeType(scope, {
+        type: ['||', '&&', '??'].includes(op) ? 'LogicalExpression' : 'BinaryExpression',
+        left: node.left,
+        right: node.right,
+        operator: op
+      });
     }
 
     if (node.type === 'ArrayExpression') {
@@ -1345,23 +1292,6 @@ const getNodeType = (scope, node) => {
       if (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring) return TYPES.bytestring;
 
       return TYPES.number;
-
-      // todo: string concat types
-      // if (node.operator !== '+') return TYPES.number;
-      //   else return [
-      //     // if left is string
-      //     ...getNodeType(scope, node.left),
-      //     ...number(TYPES.string, Valtype.i32),
-      //     [ Opcodes.i32_eq ],
-
-      //     // if right is string
-      //     ...getNodeType(scope, node.right),
-      //     ...number(TYPES.string, Valtype.i32),
-      //     [ Opcodes.i32_eq ],
-
-      //     // if either are true
-      //     [ Opcodes.i32_or ],
-      //   ];
     }
 
     if (node.type === 'UnaryExpression') {
@@ -1381,7 +1311,6 @@ const getNodeType = (scope, node) => {
         if (Prefs.fastLength) return TYPES.number;
       }
 
-
       const objectKnownType = knownType(scope, getNodeType(scope, node.object));
       if (objectKnownType != null) {
         if (name === 'length') {
@@ -1392,7 +1321,6 @@ const getNodeType = (scope, node) => {
         if (node.computed) {
           if (objectKnownType === TYPES.string) return TYPES.string;
           if (objectKnownType === TYPES.bytestring) return TYPES.bytestring;
-          if (objectKnownType === TYPES.array) return TYPES.number;
         }
       }
 
@@ -1458,10 +1386,10 @@ 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.i32_load8_u, Opcodes.i32_load8_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] < 0x04)) {}
         else if ([Opcodes.local_get, Opcodes.global_get, Opcodes.f64_const, Opcodes.i32_const, Opcodes.i64_const, Opcodes.v128_const, Opcodes.memory_size].includes(inst[0])) count++;
         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.memory_copy[0] && (inst[1] === Opcodes.memory_copy[1] || inst[1] === Opcodes.memory_init[1])) count -= 3;
         else if (inst[0] === Opcodes.return) count = 0;
         else if (inst[0] === Opcodes.call) {
           let func = funcs.find(x => x.index === inst[1]);
@@ -1733,7 +1661,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, protoLocal2, (length, itemType) => {
           return makeArray(scope, {
             rawElements: new Array(length)
-          }, _global, _name, true, itemType);
+          }, _global, _name, true, itemType, true);
         }, () => {
           optUnused = true;
           return unusedValue;
@@ -1815,7 +1743,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       f64_store: { imms: 2, args: [ true, false ], returns: 0 },
 
       // value
-      i32_const: { imms: 1, args: [], returns: 1 },
+      i32_const: { imms: 1, args: [], returns: 0 },
     };
 
     const opName = name.slice('__Porffor_wasm_'.length);
@@ -1900,7 +1828,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       if (indirectMode === 'strict') {
         return typeSwitch(scope, getNodeType(scope, decl.callee), {
           [TYPES.function]: [
-            ...argWasm,
+            ...out,
             [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
             Opcodes.i32_to_u,
             [ Opcodes.call_indirect, args.length, 0 ],
@@ -1978,7 +1906,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   const func = funcs[idx - importedFuncs.length]; // idx === scope.index ? scope : funcs.find(x => x.index === idx);
   const userFunc = func && !func.internal;
   const typedParams = userFunc || builtinFuncs[name]?.typedParams;
-  const typedReturns = (func && func.returnType == null) || builtinFuncs[name]?.typedReturns;
+  const typedReturns = (userFunc && func.returnType == null) || builtinFuncs[name]?.typedReturns;
   const paramCount = func && (typedParams ? func.params.length / 2 : func.params.length);
 
   let args = decl.arguments;
@@ -2006,13 +1934,18 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       continue;
     }
 
-    if (valtypeBinary !== Valtype.i32 && (
-      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
-      (importedFuncs[name] && name.startsWith('profile'))
-    )) {
+    if (valtypeBinary !== Valtype.i32 &&
+      (func && func.params[i * (typedParams ? 2 : 1)] === Valtype.i32)
+    ) {
       out.push(Opcodes.i32_to);
     }
 
+    if (valtypeBinary === Valtype.i32 &&
+      (func && func.params[i * (typedParams ? 2 : 1)] === Valtype.f64)
+    ) {
+      out.push([ Opcodes.f64_convert_i32_s ]);
+    }
+
     if (typedParams) out = out.concat(getNodeType(scope, arg));
   }
 
@@ -2034,6 +1967,10 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     out.push(Opcodes.i32_from);
   }
 
+  if (builtinFuncs[name] && builtinFuncs[name].returns?.[0] === Valtype.f64 && valtypeBinary === Valtype.i32) {
+    out.push(Opcodes.i32_trunc_sat_f64_s);
+  }
+
   return out;
 };
 
@@ -2057,9 +1994,9 @@ const generateNew = (scope, decl, _global, _name) => {
   if (
     (builtinFuncs[name] && !builtinFuncs[name].constr) ||
     (internalConstrs[name] && builtinFuncs[name].notConstr)
-  ) return internalThrow(scope, 'TypeError', `${name} is not a constructor`);
+  ) return internalThrow(scope, 'TypeError', `${name} is not a constructor`, true);
 
-  if (!builtinFuncs[name]) return todo(scope, `new statement is not supported yet`); // return todo(scope, `new statement is not supported yet (new ${unhackName(name)})`);
+  if (!builtinFuncs[name]) return todo(scope, `new statement is not supported yet`, true); // return todo(scope, `new statement is not supported yet (new ${unhackName(name)})`);
 
   return generateCall(scope, decl, _global, _name);
 };
@@ -2123,7 +2060,6 @@ 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 ]);
   }
@@ -2157,10 +2093,8 @@ const brTable = (input, bc, returns) => {
     [ Opcodes.br_table, ...encodeVector(table), 0 ]
   );
 
-  // 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
+  // sort the wrong way and then reverse
+  // so strings ('default') are at the start before any numbers
   const orderedBc = keys.sort((a, b) => b - a).reverse();
 
   br = count - 1;
@@ -2186,10 +2120,10 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
     return bc[known] ?? bc.default;
   }
 
-  if (Prefs.typeswitchUseBrtable)
+  if (Prefs.typeswitchBrtable)
     return brTable(type, bc, returns);
 
-  const tmp = localTmp(scope, '#typeswitch_tmp', Valtype.i32);
+  const tmp = localTmp(scope, '#typeswitch_tmp' + (Prefs.typeswitchUniqueTmp ? randId() : ''), Valtype.i32);
   const out = [
     ...type,
     [ Opcodes.local_set, tmp ],
@@ -2241,11 +2175,11 @@ const allocVar = (scope, name, global = false, type = true) => {
     return target[name].idx;
   }
 
-  let idx = global ? globalInd++ : scope.localInd++;
+  let idx = global ? globals['#ind']++ : scope.localInd++;
   target[name] = { idx, type: valtypeBinary };
 
   if (type) {
-    let typeIdx = global ? globalInd++ : scope.localInd++;
+    let typeIdx = global ? globals['#ind']++ : scope.localInd++;
     target[name + '#type'] = { idx: typeIdx, type: Valtype.i32, name };
   }
 
@@ -2338,24 +2272,10 @@ const generateVar = (scope, decl) => {
     }
 
     if (x.init) {
-      // if (isFuncType(x.init.type)) {
-      //   // let a = function () { ... }
-      //   x.init.id = { name };
-
-      //   const func = generateFunc(scope, x.init);
-
-      //   out.push(
-      //     ...number(func.index - importedFuncs.length),
-      //     [ global ? Opcodes.global_set : Opcodes.local_set, idx ],
-
-      //     ...setType(scope, name, TYPES.function)
-      //   );
-
-      //   continue;
-      // }
+      const alreadyArray = scope.arrays?.get(name) != null;
 
       const generated = generate(scope, x.init, global, name);
-      if (scope.arrays?.get(name) != null) {
+      if (!alreadyArray && scope.arrays?.get(name) != null) {
         // hack to set local as pointer before
         out.push(...number(scope.arrays.get(name)), [ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
         if (generated.at(-1) == Opcodes.i32_from_u) generated.pop();
@@ -2407,19 +2327,12 @@ 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 [
-      ...(aotPointer ? number(0, Valtype.i32) : [
-        ...generate(scope, decl.left.object),
-        Opcodes.i32_to_u
-      ]),
+      ...generate(scope, decl.left.object),
+      Opcodes.i32_to_u,
       ...(!pointerTmp ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
       ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
@@ -2430,7 +2343,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, ...unsignedLEB128(aotPointer ? pointer : 0) ],
+      [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ],
 
       [ Opcodes.local_get, newValueTmp ]
     ];
@@ -2438,21 +2351,14 @@ 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]: [
-          ...(aotPointer ? [] : [
-            ...generate(scope, decl.left.object),
-            Opcodes.i32_to_u
-          ]),
+          ...generate(scope, decl.left.object),
+          Opcodes.i32_to_u,
 
           // get index as valtype
           ...generate(scope, decl.left.property),
@@ -2461,39 +2367,22 @@ 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 ],
-          ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
+          [ Opcodes.i32_add ],
           ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
           ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
             [ Opcodes.local_get, pointerTmp ],
-            [ Opcodes.load, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+            [ Opcodes.load, 0, ValtypeSize.i32 ]
           ], generate(scope, decl.right), [
             [ Opcodes.local_get, pointerTmp ],
-            [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
+            [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
           ], getNodeType(scope, decl.right), false, name, true)),
           [ Opcodes.local_tee, newValueTmp ],
 
-          [ Opcodes.store, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+          [ Opcodes.store, 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 ]
@@ -2555,9 +2444,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
     [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
     [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
 
-    // todo: string concat types
-
-    ...setType(scope, name, TYPES.number)
+    ...setType(scope, name, getNodeType(scope, decl))
   ];
 };
 
@@ -2571,7 +2458,7 @@ const generateUnary = (scope, decl) => {
       // * -1
 
       if (decl.prefix && decl.argument.type === 'Literal' && typeof decl.argument.value === 'number') {
-        // if -<N>, just return that
+        // if -n, just return that as a const
         return number(-1 * decl.argument.value);
       }
 
@@ -2583,14 +2470,14 @@ const generateUnary = (scope, decl) => {
     case '!':
       const arg = decl.argument;
       if (arg.type === 'UnaryExpression' && arg.operator === '!') {
-        // !!x -> is x truthy
+        // opt: !!x -> is x truthy
         return truthy(scope, generate(scope, arg.argument), getNodeType(scope, arg.argument), false, false);
       }
+
       // !=
-      return falsy(scope, generate(scope, decl.argument), getNodeType(scope, decl.argument), false, false);
+      return falsy(scope, generate(scope, arg), getNodeType(scope, arg), false, false);
 
     case '~':
-      // todo: does not handle Infinity properly (should convert to 0) (but opt const converting saves us sometimes)
       return [
         ...generate(scope, decl.argument),
         Opcodes.i32_to,
@@ -2877,12 +2764,12 @@ 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;
+  let newOut = number(0, Valtype.i32), newPointer = number(0, Valtype.i32);
   if (pages.hasAnyString) {
     // todo: we use i16 even for bytestrings which should not make a bad thing happen, just be confusing for debugging?
     0, [ newOut, newPointer ] = makeArray(scope, {
-      rawElements: new Array(1)
-    }, isGlobal, leftName, true, 'i16');
+      rawElements: new Array(0)
+    }, isGlobal, leftName, true, 'i16', true);
   }
 
   // set type for local
@@ -2929,23 +2816,28 @@ const generateForOf = (scope, decl) => {
     [TYPES.string]: [
       ...setType(scope, leftName, TYPES.string),
 
-      [ Opcodes.loop, Blocktype.void ],
-
       // setup new/out array
       ...newOut,
-      [ Opcodes.drop ],
 
-      ...number(0, Valtype.i32), // base 0 for store after
+      // set length to 1
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_store, 0, 0 ],
+
+      [ Opcodes.loop, Blocktype.void ],
+
+      // use as pointer for store later
+      ...newPointer,
 
       // load current string ind {arg}
       [ Opcodes.local_get, pointer ],
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
       // store to new string ind 0
-      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
       // return new string (page)
-      ...number(newPointer),
+      ...newPointer,
+      Opcodes.i32_from_u,
 
       [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
 
@@ -2977,25 +2869,30 @@ const generateForOf = (scope, decl) => {
     [TYPES.bytestring]: [
       ...setType(scope, leftName, TYPES.bytestring),
 
-      [ Opcodes.loop, Blocktype.void ],
-
       // setup new/out array
       ...newOut,
-      [ Opcodes.drop ],
 
-      ...number(0, Valtype.i32), // base 0 for store after
+      // set length to 1
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_store, 0, 0 ],
+
+      [ Opcodes.loop, Blocktype.void ],
+
+      // use as pointer for store later
+      ...newPointer,
 
       // load current string ind {arg}
       [ Opcodes.local_get, pointer ],
       [ Opcodes.local_get, counter ],
       [ Opcodes.i32_add ],
-      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
 
       // store to new string ind 0
-      [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+      [ Opcodes.i32_store8, 0, ValtypeSize.i32 ],
 
       // return new string (page)
-      ...number(newPointer),
+      ...newPointer,
+      Opcodes.i32_from_u,
 
       [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
 
@@ -3134,32 +3031,46 @@ const generateLabel = (scope, decl) => {
 const generateThrow = (scope, decl) => {
   scope.throws = true;
 
-  let message = decl.argument.value, constructor = null;
+  const exceptionMode = Prefs.exceptionMode ?? 'lut';
+  if (exceptionMode === 'lut') {
+    let message = decl.argument.value, constructor = null;
 
-  // hack: throw new X("...") -> throw "..."
-  if (!message && (decl.argument.type === 'NewExpression' || decl.argument.type === 'CallExpression')) {
-    constructor = decl.argument.callee.name;
-    message = decl.argument.arguments[0]?.value ?? '';
-  }
+    // support `throw (new)? Error(...)`
+    if (!message && (decl.argument.type === 'NewExpression' || decl.argument.type === 'CallExpression')) {
+      constructor = decl.argument.callee.name;
+      message = decl.argument.arguments[0]?.value ?? '';
+    }
 
-  if (tags.length === 0) tags.push({
-    params: [ Valtype.i32 ],
-    results: [],
-    idx: tags.length
-  });
+    if (tags.length === 0) tags.push({
+      params: [ Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
 
-  let exceptId = exceptions.push({ constructor, message }) - 1;
-  let tagIdx = tags[0].idx;
+    let exceptId = exceptions.push({ constructor, message }) - 1;
 
-  scope.exceptions ??= [];
-  scope.exceptions.push(exceptId);
+    scope.exceptions ??= [];
+    scope.exceptions.push(exceptId);
 
-  // todo: write a description of how this works lol
+    return [
+      [ Opcodes.i32_const, signedLEB128(exceptId) ],
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
 
-  return [
-    [ Opcodes.i32_const, signedLEB128(exceptId) ],
-    [ Opcodes.throw, tagIdx ]
-  ];
+  if (exceptionMode === 'stack') {
+    if (tags.length === 0) tags.push({
+      params: [ valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
+
+    return [
+      ...generate(scope, decl.argument),
+      ...getNodeType(scope, decl.argument),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
 };
 
 const generateTry = (scope, decl) => {
@@ -3210,18 +3121,6 @@ const allocPage = (scope, reason, 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 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;
 };
 
@@ -3259,39 +3158,58 @@ const compileBytes = (val, itemType) => {
   }
 };
 
-const getAllocType = itemType => {
-  switch (itemType) {
-    case 'i8': return 'bytestring';
-    case 'i16': return 'string';
+const makeData = (scope, elements, offset = null, itemType, initEmpty) => {
+  const length = elements.length;
+
+  // if length is 0 memory/data will just be 0000... anyway
+  if (length === 0) return false;
+
+  let bytes = compileBytes(length, 'i32');
+
+  if (!initEmpty) for (let i = 0; i < length; i++) {
+    if (elements[i] == null) continue;
 
-    default: return 'array';
+    bytes.push(...compileBytes(elements[i], itemType));
   }
-};
 
-const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false, itemType = valtype, typed = false) => {
-  const out = [];
+  const obj = { bytes };
+  if (offset != null) obj.offset = offset;
 
-  scope.arrays ??= new Map();
+  const idx = data.push(obj) - 1;
 
-  let firstAssign = false;
-  if (!scope.arrays.has(name) || name === '$undeclared') {
-    firstAssign = true;
+  scope.data ??= [];
+  scope.data.push(idx);
 
-    // 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;
+  return { idx, size: bytes.length };
+};
 
-    let page;
-    if (Prefs.scopedPageNames) page = allocPage(scope, `${getAllocType(itemType)}: ${scope.name}/${uniqueName}`, itemType);
-      else page = allocPage(scope, `${getAllocType(itemType)}: ${uniqueName}`, itemType);
+const printStaticStr = str => {
+  const out = [];
 
-    // hack: use 1 for page 0 pointer for fast truthiness
-    const ptr = page === 0 ? 1 : (page * pageSize);
-    scope.arrays.set(name, ptr);
+  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 ]
+    );
   }
 
-  const pointer = scope.arrays.get(name);
+  return out;
+};
+
+const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false, itemType = valtype, intOut = false, typed = false) => {
+  if (itemType !== 'i16' && itemType !== 'i8') {
+    pages.hasArray = true;
+  } else {
+    pages.hasAnyString = true;
+    if (itemType === 'i8') pages.hasByteString = true;
+      else pages.hasString = true;
+  }
+
+  const out = [];
 
-  const local = global ? globals[name] : scope.locals[name];
+  const uniqueName = name === '$undeclared' ? name + randId() : name;
 
   const useRawElements = !!decl.rawElements;
   const elements = useRawElements ? decl.rawElements : decl.elements;
@@ -3299,46 +3217,81 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   const valtype = itemTypeToValtype[itemType];
   const length = elements.length;
 
-  if (firstAssign && useRawElements && !Prefs.noData) {
-    // if length is 0 memory/data will just be 0000... anyway
-    if (length !== 0) {
-      let bytes = compileBytes(length, 'i32');
+  const allocated = allocator.alloc({ scope, pages, globals, asmFunc, funcIndex }, uniqueName, { itemType });
+
+  let pointer = allocated;
+  if (allocator.constructor.name !== 'StaticAllocator') {
+    // const tmp = localTmp(scope, '#makearray_pointer' + uniqueName, Valtype.i32);
+    const tmp = localTmp(scope, '#makearray_pointer' + name, Valtype.i32);
+    out.push(
+      ...allocated,
+      [ Opcodes.local_set, tmp ]
+    );
+
+    if (Prefs.runtimeAllocLog) out.push(
+      ...printStaticStr(`${name}: `),
+
+      [ Opcodes.local_get, tmp ],
+      Opcodes.i32_from_u,
+      [ Opcodes.call, 0 ],
+
+      ...number(10),
+      [ Opcodes.call, 1 ]
+    );
 
-      if (!initEmpty) for (let i = 0; i < length; i++) {
-        if (elements[i] == null) continue;
+    pointer = [ [ Opcodes.local_get, tmp ] ];
 
-        bytes.push(...compileBytes(elements[i], itemType));
+    if (Prefs.data && useRawElements) {
+      const data = makeData(scope, elements, null, itemType, initEmpty);
+      if (data) {
+        // init data
+        out.push(
+          ...pointer,
+          ...number(0, Valtype.i32),
+          ...number(data.size, Valtype.i32),
+          [ ...Opcodes.memory_init, ...unsignedLEB128(data.idx), 0 ]
+        );
       }
 
-      const ind = data.push({
-        offset: pointer,
-        bytes
-      }) - 1;
+      // return pointer in out
+      out.push(
+        ...pointer,
+        ...(!intOut ? [ Opcodes.i32_from_u ] : [])
+      );
 
-      scope.data ??= [];
-      scope.data.push(ind);
+      return [ out, pointer ];
     }
+  } else {
+    const rawPtr = read_signedLEB128(pointer[0].slice(1));
 
-    // local value as pointer
-    out.push(...number(pointer));
+    scope.arrays ??= new Map();
+    const firstAssign = !scope.arrays.has(uniqueName);
+    if (firstAssign) scope.arrays.set(uniqueName, rawPtr);
 
-    return [ out, pointer ];
-  }
+    if (Prefs.data && firstAssign && useRawElements) {
+      makeData(scope, elements, rawPtr, itemType, initEmpty);
 
-  const pointerTmp = local != null ? localTmp(scope, '#makearray_pointer_tmp', Valtype.i32) : null;
-  if (pointerTmp != null) {
-    out.push(
-      [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
-      Opcodes.i32_to_u,
-      [ Opcodes.local_set, pointerTmp ]
-    );
+      // local value as pointer
+      return [ number(rawPtr, intOut ? Valtype.i32 : valtypeBinary), pointer ];
+    }
+
+    const local = global ? globals[name] : scope.locals[name];
+    const pointerTmp = local != null ? localTmp(scope, '#makearray_pointer_tmp', Valtype.i32) : null;
+    if (pointerTmp != null) {
+      out.push(
+        [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+        Opcodes.i32_to_u,
+        [ Opcodes.local_set, pointerTmp ]
+      );
+
+      pointer = [ [ Opcodes.local_get, pointerTmp ] ];
+    }
   }
 
-  const pointerWasm = pointerTmp != null ? [ [ Opcodes.local_get, pointerTmp ] ] : number(pointer, Valtype.i32);
 
   // store length
   out.push(
-    ...pointerWasm,
+    ...pointer,
     ...number(length, Valtype.i32),
     [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ]
   );
@@ -3350,11 +3303,11 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
 
     const offset = ValtypeSize.i32 + i * sizePerEl;
     out.push(
-      ...pointerWasm,
+      ...pointer,
       ...(useRawElements ? number(elements[i], Valtype[valtype]) : generate(scope, elements[i])),
       [ storeOp, 0, ...unsignedLEB128(offset) ],
       ...(!typed ? [] : [ // typed presumes !useRawElements
-        ...pointerWasm,
+        ...pointer,
         ...getNodeType(scope, elements[i]),
         [ Opcodes.i32_store8, 0, ...unsignedLEB128(offset + ValtypeSize[itemType]) ]
       ])
@@ -3362,12 +3315,13 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   }
 
   // local value as pointer
-  out.push(...pointerWasm, Opcodes.i32_from_u);
+  out.push(...pointer);
+  if (!intOut) out.push(Opcodes.i32_from_u);
 
   return [ out, pointer ];
 };
 
-const storeArray = (scope, array, index, element, aotPointer = null) => {
+const storeArray = (scope, array, index, element) => {
   if (!Array.isArray(element)) element = generate(scope, element);
   if (typeof index === 'number') index = number(index);
 
@@ -3379,26 +3333,25 @@ const storeArray = (scope, array, index, element, aotPointer = null) => {
     Opcodes.i32_to_u,
     ...number(ValtypeSize[valtype] + 1, Valtype.i32),
     [ Opcodes.i32_mul ],
-    ...(aotPointer ? [] : [
-      ...array,
-      Opcodes.i32_to_u,
-      [ Opcodes.i32_add ],
-    ]),
+
+    ...array,
+    Opcodes.i32_to_u,
+    [ Opcodes.i32_add ],
     [ Opcodes.local_set, offset ],
 
     // store value
     [ Opcodes.local_get, offset ],
     ...generate(scope, element),
-    [ Opcodes.store, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
+    [ Opcodes.store, 0, ValtypeSize.i32 ],
 
     // store type
     [ Opcodes.local_get, offset ],
     ...getNodeType(scope, element),
-    [ Opcodes.i32_store8, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
+    [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
   ];
 };
 
-const loadArray = (scope, array, index, aotPointer = null) => {
+const loadArray = (scope, array, index) => {
   if (typeof index === 'number') index = number(index);
 
   const offset = localTmp(scope, '#loadArray_offset', Valtype.i32);
@@ -3409,20 +3362,19 @@ const loadArray = (scope, array, index, aotPointer = null) => {
     Opcodes.i32_to_u,
     ...number(ValtypeSize[valtype] + 1, Valtype.i32),
     [ Opcodes.i32_mul ],
-    ...(aotPointer ? [] : [
-      ...array,
-      Opcodes.i32_to_u,
-      [ Opcodes.i32_add ],
-    ]),
+
+    ...array,
+    Opcodes.i32_to_u,
+    [ Opcodes.i32_add ],
     [ Opcodes.local_set, offset ],
 
     // load value
     [ Opcodes.local_get, offset ],
-    [ Opcodes.load, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
+    [ Opcodes.load, 0, ValtypeSize.i32 ],
 
     // load type
     [ Opcodes.local_get, offset ],
-    [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
+    [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
   ];
 };
 
@@ -3454,7 +3406,7 @@ const makeString = (scope, str, global = false, name = '$undeclared', forceBytes
 };
 
 const generateArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false) => {
-  return makeArray(scope, decl, global, name, initEmpty, valtype, true)[0];
+  return makeArray(scope, decl, global, name, initEmpty, valtype, false, true)[0];
 };
 
 const generateObject = (scope, decl, global = false, name = '$undeclared') => {
@@ -3473,9 +3425,6 @@ 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') {
@@ -3510,18 +3459,16 @@ const generateMember = (scope, decl, _global, _name) => {
     }
 
     if (builtinFuncs[name]) return withType(scope, number(builtinFuncs[name].typedParams ? (builtinFuncs[name].params.length / 2) : builtinFuncs[name].params.length), TYPES.number);
-    if (importedFuncs[name]) return withType(scope, number(importedFuncs[name].params), TYPES.number);
+    if (importedFuncs[name]) return withType(scope, number(importedFuncs[name].params.length ?? importedFuncs[name].params), TYPES.number);
     if (internalConstrs[name]) return withType(scope, number(internalConstrs[name].length ?? 0), TYPES.number);
 
     if (Prefs.fastLength) {
       // presume valid length object
       return [
-        ...(aotPointer ? number(0, Valtype.i32) : [
-          ...generate(scope, decl.object),
-          Opcodes.i32_to_u
-        ]),
+        ...generate(scope, decl.object),
+        Opcodes.i32_to_u,
 
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
         Opcodes.i32_from_u
       ];
     }
@@ -3530,12 +3477,10 @@ const generateMember = (scope, decl, _global, _name) => {
     const known = knownType(scope, type);
     if (known != null) {
       if ([ TYPES.string, TYPES.bytestring, TYPES.array ].includes(known)) return [
-        ...(aotPointer ? number(0, Valtype.i32) : [
-          ...generate(scope, decl.object),
-          Opcodes.i32_to_u
-        ]),
+        ...generate(scope, decl.object),
+        Opcodes.i32_to_u,
 
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
         Opcodes.i32_from_u
       ];
 
@@ -3545,12 +3490,10 @@ const generateMember = (scope, decl, _global, _name) => {
     return [
       ...typeIsOneOf(getNodeType(scope, decl.object), [ TYPES.string, TYPES.bytestring, TYPES.array ]),
       [ Opcodes.if, valtypeBinary ],
-        ...(aotPointer ? number(0, Valtype.i32) : [
-          ...generate(scope, decl.object),
-          Opcodes.i32_to_u
-        ]),
+        ...generate(scope, decl.object),
+        Opcodes.i32_to_u,
 
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
         Opcodes.i32_from_u,
 
         ...setLastType(scope, TYPES.number),
@@ -3593,25 +3536,29 @@ const generateMember = (scope, decl, _global, _name) => {
 
   // // 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.hasAnyString) {
+  let newOut = number(0, Valtype.i32), newPointer = number(0, Valtype.i32);
+  if (pages.hasAnyString && knownType(scope, getNodeType(scope, decl.object)) !== TYPES.array) {
+    // todo: we use i16 even for bytestrings which should not make a bad thing happen, just be confusing for debugging?
     0, [ newOut, newPointer ] = makeArray(scope, {
-      rawElements: new Array(1)
-    }, _global, _name, true, 'i16');
+      rawElements: new Array(0)
+    }, _global, _name, true, 'i16', true);
   }
 
   return typeSwitch(scope, getNodeType(scope, decl.object), {
     [TYPES.array]: [
-      ...loadArray(scope, object, property, aotPointer),
+      ...loadArray(scope, object, property),
       ...setLastType(scope)
     ],
-
     [TYPES.string]: [
       // setup new/out array
       ...newOut,
-      [ Opcodes.drop ],
 
-      ...number(0, Valtype.i32), // base 0 for store later
+      // set length to 1
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_store, 0, 0 ],
+
+      // use as pointer for store later
+      ...newPointer,
 
       ...property,
       Opcodes.i32_to_u,
@@ -3619,46 +3566,48 @@ const generateMember = (scope, decl, _global, _name) => {
       ...number(ValtypeSize.i16, Valtype.i32),
       [ Opcodes.i32_mul ],
 
-      ...(aotPointer ? [] : [
-        ...object,
-        Opcodes.i32_to_u,
-        [ Opcodes.i32_add ]
-      ]),
+      ...object,
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_add ],
 
       // load current string ind {arg}
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
       // store to new string ind 0
-      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
       // return new string (page)
-      ...number(newPointer),
+      ...newPointer,
+      Opcodes.i32_from_u,
       ...setLastType(scope, TYPES.string)
     ],
     [TYPES.bytestring]: [
       // setup new/out array
       ...newOut,
-      [ Opcodes.drop ],
 
-      ...number(0, Valtype.i32), // base 0 for store later
+      // set length to 1
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_store, 0, 0 ],
+
+      // use as pointer for store later
+      ...newPointer,
 
       ...property,
       Opcodes.i32_to_u,
 
-      ...(aotPointer ? [] : [
-        ...object,
-        Opcodes.i32_to_u,
-        [ Opcodes.i32_add ]
-      ]),
+      ...object,
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_add ],
 
       // load current string ind {arg}
-      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
+      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
 
       // store to new string ind 0
-      [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+      [ Opcodes.i32_store8, 0, ValtypeSize.i32 ],
 
       // return new string (page)
-      ...number(newPointer),
+      ...newPointer,
+      Opcodes.i32_from_u,
       ...setLastType(scope, TYPES.bytestring)
     ],
 
@@ -3666,7 +3615,7 @@ const generateMember = (scope, decl, _global, _name) => {
   });
 };
 
-const randId = () => Math.random().toString(16).slice(0, -4);
+const randId = () => Math.random().toString(16).slice(1, -2).padEnd(12, '0');
 
 const objectHack = node => {
   if (!node) return node;
@@ -3718,7 +3667,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 !!!
@@ -3732,6 +3681,9 @@ const generateFunc = (scope, decl) => {
     index: currentFuncIndex++
   };
 
+  funcIndex[name] = func.index;
+  funcs.push(func);
+
   if (typedInput && decl.returnType) {
     const { type } = extractTypeAnnotation(decl.returnType);
     // if (type != null && !Prefs.indirectCalls) {
@@ -3741,12 +3693,26 @@ const generateFunc = (scope, decl) => {
     }
   }
 
+  const defaultValues = {};
   for (let i = 0; i < params.length; i++) {
-    const name = params[i].name;
+    let name;
+    const x = params[i];
+    switch (x.type) {
+      case 'Identifier': {
+        name = x.name;
+        break;
+      }
+
+      case 'AssignmentPattern': {
+        name = x.left.name;
+        defaultValues[name] = x.right;
+        break;
+      }
+    }
+
     // if (name == null) return todo('non-identifier args are not supported');
 
     allocVar(func, name, false);
-
     if (typedInput && params[i].typeAnnotation) {
       addVarMetadata(func, name, false, extractTypeAnnotation(params[i]));
     }
@@ -3763,11 +3729,22 @@ const generateFunc = (scope, decl) => {
     };
   }
 
-  funcIndex[name] = func.index;
-  funcs.push(func);
+  const prelude = [];
+  for (const x in defaultValues) {
+    prelude.push(
+      ...getType(func, x),
+      ...number(TYPES.undefined, Valtype.i32),
+      [ Opcodes.i32_eq ],
+      [ Opcodes.if, Blocktype.void ],
+        ...generate(func, defaultValues[x], false, x),
+        [ Opcodes.local_set, func.locals[x].idx ],
 
-  const wasm = generate(func, body);
-  func.wasm = wasm;
+        ...setType(func, x, getNodeType(scope, defaultValues[x])),
+      [ Opcodes.end ]
+    );
+  }
+
+  const wasm = func.wasm = prelude.concat(generate(func, body));
 
   if (name === 'main') func.gotLastType = true;
 
@@ -3803,9 +3780,9 @@ const internalConstrs = {
 
       // new Array(n)
 
-      const [ , pointer ] = makeArray(scope, {
+      const [ out, pointer ] = makeArray(scope, {
         rawElements: new Array(0)
-      }, global, name, true);
+      }, global, name, true, undefined, true);
 
       const arg = decl.arguments[0] ?? DEFAULT_VALUE;
 
@@ -3814,12 +3791,13 @@ const internalConstrs = {
       if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeThrow', 'Invalid array length', true);
 
       return [
-        ...number(0, Valtype.i32),
+        ...out,
         ...generate(scope, arg, global, name),
         Opcodes.i32_to_u,
-        [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ],
+        [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ],
 
-        ...number(pointer)
+        ...pointer,
+        Opcodes.i32_from_u
       ];
     },
     type: TYPES.array,
@@ -3968,8 +3946,9 @@ const internalConstrs = {
 };
 
 export default program => {
-  globals = {};
-  globalInd = 0;
+  globals = {
+    ['#ind']: 0
+  };
   tags = [];
   exceptions = [];
   funcs = [];
@@ -3979,19 +3958,8 @@ export default program => {
   data = [];
   currentFuncIndex = importedFuncs.length;
 
-  globalThis.valtype = 'f64';
-
-  const valtypeOpt = process.argv.find(x => x.startsWith('--valtype='));
-  if (valtypeOpt) valtype = valtypeOpt.split('=')[1];
-
-  globalThis.valtypeBinary = Valtype[valtype];
-
   const valtypeInd = ['i32', 'i64', 'f64'].indexOf(valtype);
 
-  globalThis.pageSize = PageSize;
-  const pageSizeOpt = process.argv.find(x => x.startsWith('--page-size='));
-  if (pageSizeOpt) pageSize = parseInt(pageSizeOpt.split('=')[1]) * 1024;
-
   // set generic opcodes for current valtype
   Opcodes.const = [ Opcodes.i32_const, Opcodes.i64_const, Opcodes.f64_const ][valtypeInd];
   Opcodes.eq = [ Opcodes.i32_eq, Opcodes.i64_eq, Opcodes.f64_eq ][valtypeInd];
@@ -4013,6 +3981,7 @@ export default program => {
   builtinFuncs = new BuiltinFuncs();
   builtinVars = new BuiltinVars();
   prototypeFuncs = new PrototypeFuncs();
+  allocator = makeAllocator(Prefs.allocator ?? 'static');
 
   program.id = { name: 'main' };
 
@@ -4055,6 +4024,8 @@ export default program => {
       else main.returns = [];
   }
 
+  delete globals['#ind'];
+
   // if blank main func and other exports, remove it
   if (main.wasm.length === 0 && funcs.reduce((acc, x) => acc + (x.export ? 1 : 0), 0) > 1) funcs.splice(main.index - importedFuncs.length, 1);