porffor 0.16.0-594397507 → 0.16.0-5c5338783

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`);
 
@@ -433,63 +423,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');
+  }, global, name, true, 'i16', true);
 
   return [
     // setup left
@@ -503,7 +442,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 +455,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 +474,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 +496,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 +613,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
@@ -1054,7 +998,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 +1012,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 +1022,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 +1035,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 +1050,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 +1202,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 +1218,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;
         }
       }
 
@@ -1458,10 +1398,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 +1673,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 +1755,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);
@@ -1978,7 +1918,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;
@@ -2007,8 +1947,8 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     }
 
     if (valtypeBinary !== Valtype.i32 && (
-      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
-      (importedFuncs[name] && name.startsWith('profile'))
+      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32)
+      // (importedFuncs[name] && name.startsWith('profile'))
     )) {
       out.push(Opcodes.i32_to);
     }
@@ -2123,7 +2063,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 +2096,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 +2123,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 +2178,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 +2275,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 +2330,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 +2346,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 +2354,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 +2370,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 ]
@@ -2571,7 +2463,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 +2475,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 +2769,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 +2821,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 +2874,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 ],
 
@@ -3210,18 +3112,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 +3149,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;
 
-    default: return 'array';
+  // 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;
+
+    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;
+
+  const idx = data.push(obj) - 1;
 
-  scope.arrays ??= new Map();
+  scope.data ??= [];
+  scope.data.push(idx);
 
-  let firstAssign = false;
-  if (!scope.arrays.has(name) || name === '$undeclared') {
-    firstAssign = true;
+  return { idx, size: bytes.length };
+};
+
+const printStaticStr = str => {
+  const out = [];
 
-    // 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;
+  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 ]
+    );
+  }
 
-    let page;
-    if (Prefs.scopedPageNames) page = allocPage(scope, `${getAllocType(itemType)}: ${scope.name}/${uniqueName}`, itemType);
-      else page = allocPage(scope, `${getAllocType(itemType)}: ${uniqueName}`, itemType);
+  return out;
+};
 
-    // hack: use 1 for page 0 pointer for fast truthiness
-    const ptr = page === 0 ? 1 : (page * pageSize);
-    scope.arrays.set(name, ptr);
+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 pointer = scope.arrays.get(name);
+  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 +3208,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}: `),
 
-      if (!initEmpty) for (let i = 0; i < length; i++) {
-        if (elements[i] == null) continue;
+      [ Opcodes.local_get, tmp ],
+      Opcodes.i32_from_u,
+      [ Opcodes.call, 0 ],
 
-        bytes.push(...compileBytes(elements[i], itemType));
+      ...number(10),
+      [ Opcodes.call, 1 ]
+    );
+
+    pointer = [ [ Opcodes.local_get, tmp ] ];
+
+    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 +3294,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 +3306,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 +3324,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 +3353,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 +3397,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 +3416,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 +3450,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 +3468,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 +3481,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 +3527,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;
+  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)
-    }, _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 +3557,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 +3606,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 +3658,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 !!!
@@ -3803,9 +3743,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 +3754,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 +3909,9 @@ const internalConstrs = {
 };
 
 export default program => {
-  globals = {};
-  globalInd = 0;
+  globals = {
+    ['#ind']: 0
+  };
   tags = [];
   exceptions = [];
   funcs = [];
@@ -3979,19 +3921,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 +3944,7 @@ export default program => {
   builtinFuncs = new BuiltinFuncs();
   builtinVars = new BuiltinVars();
   prototypeFuncs = new PrototypeFuncs();
+  allocator = makeAllocator(Prefs.allocator ?? 'static');
 
   program.id = { name: 'main' };
 
@@ -4055,6 +3987,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);