porffor 0.16.0-fe07da0f4 → 0.17.0-048c6f2ee

package/CONTRIBUTING.md

@@ -26,7 +26,7 @@ You can also swap out `node` in the alias to use another runtime like Deno (`den
 
 ### Precompile
 
-**If you update any file inside `compiler/builtins` you will need to do this for it to update inside Porffor otherwise your changes will have no effect.** Run `node compiler/precompile.js` to precompile. It may error during this, if so, you might have an error in your code or there could be a compiler error with Porffor (feel free to ask for help as soon as you encounter any errors with it).
+**If you update any file inside `compiler/builtins` you will need to do this for it to update inside Porffor otherwise your changes will have no effect.** Run `./porf precompile` to precompile. It may error during this, if so, you might have an error in your code or there could be a compiler error with Porffor (feel free to ask for help as soon as you encounter any errors with it).
 
 <br>
 
@@ -233,7 +233,7 @@ builtins/tostring_number: impl radix
 
 ## Test262
 
-Make sure you have Test262 cloned already **inside of `test262/`** (`git clone https://github.com/tc39/test262.git test262/test262`) and run `npm install` inside `test262/` too.
+For the first time, ensure you run `./test262/setup.sh`.
 
 Run `node test262` to run all the tests and get an output of total overall test results.
 

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!
 
@@ -63,26 +63,14 @@ Expect nothing to work! Only very limited JS is currently supported. See files i
 - `--valtype=i32|i64|f64` (default: `f64`) to set valtype
 - `-O0` to disable opt
 - `-O1` (default) to enable basic opt (simplify insts, treeshake wasm imports)
-- `-O2` to enable advanced opt (inlining). unstable
-- `-O3` to enable advanceder opt (precompute const math). unstable
-- `--no-run` to not run wasm output, just compile
-- `--opt-log` to log some opts
-- `--code-log` to log some codegen (you probably want `-funcs`)
-- `--regex-log` to log some regex
-- `--funcs` to log funcs
-- `--ast-log` to log AST
-- `--opt-funcs` to log funcs after opt
-- `--sections` to log sections as hex
-- `--opt-no-inline` to not inline any funcs
-- `--tail-call` to enable tail calls (experimental + not widely implemented)
-- `--compile-hints` to enable V8 compilation hints (experimental + doesn't seem to do much?)
+- `-O2` to enable advanced opt (inlining). unstable!
+- `-O3` to enable advanceder opt (precompute const math). unstable!
 
 ## Limitations
 - No full object support yet
 - 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 +100,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;
@@ -29,72 +30,123 @@ typedef double f64;
 f64 NAN = 0e+0/0e+0;
 
 struct ReturnValue {
-  ${CValtype.f64} value;
-  ${CValtype.i32} type;
+  f64 value;
+  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'],
-    argTypes: [CValtype.i32, CValtype.i32],
+    argTypes: ['i32', 'i32'],
     returns: false
   },
   [Opcodes.i32_store16]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
-    argTypes: [CValtype.i32, CValtype.i16],
+    argTypes: ['i32', 'u16'],
     returns: false
   },
   [Opcodes.i32_store8]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
-    argTypes: [CValtype.i32, CValtype.i8],
+    argTypes: ['i32', 'u8'],
     returns: false
   },
 
   [Opcodes.i32_load]: {
-    c: `${CValtype.i32} out;
+    c: `i32 out;
 memcpy(&out, _memory + offset + pointer, sizeof(out));
 return out;`,
     args: ['pointer'],
-    argTypes: [CValtype.i32],
-    returns: CValtype.i32
+    argTypes: ['i32'],
+    returns: 'i32'
   },
   [Opcodes.i32_load16_u]: {
-    c: `${CValtype.i16} out;
+    c: `u16 out;
 memcpy(&out, _memory + offset + pointer, sizeof(out));
 return out;`,
     args: ['pointer'],
-    argTypes: [CValtype.i32],
-    returns: CValtype.i32
+    argTypes: ['i32'],
+    returns: 'i32'
   },
   [Opcodes.i32_load8_u]: {
-    c: `${CValtype.i8} out;
+    c: `u8 out;
 memcpy(&out, _memory + offset + pointer, sizeof(out));
 return out;`,
     args: ['pointer'],
-    argTypes: [CValtype.i32],
-    returns: CValtype.i32
+    argTypes: ['i32'],
+    returns: 'i32'
   },
 
   [Opcodes.f64_store]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
-    argTypes: [CValtype.i32, CValtype.f64],
+    argTypes: ['i32', 'f64'],
     returns: false
   },
   [Opcodes.f64_load]: {
-    c: `${CValtype.f64} out;
+    c: `f64 out;
 memcpy(&out, _memory + offset + pointer, sizeof(out));
 return out;`,
     args: ['pointer'],
-    argTypes: [CValtype.i32],
-    returns: CValtype.f64
+    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'
   },
 };
 
