porffor 0.16.0-688a50c13 → 0.16.0-7143cc59c

package/README.md

@@ -29,7 +29,7 @@ Expect nothing to work! Only very limited JS is currently supported. See files i
 > [!WARNING]
 > Compiling to native binaries uses [2c](#2c), Porffor's own Wasm -> C compiler, which is experimental.
 
-**`porf native path/to/script.js out(.exe)`**. You can specify the compiler with `--compiler=clang/zig/gcc`, and which opt level to use with `--cO=O3` (`Ofast` by default). Output binaries are also stripped by default.
+**`porf native path/to/script.js out(.exe)`**. You can specify the compiler with `--compiler=clang/gcc/zig` (`clang` by default), and which optimization level to use with `--cO=Ofast/O3/O2/O1/O0` (`Ofast` by default). Output binaries are also stripped by default.
 
 ### Compiling to C
 > [!WARNING]
@@ -49,7 +49,7 @@ Expect nothing to work! Only very limited JS is currently supported. See files i
 
 **`porf debug path/to/script.js`**
 
-### Profiling the generated Wasm of a JS file
+### Debugging the compiled Wasm of a JS file
 > [!WARNING]
 > Very experimental WIP feature!
 
@@ -82,7 +82,6 @@ Expect nothing to work! Only very limited JS is currently supported. See files i
 - Little built-ins/prototype
 - No async/promise/await
 - No variables between scopes (except args and globals)
-- Literal callees only in calls (eg `print()` works, `a = print; a()` does not)
 - No `eval()` etc (since it is AOT)
 
 ## Sub-engines
@@ -112,7 +111,7 @@ These include some early (stage 1/0) and/or dead (last commit years ago) proposa
 
 - Number literals
 - Declaring functions
-- Calling functions *literal callees only*
+- Calling functions
 - `return`
 - `let`/`const`/`var` basic declarations
 - Some basic integer operators (`+-/*%`)

package/compiler/2c.js

@@ -2,10 +2,11 @@ import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from '.
 import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
 import { operatorOpcode } from './expression.js';
 import { log } from './log.js';
+import Prefs from './prefs.js';
 
 const CValtype = {
-  i8: 'i8',
-  i16: 'i16',
+  i8: 'u8',
+  i16: 'u16',
   i32: 'i32',
   u32: 'u32',
   i64: 'i64',
@@ -17,8 +18,8 @@ const CValtype = {
   undefined: 'void'
 };
 
-const alwaysPreface = `typedef uint8_t i8;
-typedef uint16_t i16;
+const alwaysPreface = `typedef uint8_t u8;
+typedef uint16_t u16;
 typedef int32_t i32;
 typedef uint32_t u32;
 typedef int64_t i64;
@@ -33,11 +34,11 @@ struct ReturnValue {
   i32 type;
 };\n\n`;
 
-// todo: is memcpy/etc safe with host endianness?
+// todo: review whether 2cMemcpy should be default or not
 
 // all:
 // immediates: ['align', 'offset']
-const CMemFuncs = {
+const CMemFuncs = Prefs['2cMemcpy'] ? {
   [Opcodes.i32_store]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
@@ -47,13 +48,13 @@ const CMemFuncs = {
   [Opcodes.i32_store16]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
-    argTypes: ['i32', 'i16'],
+    argTypes: ['i32', 'u16'],
     returns: false
   },
   [Opcodes.i32_store8]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
-    argTypes: ['i32', 'i8'],
+    argTypes: ['i32', 'u8'],
     returns: false
   },
 
@@ -66,7 +67,7 @@ return out;`,
     returns: 'i32'
   },
   [Opcodes.i32_load16_u]: {
-    c: `i16 out;
+    c: `u16 out;
 memcpy(&out, _memory + offset + pointer, sizeof(out));
 return out;`,
     args: ['pointer'],
@@ -74,7 +75,7 @@ return out;`,
     returns: 'i32'
   },
   [Opcodes.i32_load8_u]: {
-    c: `i8 out;
+    c: `u8 out;
 memcpy(&out, _memory + offset + pointer, sizeof(out));
 return out;`,
     args: ['pointer'],
@@ -96,6 +97,57 @@ return out;`,
     argTypes: ['i32'],
     returns: 'f64'
   },
+} : {
+  [Opcodes.i32_store]: {
+    c: `*((i32*)(_memory + offset + pointer)) = value;`,
+    args: ['pointer', 'value'],
+    argTypes: ['i32', 'i32'],
+    returns: false
+  },
+  [Opcodes.i32_store16]: {
+    c: `*((u16*)(_memory + offset + pointer)) = value;`,
+    args: ['pointer', 'value'],
+    argTypes: ['i32', 'u16'],
+    returns: false
+  },
+  [Opcodes.i32_store8]: {
+    c: `*((u8*)(_memory + offset + pointer)) = value;`,
+    args: ['pointer', 'value'],
+    argTypes: ['i32', 'u8'],
+    returns: false
+  },
+
+  [Opcodes.i32_load]: {
+    c: `return *((i32*)(_memory + offset + pointer));`,
+    args: ['pointer'],
+    argTypes: ['i32'],
+    returns: 'i32'
+  },
+  [Opcodes.i32_load16_u]: {
+    c: `return *((u16*)(_memory + offset + pointer));`,
+    args: ['pointer'],
+    argTypes: ['i32'],
+    returns: 'i32'
+  },
+  [Opcodes.i32_load8_u]: {
+    c: `return *((u8*)(_memory + offset + pointer));`,
+    args: ['pointer'],
+    argTypes: ['i32'],
+    returns: 'i32'
+  },
+
+  [Opcodes.f64_store]: {
+    c: `*((f64*)(_memory + offset + pointer)) = value;`,
+    args: ['pointer', 'value'],
+    argTypes: ['i32', 'f64'],
+    returns: false
+  },
+  [Opcodes.f64_load]: {
+    c: `return *((f64*)(_memory + offset + pointer));`,
+    args: ['pointer'],
+    argTypes: ['i32'],
+    returns: 'f64'
+  },
 };
 
 const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
