porffor 0.16.0-594397507 → 0.16.0-5c5338783

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>
 

package/compiler/2c.js

@@ -29,8 +29,8 @@ 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?
@@ -41,60 +41,60 @@ const CMemFuncs = {
   [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', 'i16'],
     returns: false
   },
   [Opcodes.i32_store8]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
-    argTypes: [CValtype.i32, CValtype.i8],
+    argTypes: ['i32', 'i8'],
     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: `i16 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: `i8 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'
   },
 };
 
@@ -108,7 +108,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})`;
@@ -156,7 +156,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
   }
 
   if (data.length > 0) {
-    prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n'));
+    prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n  '));
   }
 
   if (importFuncs.find(x => x.name === '__Porffor_readArgv')) {
@@ -168,10 +168,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 +219,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 +283,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 +337,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 +345,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 +353,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);
           }
@@ -368,7 +368,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
         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 +434,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 +458,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];
@@ -490,23 +475,24 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
   }
 
   memcpy(_memory + outPtr, &read, sizeof(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;
@@ -519,10 +505,13 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
   fclose(fp);
 
   memcpy(_memory + outPtr, &read, sizeof(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 +528,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 +561,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 +591,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 +626,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,129 @@
+import { Blocktype, 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;
+
+    // todo: what should be the default
+    // 16: 1MiB chunks
+    // 64KiB * chunk size each growth
+    this.chunkSize = chunkSize ?? Prefs.chunkAllocatorSize ?? 16;
+  }
+
+  alloc({ asmFunc, funcIndex, globals }) {
+    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(

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

package/compiler/builtins/porffor.d.ts

@@ -56,6 +56,9 @@ type PorfforGlobal = {
 
   s(...args: any): string;
   bs(...args: any): bytestring;
+
+  readArgv(index: i32, out: bytestring): i32;
+  readFile(path: bytestring, out: bytestring): i32;
 };
 
 declare global {

package/compiler/builtins/set.ts

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