@@ -108,7 +160,7 @@ for (const x in CValtype) {
 
 const removeBrackets = str => {
   // return str;
-  // if (str.startsWith(`(${CValtype.i32})(${CValtype.u32})`)) return `(${CValtype.i32})(${CValtype.u32})(` + removeBrackets(str.slice(22, -1)) + ')';
+  // if (str.startsWith('(i32)(u32)')) return '(i32)(u32)(' + removeBrackets(str.slice(22, -1)) + ')';
 
   for (const x in CValtype) {
     const p = `(${x})`;
@@ -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')) {
@@ -168,10 +225,10 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
   let depth = 1;
   let brDepth = 0;
-  const line = (str, semi = true) => out += `${' '.repeat(depth * 2 + brDepth * 2)}${str}${semi ? ';' : ''}\n`;
+  const line = (str, semi = true) => out += `${' '.repeat((depth + brDepth) * 2)}${str}${semi ? ';' : ''}\n`;
   const lines = lines => {
     for (const x of lines) {
-      out += `${' '.repeat(depth * 2)}${x}\n`;
+      out += `${' '.repeat((depth + brDepth) * 2)}${x}\n`;
     }
   };
 
@@ -219,10 +276,10 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
     const shouldInline = false; // f.internal;
     if (f.name === 'main') out += `int main(${prependMain.has('argv') ? 'int argc, char* argv[]' : ''}) {\n`;
-      else out += `${f.internal ? (returns ? CValtype.f64 : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+      else out += `${f.internal ? (returns ? 'f64' : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
 
     if (f.name === 'main') {
-      out += [...prependMain.values()].join('\n');
+      out += '  ' + [...prependMain.values()].join('\n  ');
       if (prependMain.size > 0) out += '\n\n';
     }
 
@@ -283,12 +340,12 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
         switch (i[1]) {
           // i32_trunc_sat_f64_s
           case 0x02:
-            vals.push(`(${CValtype.i32})(${vals.pop()})`);
+            vals.push(`(i32)(${vals.pop()})`);
             break;
 
           // i32_trunc_sat_f64_u
           case 0x03:
-            vals.push(`(${CValtype.u32})(${vals.pop()})`);
+            vals.push(`(u32)(${vals.pop()})`);
             break;
         }
 
@@ -337,7 +394,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
         case Opcodes.f64_trunc:
           // vals.push(`trunc(${vals.pop()})`);
-          vals.push(`(${CValtype.i32})(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
+          vals.push(`(i32)(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
           break;
 
         case Opcodes.f64_convert_i32_u:
@@ -345,7 +402,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
         case Opcodes.f64_convert_i64_u:
         case Opcodes.f64_convert_i64_s:
           // int to f64
-          vals.push(`(${CValtype.f64})(${removeBrackets(vals.pop())})`);
+          vals.push(`(f64)(${removeBrackets(vals.pop())})`);
           break;
 
         case Opcodes.i32_eqz:
@@ -353,7 +410,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
             vals.push(`!(${removeBrackets(vals.pop())})`);
           } else {
             let cond = '(' + removeBrackets(vals.pop());
-            if (cond.startsWith(`(${CValtype.i32})`)) cond = `${cond.slice(`(${CValtype.i32})`.length)}) == 0e+0`;
+            if (cond.startsWith(`(i32)`)) cond = `${cond.slice(5)} == 0e+0`;
               else cond += ') == 0';
             vals.push(cond);
           }
@@ -362,13 +419,16 @@ 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: {
           let cond = removeBrackets(vals.pop());
           if (!lastCond) {
-            if (cond.startsWith(`(${CValtype.i32})`)) cond = `(${cond.slice(`(${CValtype.i32})`.length)}) != 0e+0`;
+            if (cond.startsWith(`(i32)`)) cond = `${cond.slice(5)} != 0e+0`;
               else cond = `(${cond}) != 0`;
           }
 
@@ -434,28 +494,16 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
             const importFunc = importFuncs[i[1]];
             switch (importFunc.name) {
               case 'print':
-                // line(`printf("%f\\n", ${vals.pop()})`);
                 line(`printf("${valtype === 'f64' ? '%g' : '%i'}\\n", ${vals.pop()})`);
                 includes.set('stdio.h', true);
                 break;
               case 'printChar':
-                line(`printf("%c", (int)(${vals.pop()}))`);
+                line(`putchar((int)(${vals.pop()}))`);
                 includes.set('stdio.h', true);
                 break;
 
               case 'time':
                 line(`double _time_out`);
-                /* platformSpecific(
-`FILETIME _time_filetime;
-GetSystemTimeAsFileTime(&_time_filetime);
-
-ULARGE_INTEGER _time_ularge;
-_time_ularge.LowPart = _time_filetime.dwLowDateTime;
-_time_ularge.HighPart = _time_filetime.dwHighDateTime;
-_time_out = (_time_ularge.QuadPart - 116444736000000000i64) / 10000.;`,
-`struct timespec _time;
-clock_gettime(CLOCK_MONOTONIC, &_time);
-_time_out = _time.tv_nsec / 1000000.;`); */
                 platformSpecific(
 `LARGE_INTEGER _time_freq, _time_t;
 QueryPerformanceFrequency(&_time_freq);
@@ -470,14 +518,11 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
                 winIncludes.set('windows.h', true);
                 break;
 
-              case '__Porffor_readArgv':
-                includes.set('stdlib.h', true);
-
+              case '__Porffor_readArgv': {
                 prepend.set('__Porffor_readArgv',
-`void __Porffor_readArgv(u32 index, u32 outPtr) {
+`i32 __Porffor_readArgv(u32 index, u32 outPtr) {
   if (index >= _argc) {
-    printf("expected %d arguments\\n", index);
-    exit(1);
+    return -1;
   }
 
   char* arg = _argv[index];
@@ -489,24 +534,25 @@ _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;
 }`);
 
-                line(`__Porffor_readArgv((u32)(${vals.at(-2)}), (u32)(${vals.pop()}))`);
-                vals.pop();
+                const outPtr = vals.pop();
+                const index = vals.pop();
+                vals.push(`(f64)__Porffor_readArgv((u32)(${index}), (u32)(${outPtr}))`);
                 break;
+              }
 
-              case '__Porffor_readFile':
+              case '__Porffor_readFile': {
                 includes.set('stdio.h', true);
-                includes.set('stdlib.h', true);
 
                 prepend.set('__Porffor_readFile',
-`void __Porffor_readFile(u32 pathPtr, u32 outPtr) {
+`i32 __Porffor_readFile(u32 pathPtr, u32 outPtr) {
   char* path = _memory + pathPtr + 4;
   FILE* fp = fopen(path, "r");
   if (fp == NULL) {
-    printf("failed to open file: %s\\n", path);
-    exit(1);
+    return -1;
   }
 
   u32 read = 0;
@@ -518,11 +564,14 @@ _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;
 }`);
-                line(`__Porffor_readFile((u32)(${vals.at(-2)}), (u32)(${vals.pop()}))`);
-                vals.pop();
+                const outPtr = vals.pop();
+                const pathPtr = vals.pop();
+                vals.push(`(f64)__Porffor_readFile((u32)(${pathPtr}), (u32)(${outPtr}))`);
                 break;
+              }
 
               default:
                 log.warning('2c', `unimplemented import: ${importFunc.name}`);
@@ -539,9 +588,10 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
             if (func.internal) {
               vals.push(`${sanitize(func.name)}(${args.join(', ')})`);
             } else {
-              line(`const struct ReturnValue _${retTmpId++} = ${sanitize(func.name)}(${args.join(', ')})`);
-              vals.push(`_.value`);
-              vals.push(`_.type`);
+              const id = retTmpId++;
+              line(`const struct ReturnValue _${id} = ${sanitize(func.name)}(${args.join(', ')})`);
+              vals.push(`_${id}.value`);
+              vals.push(`_${id}.type`);
             }
           } else line(`${sanitize(func.name)}(${args.join(', ')})`);
 
@@ -571,7 +621,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
 
           let cond = removeBrackets(vals.pop());
           if (!lastCond) {
-            if (cond.startsWith(`(${CValtype.i32})`)) cond = `(${cond.slice(`(${CValtype.i32})`.length)}) != 0e+0`;
+            if (cond.startsWith(`(i32)`)) cond = `${cond.slice(5)} != 0e+0`;
               else cond = `(${cond}) != 0`;
           }
 
@@ -601,8 +651,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
             const name = invOpcodes[i[0]];
             const func = CMemFuncs[i[0]];
             if (!prepend.has(name)) {
-              prepend.set(name, `${func.returns || 'void'} ${name}(${CValtype.i32} align, ${CValtype.i32} offset, ${func.args.map((x, i) => `${func.argTypes[i]} ${x}`).join(', ')}) {\n  ${func.c.replaceAll('\n', '\n  ')}\n}\n`);
-              // generate func c and prepend
+              prepend.set(name, `${func.returns || 'void'} ${name}(i32 align, i32 offset, ${func.args.map((x, i) => `${func.argTypes[i]} ${x}`).join(', ')}) {\n  ${func.c.replaceAll('\n', '\n  ')}\n}\n`);
             }
 
             const immediates = [ i[1], read_unsignedLEB128(i.slice(2)) ];
@@ -637,7 +686,6 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
   depth = 0;
 
   const makeIncludes = includes => [...includes.keys()].map(x => `#include <${x}>\n`).join('');
-
   out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + alwaysPreface + [...prepend.values()].join('\n') + '\n\n' + out;
 
   return out.trim();

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

@@ -21,7 +21,7 @@ const chHint = (topTier, baselineTier, strategy) => {
   return (strategy | (baselineTier << 2) | (topTier << 4));
 };
 
-export default (funcs, globals, tags, pages, data, flags) => {
+export default (funcs, globals, tags, pages, data, flags, noTreeshake = false) => {
   const types = [], typeCache = {};
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
@@ -44,7 +44,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   let importFuncs = [];
 
-  if (optLevel < 1 || !Prefs.treeshakeWasmImports) {
+  if (optLevel < 1 || !Prefs.treeshakeWasmImports || noTreeshake) {
     importFuncs = importedFuncs;
   } else {
     let imports = new Map();
@@ -94,7 +94,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   const importSection = importFuncs.length === 0 ? [] : createSection(
     Section.import,
-    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(new Array(x.params).fill(x.name.startsWith('profile') ? Valtype.i32 : valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
+    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(typeof x.params === 'object' ? x.params : new Array(x.params).fill(valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
   );
 
   const funcSection = createSection(
@@ -116,7 +116,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
     ] ])
   );
 
-  if (pages.has('func argc lut')) {
+  if (pages.has('func argc lut') && !data.addedFuncArgcLut) {
     // generate func argc lut data
     const bytes = [];
     for (let i = 0; i < funcs.length; i++) {
@@ -128,6 +128,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
       offset: pages.get('func argc lut').ind * pageSize,
       bytes
     });
+    data.addedFuncArgcLut = true;
   }
 
   // const t0 = performance.now();
@@ -239,7 +240,13 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   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(