@@ -152,11 +204,16 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
   if (pages.size > 0) {
     prepend.set('_memory', `char _memory[${pages.size * pageSize}];\n`);
-    includes.set('string.h', true);
+    if (Prefs['2cMemcpy']) includes.set('string.h', true);
   }
 
   if (data.length > 0) {
-    prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n  '));
+    if (Prefs['2cMemcpy']) {
+      prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n  '));
+      includes.set('string.h', true);
+    } else {
+      prependMain.set('_data', data.map(x => x.bytes.reduce((acc, y, i) => acc + `_memory[${x.offset + i}]=(u8)${y};`, '')).join('\n  '));
+    }
   }
 
   if (importFuncs.find(x => x.name === '__Porffor_readArgv')) {
@@ -362,7 +419,10 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
         case Opcodes.return:
           // line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
-          line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(vals.pop())}, ${removeBrackets(vals.pop())} }` : ''}`);
+          const b = vals.pop();
+          const a = vals.pop();
+          line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(a)}, ${removeBrackets(b)} }` : ''}`);
+          // line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(vals.pop())}, ${removeBrackets(vals.pop())} }` : ''}`);
           break;
 
         case Opcodes.if: {
@@ -474,7 +534,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
     out[read++] = ch;
   }
 
-  memcpy(_memory + outPtr, &read, sizeof(read));
+  *((i32*)(_memory + outPtr)) = (i32)read;
   return read;
 }`);
 
@@ -504,7 +564,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
 
   fclose(fp);
 
-  memcpy(_memory + outPtr, &read, sizeof(read));
+  *((i32*)(_memory + outPtr)) = (i32)read;
   return read;
 }`);
                 const outPtr = vals.pop();

package/compiler/allocators.js

