porffor 0.16.0-688a50c13 → 0.16.0-79cd8c0c8

package/compiler/codegen.js

@@ -1,5 +1,5 @@
-import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
-import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector, read_signedLEB128 } from './encoding.js';
+import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from './wasmSpec.js';
+import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from './encoding.js';
 import { operatorOpcode } from './expression.js';
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
 import { PrototypeFuncs } from './prototype.js';
@@ -9,16 +9,15 @@ import * as Rhemyn from '../rhemyn/compile.js';
 import parse from './parse.js';
 import { log } from './log.js';
 import Prefs from './prefs.js';
-import Allocator from './allocators/index.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) {
@@ -182,6 +181,12 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
               continue;
             }
 
+            if (asm[0] === 'memory') {
+              allocPage(scope, 'asm instrinsic');
+              // todo: add to store/load offset insts
+              continue;
+            }
+
             let inst = Opcodes[asm[0].replace('.', '_')];
             if (inst == null) throw new Error(`inline asm: inst ${asm[0]} not found`);
 
@@ -428,12 +433,63 @@ 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, {
     rawElements: new Array(0)
-  }, global, name, true, 'i16', true);
+  }, global, name, true, 'i16');
 
   return [
     // setup left
@@ -447,7 +503,7 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
     [ Opcodes.local_set, rightPointer ],
 
     // calculate length
-    ...pointer, // base 0 for store later
+    ...number(0, Valtype.i32), // base 0 for store later
 
     [ Opcodes.local_get, leftPointer ],
     [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
@@ -460,13 +516,11 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
     [ Opcodes.i32_add ],
 
     // store length
-    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ],
+    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ],
 
     // copy left
     // dst = out pointer + length size
-    ...pointer,
-    ...number(ValtypeSize.i32, Valtype.i32),
-    [ Opcodes.i32_add ],
+    ...number(pointer + ValtypeSize.i32, Valtype.i32),
 
     // src = left pointer + length size
     [ Opcodes.local_get, leftPointer ],
@@ -479,9 +533,7 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
 
     // copy right
     // dst = out pointer + length size + left length * sizeof valtype
-    ...pointer,
-    ...number(ValtypeSize.i32, Valtype.i32),
-    [ Opcodes.i32_add ],
+    ...number(pointer + ValtypeSize.i32, Valtype.i32),
 
     [ Opcodes.local_get, leftLength ],
     ...number(bytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
@@ -501,8 +553,7 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
     [ ...Opcodes.memory_copy, 0x00, 0x00 ],
 
     // return new string (page)
-    ...pointer,
-    Opcodes.i32_from_u
+    ...number(pointer)
   ];
 };
 
@@ -618,10 +669,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
@@ -1040,9 +1091,9 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
 
   let baseGlobalIdx, i = 0;
   for (const type of globalTypes) {
-    if (baseGlobalIdx === undefined) baseGlobalIdx = globals['#ind'];
+    if (baseGlobalIdx === undefined) baseGlobalIdx = globalInd;
 
-    globals[globalNames[i] ?? `${name}_global_${i}`] = { idx: globals['#ind']++, type, init: globalInits[i] ?? 0 };
+    globals[globalNames[i] ?? `${name}_global_${i}`] = { idx: globalInd++, type, init: globalInits[i] ?? 0 };
     i++;
   }
 
@@ -1055,15 +1106,11 @@ 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;
@@ -1678,7 +1725,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, true);
+          }, _global, _name, true, itemType);
         }, () => {
           optUnused = true;
           return unusedValue;
@@ -2068,6 +2115,7 @@ const brTable = (input, bc, returns) => {
   }
 
   for (let i = 0; i < count; i++) {
+    // if (i === 0) out.push([ Opcodes.block, returns, 'br table start' ]);
     if (i === 0) out.push([ Opcodes.block, returns ]);
       else out.push([ Opcodes.block, Blocktype.void ]);
   }
@@ -2101,8 +2149,10 @@ const brTable = (input, bc, returns) => {
     [ Opcodes.br_table, ...encodeVector(table), 0 ]
   );
 
-  // sort the wrong way and then reverse
-  // so strings ('default') are at the start before any numbers
+  // if you can guess why we sort the wrong way and then reverse
+  // (instead of just sorting the correct way)
+  // dm me and if you are correct and the first person
+  // I will somehow shout you out or something
   const orderedBc = keys.sort((a, b) => b - a).reverse();
 
   br = count - 1;
@@ -2128,7 +2178,7 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
     return bc[known] ?? bc.default;
   }
 
