porffor 0.16.0-f9dde1759 → 0.16.0-fa3914030

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');
+  }, assign ? false : global, assign ? undefined : 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
@@ -1014,12 +958,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 +995,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 +1009,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);
   }
 
@@ -1091,9 +1032,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 +1047,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;
@@ -1318,7 +1263,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') {
@@ -1337,23 +1290,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') {
@@ -1373,7 +1309,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') {
@@ -1384,7 +1319,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;
         }
       }
 
@@ -1450,10 +1384,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]);
@@ -1725,7 +1659,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;
@@ -1998,13 +1932,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));
   }
 
@@ -2026,6 +1965,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;
 };
 
@@ -2049,9 +1992,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);
 };
@@ -2230,11 +2173,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 };
   }
 
@@ -2327,24 +2270,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();
@@ -2396,19 +2325,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, [
@@ -2419,7 +2341,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 ]
     ];
@@ -2427,21 +2349,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),
@@ -2450,39 +2365,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 ]
@@ -2544,9 +2442,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))
   ];
 };
 
@@ -2866,12 +2762,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
@@ -2918,23 +2814,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 ],
 
@@ -2966,25 +2867,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 ],
 
@@ -3199,18 +3105,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;
 };
 
@@ -3248,39 +3142,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;
 
-    default: return 'array';
+  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;
 
-  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 + randId() : 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 ]
+    );
+  }
+
+  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 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;
@@ -3288,46 +3201,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 ]
   );
@@ -3339,11 +3287,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]) ]
       ])
@@ -3351,12 +3299,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);
 
@@ -3368,26 +3317,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);
@@ -3398,20 +3346,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] ]
   ];
 };
 
@@ -3443,7 +3390,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') => {
@@ -3462,9 +3409,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') {
@@ -3505,12 +3449,10 @@ const generateMember = (scope, decl, _global, _name) => {
     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
       ];
     }
@@ -3519,12 +3461,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
       ];
 
@@ -3534,12 +3474,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),
@@ -3582,25 +3520,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,
@@ -3608,46 +3550,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)
     ],
 
@@ -3792,9 +3736,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;
 
@@ -3803,12 +3747,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,
@@ -3957,8 +3902,9 @@ const internalConstrs = {
 };
 
 export default program => {
-  globals = {};
-  globalInd = 0;
+  globals = {
+    ['#ind']: 0
+  };
   tags = [];
   exceptions = [];
   funcs = [];
@@ -3991,6 +3937,7 @@ export default program => {
   builtinFuncs = new BuiltinFuncs();
   builtinVars = new BuiltinVars();
   prototypeFuncs = new PrototypeFuncs();
+  allocator = makeAllocator(Prefs.allocator ?? 'static');
 
   program.id = { name: 'main' };
 
@@ -4033,6 +3980,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);