@@ -0,0 +1,128 @@
+import { Opcodes, PageSize, Valtype } from './wasmSpec.js';
+import { number } from './embedding.js';
+import Prefs from './prefs.js';
+
+// we currently have 3 allocators:
+// - static (default): a static/compile-time allocator. fast (no grow/run-time alloc needed) but can break some code
+// - grow: perform a memory.grow every allocation. simple but maybe slow?
+// - chunk: perform large memory.grow's in chunks when needed. needs investigation
+
+export default name => {
+  switch (name) {
+    case 'static': return new StaticAllocator();
+    case 'grow': return new GrowAllocator();
+    case 'chunk': return new ChunkAllocator();
+    default: throw new Error(`unknown allocator: ${name}`);
+  }
+};
+
+export class StaticAllocator {
+  constructor() {
+  }
+
+  allocType(itemType) {
+    switch (itemType) {
+      case 'i8': return 'bytestring';
+      case 'i16': return 'string';
+
+      default: return 'array';
+    }
+  }
+
+  ptr(ind) {
+    if (ind === 0) return 4;
+    return ind * PageSize;
+  }
+
+  alloc({ scope, pages }, name, { itemType }) {
+    const reason = `${this.allocType(itemType)}: ${Prefs.scopedPageNames ? (scope.name + '/') : ''}${name}`;
+
+    if (pages.has(reason)) return number(this.ptr(pages.get(reason).ind), Valtype.i32);
+
+    if (reason.startsWith('array:')) pages.hasArray = true;
+    if (reason.startsWith('string:')) pages.hasString = true;
+    if (reason.startsWith('bytestring:')) pages.hasByteString = true;
+    if (reason.includes('string:')) pages.hasAnyString = true;
+
+    let ind = pages.size;
+    pages.set(reason, { ind, type: itemType });
+
+    scope.pages ??= new Map();
+    scope.pages.set(reason, { ind, type: itemType });
+
+    return number(this.ptr(ind), Valtype.i32);
+  }
+}
+
+export class GrowAllocator {
+  constructor() {
+    Prefs.rmUnusedTypes = false;
+  }
+
+  alloc() {
+    return [
+      // grow by 1 page
+      [ Opcodes.i32_const, 1 ],
+      [ Opcodes.memory_grow, 0 ], // returns old page count
+
+      // get ptr (page count * page size)
+      number(65536, Valtype.i32)[0],
+      [ Opcodes.i32_mul ]
+    ];
+  }
+}
+
+export class ChunkAllocator {
+  constructor(chunkSize) {
+    Prefs.rmUnusedTypes = false;
+
+    // 64KiB * chunk size each growth
+    // 16: 1MiB chunks
+    this.chunkSize = chunkSize ?? Prefs.chunkAllocatorSize ?? 16;
+  }
+
+  alloc({ asmFunc, funcIndex }) {
+    const func = funcIndex['#chunkallocator_alloc'] ?? asmFunc('#chunkallocator_alloc', {
+      wasm: [
+        [ Opcodes.global_get, 0 ],
+        [ Opcodes.global_get, 1 ],
+        [ Opcodes.i32_ge_s ],
+        [ Opcodes.if, Valtype.i32 ], // ptr >= next
+          // grow by chunk size pages
+          [ Opcodes.i32_const, this.chunkSize ],
+          [ Opcodes.memory_grow, 0 ],
+
+          // ptr = prev memory size * PageSize
+          number(65536, Valtype.i32)[0],
+          [ Opcodes.i32_mul ],
+          [ Opcodes.global_set, 0 ],
+
+          // next = ptr + ((chunkSize - 1) * PageSize)
+          [ Opcodes.global_get, 0 ],
+          number(65536 * (this.chunkSize - 1), Valtype.i32)[0],
+          [ Opcodes.i32_add ],
+          [ Opcodes.global_set, 1 ],
+
+          // return ptr
+          [ Opcodes.global_get, 0 ],
+        [ Opcodes.else ],
+          // return ptr = ptr + PageSize
+          [ Opcodes.global_get, 0 ],
+          number(65536, Valtype.i32)[0],
+          [ Opcodes.i32_add ],
+          [ Opcodes.global_set, 0 ],
+          [ Opcodes.global_get, 0 ],
+        [ Opcodes.end ],
+      ],
+      params: [],
+      locals: [],
+      globals: [ Valtype.i32, Valtype.i32 ],
+      globalNames: ['#chunkallocator_ptr', '#chunkallocator_next'],
+      returns: [ Valtype.i32 ],
+    }).index;
+
+    return [
+      [ Opcodes.call, func ]
+    ];
+  }
+}

package/compiler/assemble.js