-  if (Prefs.typeswitchBrtable)
+  if (Prefs.typeswitchUseBrtable)
     return brTable(type, bc, returns);
 
   const tmp = localTmp(scope, '#typeswitch_tmp' + (Prefs.typeswitchUniqueTmp ? randId() : ''), Valtype.i32);
@@ -2183,11 +2233,11 @@ const allocVar = (scope, name, global = false, type = true) => {
     return target[name].idx;
   }
 
-  let idx = global ? globals['#ind']++ : scope.localInd++;
+  let idx = global ? globalInd++ : scope.localInd++;
   target[name] = { idx, type: valtypeBinary };
 
   if (type) {
-    let typeIdx = global ? globals['#ind']++ : scope.localInd++;
+    let typeIdx = global ? globalInd++ : scope.localInd++;
     target[name + '#type'] = { idx: typeIdx, type: Valtype.i32, name };
   }
 
@@ -2280,10 +2330,24 @@ const generateVar = (scope, decl) => {
     }
 
     if (x.init) {
-      const alreadyArray = scope.arrays?.get(name) != null;
+      // 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 generated = generate(scope, x.init, global, name);
-      if (!alreadyArray && scope.arrays?.get(name) != null) {
+      if (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();
@@ -2335,12 +2399,19 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
   // hack: .length setter
   if (decl.left.type === 'MemberExpression' && decl.left.property.name === 'length') {
+    const name = decl.left.object.name;
+    const pointer = scope.arrays?.get(name);
+
+    const aotPointer = Prefs.aotPointerOpt && pointer != null;
+
     const newValueTmp = localTmp(scope, '__length_setter_tmp');
     const pointerTmp = op === '=' ? null : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
 
     return [
-      ...generate(scope, decl.left.object),
-      Opcodes.i32_to_u,
+      ...(aotPointer ? number(0, Valtype.i32) : [
+        ...generate(scope, decl.left.object),
+        Opcodes.i32_to_u
+      ]),
       ...(!pointerTmp ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
       ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
@@ -2351,7 +2422,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
       [ Opcodes.local_tee, newValueTmp ],
 
       Opcodes.i32_to_u,
-      [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ],
+      [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
 
       [ Opcodes.local_get, newValueTmp ]
     ];
@@ -2359,14 +2430,21 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
   // arr[i]
   if (decl.left.type === 'MemberExpression' && decl.left.computed) {
+    const name = decl.left.object.name;
+    const pointer = scope.arrays?.get(name);
+
+    const aotPointer = Prefs.aotPointerOpt && pointer != null;
+
     const newValueTmp = localTmp(scope, '__member_setter_val_tmp');
     const pointerTmp = op === '=' ? -1 : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
 
     return [
       ...typeSwitch(scope, getNodeType(scope, decl.left.object), {
         [TYPES.array]: [
-          ...generate(scope, decl.left.object),
-          Opcodes.i32_to_u,
+          ...(aotPointer ? [] : [
+            ...generate(scope, decl.left.object),
+            Opcodes.i32_to_u
+          ]),
 
           // get index as valtype
           ...generate(scope, decl.left.property),
@@ -2375,22 +2453,39 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
           // turn into byte offset by * valtypeSize (4 for i32, 8 for i64/f64)
           ...number(ValtypeSize[valtype] + 1, Valtype.i32),
           [ Opcodes.i32_mul ],
-          [ Opcodes.i32_add ],
+          ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
           ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
           ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
             [ Opcodes.local_get, pointerTmp ],
-            [ Opcodes.load, 0, ValtypeSize.i32 ]
+            [ Opcodes.load, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
           ], generate(scope, decl.right), [
             [ Opcodes.local_get, pointerTmp ],
-            [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
+            [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
           ], getNodeType(scope, decl.right), false, name, true)),
           [ Opcodes.local_tee, newValueTmp ],
 
-          [ Opcodes.store, 0, ValtypeSize.i32 ]
+          [ Opcodes.store, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
         ],
 
         default: internalThrow(scope, 'TypeError', `Cannot assign member with non-array`)
+
+        // [TYPES.string]: [
+        //   // turn into byte offset by * sizeof i16
+        //   ...number(ValtypeSize.i16, Valtype.i32),
+        //   [ Opcodes.i32_mul ],
+        //   ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
+        //   ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+        //   ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+        //     [ Opcodes.local_get, pointerTmp ],
+        //     [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+        //   ], generate(scope, decl.right), number(TYPES.string, Valtype.i32), getNodeType(scope, decl.right))),
+        //   [ Opcodes.local_tee, newValueTmp ],
+
+        //   Opcodes.i32_to_u,
+        //   [ StoreOps.i16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+        // ]
       }, Blocktype.void),
 
       [ Opcodes.local_get, newValueTmp ]
@@ -2774,12 +2869,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.i32), newPointer = number(0, Valtype.i32);
+  let newOut = number(0, Valtype.f64), newPointer = -1;
   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(0)
-    }, isGlobal, leftName, true, 'i16', true);
+      rawElements: new Array(1)
+    }, isGlobal, leftName, true, 'i16');
   }
 
   // set type for local
@@ -2826,28 +2921,23 @@ const generateForOf = (scope, decl) => {
     [TYPES.string]: [
       ...setType(scope, leftName, TYPES.string),
 
+      [ Opcodes.loop, Blocktype.void ],
+
       // setup new/out array
       ...newOut,
+      [ Opcodes.drop ],
 
-      // set length to 1
-      ...number(1, Valtype.i32),
-      [ Opcodes.i32_store, 0, 0 ],
-
-      [ Opcodes.loop, Blocktype.void ],
-
-      // use as pointer for store later
-      ...newPointer,
+      ...number(0, Valtype.i32), // base 0 for store after
 
       // load current string ind {arg}
       [ Opcodes.local_get, pointer ],
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
 
       // store to new string ind 0
-      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
 
       // return new string (page)
-      ...newPointer,
-      Opcodes.i32_from_u,
+      ...number(newPointer),
 
       [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
 
@@ -2879,30 +2969,25 @@ const generateForOf = (scope, decl) => {
     [TYPES.bytestring]: [
       ...setType(scope, leftName, TYPES.bytestring),
 
+      [ Opcodes.loop, Blocktype.void ],
+
       // setup new/out array
       ...newOut,
+      [ Opcodes.drop ],
 
-      // set length to 1
-      ...number(1, Valtype.i32),
-      [ Opcodes.i32_store, 0, 0 ],
-
-      [ Opcodes.loop, Blocktype.void ],
-
-      // use as pointer for store later
-      ...newPointer,
+      ...number(0, Valtype.i32), // base 0 for store after
 
       // load current string ind {arg}
       [ Opcodes.local_get, pointer ],
       [ Opcodes.local_get, counter ],
       [ Opcodes.i32_add ],
-      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
 
       // store to new string ind 0
-      [ Opcodes.i32_store8, 0, ValtypeSize.i32 ],
+      [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
 
       // return new string (page)
-      ...newPointer,
-      Opcodes.i32_from_u,
+      ...number(newPointer),
 
       [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
 
@@ -3122,6 +3207,16 @@ const allocPage = (scope, reason, type) => {
   return ind;
 };
 
+// todo: add scope.pages
+const freePage = reason => {
+  const { ind } = pages.get(reason);
+  pages.delete(reason);
+
+  if (Prefs.allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
+
+  return ind;
+};
+
 const itemTypeToValtype = {
   i32: 'i32',
   i64: 'i64',
@@ -3156,84 +3251,86 @@ const compileBytes = (val, itemType) => {
   }
 };
 
-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 getAllocType = itemType => {
+  switch (itemType) {
+    case 'i8': return 'bytestring';
+    case 'i16': return 'string';
+
+    default: return 'array';
   }
+};
 
+const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false, itemType = valtype, typed = false) => {
   const out = [];
 
-  const uniqueName = name === '$undeclared' ? name + randId() : name;
+  scope.arrays ??= new Map();
 
-  const useRawElements = !!decl.rawElements;
-  const elements = useRawElements ? decl.rawElements : decl.elements;
+  let firstAssign = false;
+  if (!scope.arrays.has(name) || name === '$undeclared') {
+    firstAssign = true;
 
-  const valtype = itemTypeToValtype[itemType];
-  const length = elements.length;
+    // todo: can we just have 1 undeclared array? probably not? but this is not really memory efficient
+    const uniqueName = name === '$undeclared' ? name + randId() : name;
 
-  const allocated = allocator.alloc({ scope, pages, globals }, uniqueName, { itemType });
+    let page;
+    if (Prefs.scopedPageNames) page = allocPage(scope, `${getAllocType(itemType)}: ${scope.name}/${uniqueName}`, itemType);
+      else page = allocPage(scope, `${getAllocType(itemType)}: ${uniqueName}`, itemType);
 
-  let pointer = allocated;
-  if (allocator.constructor.name !== 'StaticAllocator') {
-    const tmp = localTmp(scope, '#makearray_pointer' + uniqueName, Valtype.i32);
-    out.push(
-      ...allocated,
-      [ Opcodes.local_set, tmp ]
-    );
+    // hack: use 1 for page 0 pointer for fast truthiness
+    const ptr = page === 0 ? 1 : (page * pageSize);
+    scope.arrays.set(name, ptr);
+  }
 
-    pointer = [ [ Opcodes.local_get, tmp ] ];
-  } else {
-    const rawPtr = read_signedLEB128(pointer[0].slice(1));
+  const pointer = scope.arrays.get(name);
 
-    scope.arrays ??= new Map();
-    const firstAssign = !scope.arrays.has(uniqueName);
-    if (firstAssign) scope.arrays.set(uniqueName, rawPtr);
+  const local = global ? globals[name] : scope.locals[name];
 
-    if (Prefs.data && firstAssign && useRawElements) {
-      // if length is 0 memory/data will just be 0000... anyway
-      if (length !== 0) {
-        let bytes = compileBytes(length, 'i32');
+  const useRawElements = !!decl.rawElements;
+  const elements = useRawElements ? decl.rawElements : decl.elements;
 
-        if (!initEmpty) for (let i = 0; i < length; i++) {
-          if (elements[i] == null) continue;
+  const valtype = itemTypeToValtype[itemType];
+  const length = elements.length;
 
-          bytes.push(...compileBytes(elements[i], itemType));
-        }
+  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 ind = data.push({
-          offset: rawPtr,
-          bytes
-        }) - 1;
+      if (!initEmpty) for (let i = 0; i < length; i++) {
+        if (elements[i] == null) continue;
 
-        scope.data ??= [];
-        scope.data.push(ind);
+        bytes.push(...compileBytes(elements[i], itemType));
       }
 
-      // local value as pointer
-      return [ number(rawPtr, intOut ? Valtype.i32 : valtypeBinary), pointer ];
+      const ind = data.push({
+        offset: pointer,
+        bytes
+      }) - 1;
+
+      scope.data ??= [];
+      scope.data.push(ind);
     }
 
-    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 ]
-      );
+    // local value as pointer
+    out.push(...number(pointer));
 
-      pointer = [ [ Opcodes.local_get, pointerTmp ] ];
-    }
+    return [ out, pointer ];
   }
 
+  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 ]
+    );
+  }
+
+  const pointerWasm = pointerTmp != null ? [ [ Opcodes.local_get, pointerTmp ] ] : number(pointer, Valtype.i32);
 
   // store length
   out.push(
-    ...pointer,
+    ...pointerWasm,
     ...number(length, Valtype.i32),
     [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ]
   );
@@ -3245,11 +3342,11 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
 
     const offset = ValtypeSize.i32 + i * sizePerEl;
     out.push(
-      ...pointer,
+      ...pointerWasm,
       ...(useRawElements ? number(elements[i], Valtype[valtype]) : generate(scope, elements[i])),
       [ storeOp, 0, ...unsignedLEB128(offset) ],
       ...(!typed ? [] : [ // typed presumes !useRawElements
-        ...pointer,
+        ...pointerWasm,
         ...getNodeType(scope, elements[i]),
         [ Opcodes.i32_store8, 0, ...unsignedLEB128(offset + ValtypeSize[itemType]) ]
       ])
@@ -3257,13 +3354,12 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   }
 
   // local value as pointer
-  out.push(...pointer);
-  if (!intOut) out.push(Opcodes.i32_from_u);
+  out.push(...pointerWasm, Opcodes.i32_from_u);
 
   return [ out, pointer ];
 };
 
-const storeArray = (scope, array, index, element) => {
+const storeArray = (scope, array, index, element, aotPointer = null) => {
   if (!Array.isArray(element)) element = generate(scope, element);
   if (typeof index === 'number') index = number(index);
 
@@ -3275,25 +3371,26 @@ const storeArray = (scope, array, index, element) => {
     Opcodes.i32_to_u,
     ...number(ValtypeSize[valtype] + 1, Valtype.i32),
     [ Opcodes.i32_mul ],
-
-    ...array,
-    Opcodes.i32_to_u,
-    [ Opcodes.i32_add ],
+    ...(aotPointer ? [] : [
+      ...array,
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_add ],
+    ]),
     [ Opcodes.local_set, offset ],
 
     // store value
     [ Opcodes.local_get, offset ],
     ...generate(scope, element),
-    [ Opcodes.store, 0, ValtypeSize.i32 ],
+    [ Opcodes.store, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
     // store type
     [ Opcodes.local_get, offset ],
     ...getNodeType(scope, element),
-    [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
+    [ Opcodes.i32_store8, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
   ];
 };
 
-const loadArray = (scope, array, index) => {
+const loadArray = (scope, array, index, aotPointer = null) => {
   if (typeof index === 'number') index = number(index);
 
   const offset = localTmp(scope, '#loadArray_offset', Valtype.i32);
@@ -3304,19 +3401,20 @@ const loadArray = (scope, array, index) => {
     Opcodes.i32_to_u,
     ...number(ValtypeSize[valtype] + 1, Valtype.i32),
     [ Opcodes.i32_mul ],
-
-    ...array,
-    Opcodes.i32_to_u,
-    [ Opcodes.i32_add ],
+    ...(aotPointer ? [] : [
+      ...array,
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_add ],
+    ]),
     [ Opcodes.local_set, offset ],
 
     // load value
     [ Opcodes.local_get, offset ],
-    [ Opcodes.load, 0, ValtypeSize.i32 ],
+    [ Opcodes.load, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
     // load type
     [ Opcodes.local_get, offset ],
-    [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
+    [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
   ];
 };
 
@@ -3348,7 +3446,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, false, true)[0];
+  return makeArray(scope, decl, global, name, initEmpty, valtype, true)[0];
 };
 
 const generateObject = (scope, decl, global = false, name = '$undeclared') => {
@@ -3367,6 +3465,9 @@ const withType = (scope, wasm, type) => [
 
 const generateMember = (scope, decl, _global, _name) => {
   const name = decl.object.name;
+  const pointer = scope.arrays?.get(name);
+
+  const aotPointer = Prefs.aotPointerOpt && pointer;
 
   // hack: .name
   if (decl.property.name === 'name') {
@@ -3407,10 +3508,12 @@ const generateMember = (scope, decl, _global, _name) => {
     if (Prefs.fastLength) {
       // presume valid length object
       return [
-        ...generate(scope, decl.object),
-        Opcodes.i32_to_u,
+        ...(aotPointer ? number(0, Valtype.i32) : [
+          ...generate(scope, decl.object),
+          Opcodes.i32_to_u
+        ]),
 
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
         Opcodes.i32_from_u
       ];
     }
@@ -3419,10 +3522,12 @@ const generateMember = (scope, decl, _global, _name) => {
     const known = knownType(scope, type);
     if (known != null) {
       if ([ TYPES.string, TYPES.bytestring, TYPES.array ].includes(known)) return [
-        ...generate(scope, decl.object),
-        Opcodes.i32_to_u,
+        ...(aotPointer ? number(0, Valtype.i32) : [
+          ...generate(scope, decl.object),
+          Opcodes.i32_to_u
+        ]),
 
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
         Opcodes.i32_from_u
       ];
 
@@ -3432,10 +3537,12 @@ const generateMember = (scope, decl, _global, _name) => {
     return [
       ...typeIsOneOf(getNodeType(scope, decl.object), [ TYPES.string, TYPES.bytestring, TYPES.array ]),
       [ Opcodes.if, valtypeBinary ],
-        ...generate(scope, decl.object),
-        Opcodes.i32_to_u,
+        ...(aotPointer ? number(0, Valtype.i32) : [
+          ...generate(scope, decl.object),
+          Opcodes.i32_to_u
+        ]),
 
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
         Opcodes.i32_from_u,
 
         ...setLastType(scope, TYPES.number),
@@ -3478,29 +3585,25 @@ 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, Valtype.i32), newPointer = number(0, Valtype.i32);
+  let newOut = number(0, valtypeBinary), newPointer = -1;
   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(0)
-    }, _global, _name, true, 'i16', true);
+      rawElements: new Array(1)
+    }, _global, _name, true, 'i16');
   }
 
   return typeSwitch(scope, getNodeType(scope, decl.object), {
     [TYPES.array]: [
-      ...loadArray(scope, object, property),
+      ...loadArray(scope, object, property, aotPointer),
       ...setLastType(scope)
     ],
+
     [TYPES.string]: [
       // setup new/out array
       ...newOut,
+      [ Opcodes.drop ],
 
-      // set length to 1
-      ...number(1, Valtype.i32),
-      [ Opcodes.i32_store, 0, 0 ],
-
-      // use as pointer for store later
-      ...newPointer,
+      ...number(0, Valtype.i32), // base 0 for store later
 
       ...property,
       Opcodes.i32_to_u,
@@ -3508,48 +3611,46 @@ const generateMember = (scope, decl, _global, _name) => {
       ...number(ValtypeSize.i16, Valtype.i32),
       [ Opcodes.i32_mul ],
 
-      ...object,
-      Opcodes.i32_to_u,
-      [ Opcodes.i32_add ],
+      ...(aotPointer ? [] : [
+        ...object,
+        Opcodes.i32_to_u,
+        [ Opcodes.i32_add ]
+      ]),
 
       // load current string ind {arg}
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
       // store to new string ind 0
-      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
 
       // return new string (page)
-      ...newPointer,
-      Opcodes.i32_from_u,
+      ...number(newPointer),
       ...setLastType(scope, TYPES.string)
     ],
     [TYPES.bytestring]: [
       // setup new/out array
       ...newOut,
+      [ Opcodes.drop ],
 
-      // set length to 1
-      ...number(1, Valtype.i32),
-      [ Opcodes.i32_store, 0, 0 ],
-
-      // use as pointer for store later
-      ...newPointer,
+      ...number(0, Valtype.i32), // base 0 for store later
 
       ...property,
       Opcodes.i32_to_u,
 
-      ...object,
-      Opcodes.i32_to_u,
-      [ Opcodes.i32_add ],
+      ...(aotPointer ? [] : [
+        ...object,
+        Opcodes.i32_to_u,
+        [ Opcodes.i32_add ]
+      ]),
 
       // load current string ind {arg}
-      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
       // store to new string ind 0
-      [ Opcodes.i32_store8, 0, ValtypeSize.i32 ],
+      [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
 
       // return new string (page)
-      ...newPointer,
-      Opcodes.i32_from_u,
+      ...number(newPointer),
       ...setLastType(scope, TYPES.bytestring)
     ],
 
@@ -3705,13 +3806,12 @@ const internalConstrs = {
       if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeThrow', 'Invalid array length', true);
 
       return [
-        ...pointer,
+        ...number(0, Valtype.i32),
         ...generate(scope, arg, global, name),
         Opcodes.i32_to_u,
-        [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ],
+        [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ],
 
-        ...pointer,
-        Opcodes.i32_from_u
+        ...number(pointer)
       ];
     },
     type: TYPES.array,
@@ -3860,9 +3960,8 @@ const internalConstrs = {
 };
 
 export default program => {
-  globals = {
-    ['#ind']: 0
-  };
+  globals = {};
+  globalInd = 0;
   tags = [];
   exceptions = [];
   funcs = [];
@@ -3895,7 +3994,6 @@ export default program => {
   builtinFuncs = new BuiltinFuncs();
   builtinVars = new BuiltinVars();
   prototypeFuncs = new PrototypeFuncs();
-  allocator = Allocator(Prefs.allocator ?? 'static');
 
   program.id = { name: 'main' };
 
@@ -3938,8 +4036,6 @@ 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);