@@ -240,7 +240,13 @@ export default (funcs, globals, tags, pages, data, flags, noTreeshake = false) =
 
   const dataSection = data.length === 0 ? [] : createSection(
     Section.data,
-    encodeVector(data.map(x => [ 0x00, Opcodes.i32_const, ...signedLEB128(x.offset), Opcodes.end, ...encodeVector(x.bytes) ]))
+    encodeVector(data.map(x => {
+      // type: active
+      if (x.offset != null) return [ 0x00, Opcodes.i32_const, ...signedLEB128(x.offset), Opcodes.end, ...encodeVector(x.bytes) ];
+
+      // type: passive
+      return [ 0x01, ...encodeVector(x.bytes) ];
+    }))
   );
 
   const dataCountSection = data.length === 0 ? [] : createSection(

package/compiler/builtins/array.ts

@@ -171,12 +171,11 @@ export const __Array_prototype_filter = (_this: any[], callbackFn: any) => {
 };
 
 export const __Array_prototype_map = (_this: any[], callbackFn: any) => {
-  const out: any[] = [];
-
-  const len: i32 = _this.length;
   let i: i32 = 0;
+  const len: i32 = _this.length;
+  const out: any[] = new Array(len);
   while (i < len) {
-    out.push(callbackFn(_this[i], i++, _this));
+    out[i] = callbackFn(_this[i], i++, _this);
   }
 
   return out;

package/compiler/builtins/date.ts

@@ -722,10 +722,9 @@ export const __Porffor_date_allocate = (): Date => {
   const hack: bytestring = '';
 
   if (hack.length == 0) {
-    hack.length = Porffor.wasm`memory.size 0
+    hack.length = Porffor.wasm`
 i32.const 1
 memory.grow 0
-drop
 i32.const 65536
 i32.mul
 i32.from_u`;

package/compiler/builtins/set.ts

@@ -2,10 +2,9 @@ import type {} from './porffor.d.ts';
 
 // dark wasm magic for dealing with memory, sorry.
 export const __Porffor_allocate = (): number => {
-  Porffor.wasm`memory.size 0
+  Porffor.wasm`
 i32.const 1
 memory.grow 0
-drop
 i32.const 65536
 i32.mul
 i32.from_u

package/compiler/codegen.js

@@ -9,7 +9,7 @@ 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';
+import makeAllocator from './allocators.js';
 
 let globals = {};
 let tags = [];
@@ -33,11 +33,6 @@ const todo = (scope, msg, expectsValue = undefined) => {
 
     case 'runtime':
       return internalThrow(scope, 'TodoError', msg, expectsValue);
-
-      // return [
-      //   ...debug(`todo! ${msg}`),
-      //   [ Opcodes.unreachable ]
-      // ];
   }
 };
 
@@ -431,7 +426,7 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
   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', true);
 
@@ -447,7 +442,7 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
     [ Opcodes.local_set, rightPointer ],
 
     // calculate length
-    ...pointer, // base 0 for store later
+    ...out,
 
     [ Opcodes.local_get, leftPointer ],
     [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
@@ -1003,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;
 
@@ -1017,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);
   }
 
@@ -1403,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]);
@@ -3117,8 +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;
 };
 
@@ -3156,6 +3149,46 @@ const compileBytes = (val, itemType) => {
   }
 };
 
+const makeData = (scope, elements, offset = null, itemType, initEmpty) => {
+  const length = elements.length;
+
+  // if length is 0 memory/data will just be 0000... anyway
+  if (length === 0) return false;
+
+  let bytes = compileBytes(length, 'i32');
+
+  if (!initEmpty) for (let i = 0; i < length; i++) {
+    if (elements[i] == null) continue;
+
+    bytes.push(...compileBytes(elements[i], itemType));
+  }
+
+  const obj = { bytes };
+  if (offset != null) obj.offset = offset;
+
+  const idx = data.push(obj) - 1;
+
+  scope.data ??= [];
+  scope.data.push(idx);
+
+  return { idx, size: bytes.length };
+};
+
+const printStaticStr = str => {
+  const out = [];
+
+  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;
@@ -3175,17 +3208,50 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   const valtype = itemTypeToValtype[itemType];
   const length = elements.length;
 
-  const allocated = allocator.alloc({ scope, pages, globals }, uniqueName, { itemType });
+  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' + 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 ]
+    );
+
     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 ]
+        );
+      }
+
+      // return pointer in out
+      out.push(
+        ...pointer,
+        ...(!intOut ? [ Opcodes.i32_from_u ] : [])
+      );
+
+      return [ out, pointer ];
+    }
   } else {
     const rawPtr = read_signedLEB128(pointer[0].slice(1));
 
@@ -3194,24 +3260,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     if (firstAssign) scope.arrays.set(uniqueName, rawPtr);
 
     if (Prefs.data && firstAssign && useRawElements) {
-      // if length is 0 memory/data will just be 0000... anyway
-      if (length !== 0) {
-        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 ind = data.push({
-          offset: rawPtr,
-          bytes
-        }) - 1;
-
-        scope.data ??= [];
-        scope.data.push(ind);
-      }
+      makeData(scope, elements, rawPtr, itemType, initEmpty);
 
       // local value as pointer
       return [ number(rawPtr, intOut ? Valtype.i32 : valtypeBinary), pointer ];
@@ -3694,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;
 
@@ -3705,7 +3754,7 @@ const internalConstrs = {
       if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeThrow', 'Invalid array length', true);
 
       return [
-        ...pointer,
+        ...out,
         ...generate(scope, arg, global, name),
         Opcodes.i32_to_u,
         [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ],
@@ -3895,7 +3944,7 @@ export default program => {
   builtinFuncs = new BuiltinFuncs();
   builtinVars = new BuiltinVars();
   prototypeFuncs = new PrototypeFuncs();
-  allocator = Allocator(Prefs.allocator ?? 'static');
+  allocator = makeAllocator(Prefs.allocator ?? 'static');
 
   program.id = { name: 'main' };