porffor 0.60.6 → 0.60.8

package/README.md

@@ -92,11 +92,9 @@ Porffor uses a unique versioning system, here's an example: `0.48.7`. Let's brea
 - `compiler`: contains the compiler itself
   - `builtins`: built-in apis written in typescript
   - `2c.js`: custom wasm-to-c engine
-  - `allocator.js`: static/compile-time allocator
   - `assemble.js`: assembles wasm ops and metadata into a spec-compliant wasm module/file
   - `builtins.js`: all manually written built-ins of the engine (spec, custom. vars, funcs)
-  - `builtins_object.js`: all the various built-in objects (think `String`, `globalThis`, etc.)
-  - `builtins_precompiled.js`: dynamically generated builtins from the `builtins/` folder
+  - `builtins_precompiled.js`: generated builtins from the `builtins/` folder
   - `codegen.js`: code (wasm) generation, ast -> wasm. The bulk of the effort
   - `cyclone.js`: wasm partial constant evaluator (it is fast and dangerous hence "cyclone")
   - `disassemble.js`: wasm disassembler using internal debug info

package/compiler/2c.js

@@ -429,6 +429,7 @@ export default ({ funcs, globals, data, pages }) => {
         for (const name in symbols) {
           line(`*(void**)(&${name}) = dlsym(_dl, "${name}")`);
           ffiFuncs[name] = symbols[name];
+          cified.add(name, true);
         }
 
         continue;
@@ -642,9 +643,13 @@ extern ${importFunc.returns.length > 0 ? CValtype[importFunc.returns[0]] : 'void
 
               case 'time': {
                 const id = tmpId++;
-                line(`time_t _time_t${id}`);
-                line(`time(&_time_t${id})`);
-                line(`f64 _time_out${id} = (f64)_time_t${id} * 1000.0`);
+                platformSpecific(`
+time_t _time_t${id};
+time(&_time_t${id});
+f64 _time_out${id} = (f64)_time_t${id} * 1000.0;`, `
+struct timespec _ts${id};
+clock_gettime(CLOCK_REALTIME, &_ts${id});
+f64 _time_out${id} = (f64)_ts${id}.tv_sec * 1000.0 + (f64)_ts${id}.tv_nsec / 1.0e6;`);
                 vals.push(`_time_out${id}`);
 
                 includes.set('time.h', true);

package/compiler/assemble.js

@@ -197,10 +197,10 @@ export default (funcs, globals, tags, pages, data, noTreeshake = false) => {
   }
   time('func section');
 
-  if (pages.has('func lut')) {
+  if (pages.has('#func lut')) {
     if (data.addedFuncArgcLut) {
       // remove existing data
-      data = data.filter(x => x.page !== 'func lut');
+      data = data.filter(x => x.page !== '#func lut');
     }
 
     // generate func lut data
@@ -233,7 +233,7 @@ export default (funcs, globals, tags, pages, data, noTreeshake = false) => {
     if (Prefs.debugFuncLut) log('assemble', `func lut using ${bytes.length}/${pageSize * 2} (${bytesPerFunc} bytes per func)`);
 
     data.push({
-      page: 'func lut',
+      page: '#func lut',
       bytes
     });
     data.addedFuncArgcLut = true;

package/compiler/builtins.js

@@ -1,5 +1,4 @@
 import * as PrecompiledBuiltins from './builtins_precompiled.js';
-import ObjectBuiltins from './builtins_objects.js';
 import { PageSize, Blocktype, Opcodes, Valtype } from './wasmSpec.js';
 import { TYPES, TYPE_NAMES } from './types.js';
 import { number, unsignedLEB128 } from './encoding.js';
@@ -62,7 +61,7 @@ export const createImport = (name, params, returns, js = null, c = null) => {
 export const UNDEFINED = 0;
 export const NULL = 0;
 
-export const BuiltinVars = function(ctx) {
+export const BuiltinVars = function({ builtinFuncs }) {
   this.undefined = () => [ number(UNDEFINED) ];
   this.undefined.type = TYPES.undefined;
 
@@ -121,7 +120,350 @@ export const BuiltinVars = function(ctx) {
     this[`__Symbol_${x}`].type = TYPES.symbol;
   }
 
-  ObjectBuiltins.call(this, ctx, Prefs);
+  // builtin objects
+  const makePrefix = name => (name.startsWith('__') ? '' : '__') + name + '_';
+
+  const done = new Set();
+  const object = (name, props) => {
+    done.add(name);
+    const prefix = name === 'globalThis' ? '' : makePrefix(name);
+
+    // already a func
+    const existingFunc = builtinFuncs[name];
+
+    builtinFuncs['#get_' + name] = {
+      params: [],
+      locals: [ Valtype.i32 ],
+      returns: [ Valtype.i32 ],
+      returnType: TYPES.object,
+      wasm: (scope, { allocPage, makeString, generate, getNodeType, builtin, funcRef, glbl }) => {
+        if (globalThis.precompile) return [ [ 'get object', name ] ];
+
+        // todo/perf: precompute bytes here instead of calling real funcs if we really care about perf later
+
+        let ptr;
+        if (existingFunc) {
+          ptr = funcRef(name)[0][1];
+        } else {
+          ptr = allocPage(scope, `builtin object: ${name}`);
+        }
+
+        const getPtr = glbl(Opcodes.global_get, `getptr_${name}`, Valtype.i32)[0];
+        const out = [
+          // check if already made/cached
+          getPtr,
+          [ Opcodes.if, Blocktype.void ],
+            getPtr,
+            [ Opcodes.return ],
+          [ Opcodes.end ],
+
+          // set cache & ptr for use
+          number(ptr, Valtype.i32),
+          [ Opcodes.local_tee, 0 ],
+          glbl(Opcodes.global_set, `getptr_${name}`, Valtype.i32)[0],
+
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_from_u,
+          number(existingFunc ? TYPES.function : TYPES.object, Valtype.i32),
+          [ Opcodes.call, builtin('__Porffor_object_underlying') ],
+          [ Opcodes.drop ],
+          [ Opcodes.local_set, 0 ]
+        ];
+
+        for (const x in props) {
+          let value = {
+            type: 'Identifier',
+            name: prefix + x
+          };
+
+          if (x === '__proto__') {
+            out.push(
+              [ Opcodes.local_get, 0 ],
+              number(TYPES.object, Valtype.i32),
+
+              ...generate(scope, value),
+              Opcodes.i32_to_u,
+              ...getNodeType(scope, value),
+
+              [ Opcodes.call, builtin('__Porffor_object_setPrototype') ]
+            );
+            continue;
+          }
+
+          let add = true;
+          if (existingFunc && (x === 'prototype' || x === 'constructor')) add = false;
+
+          let flags = 0b0000;
+          const d = props[x];
+          if (d.configurable) flags |= 0b0010;
+          if (d.enumerable) flags |= 0b0100;
+          if (d.writable) flags |= 0b1000;
+
+          out.push(
+            [ Opcodes.local_get, 0 ],
+            number(TYPES.object, Valtype.i32),
+
+            ...makeString(scope, x),
+            Opcodes.i32_to_u,
+            number(TYPES.bytestring, Valtype.i32),
+
+            ...generate(scope, value),
+            ...getNodeType(scope, value),
+
+            number(flags, Valtype.i32),
+            number(TYPES.number, Valtype.i32),
+
+            [ Opcodes.call, builtin(add ? '__Porffor_object_fastAdd' : '__Porffor_object_define') ]
+          );
+        }
+
+        // return ptr
+        out.push(getPtr);
+        return out;
+      }
+    };
+
+    this[name] = (scope, { builtin }) => [
+      [ Opcodes.call, builtin('#get_' + name) ],
+      Opcodes.i32_from_u
+    ];
+    this[name].type = existingFunc ? TYPES.function : TYPES.object;
+
+    for (const x in props) {
+      const d = props[x];
+      const k = prefix + x;
+
+      if (Object.hasOwn(d, 'value') && !Object.hasOwn(builtinFuncs, k) && !Object.hasOwn(this, k)) {
+        if (Array.isArray(d.value) || typeof d.value === 'function') {
+          this[k] = d.value;
+          continue;
+        }
+
+        if (typeof d.value === 'number') {
+          this[k] = [ number(d.value) ];
+          this[k].type = TYPES.number;
+          continue;
+        }
+
+        if (typeof d.value === 'string') {
+          this[k] = (scope, { makeString }) => makeString(scope, d.value);
+          this[k].type = TYPES.bytestring;
+          continue;
+        }
+
+        if (d.value === null) {
+          this[k] = this.null;
+          continue;
+        }
+
+        throw new Error(`unsupported value type (${typeof d.value})`);
+      }
+    }
+  };
+
+  const props = (base, vals) => {
+    const out = {};
+
+    if (Array.isArray(vals)) {
+      // array of keys with no value
+      for (const x of vals) {
+        out[x] = {
+          ...base
+        };
+      }
+    } else for (const x in vals) {
+      // object of key values
+      out[x] = {
+        ...base,
+        value: vals[x]
+      };
+    }
+
+    return out;
+  };
+
+  const builtinFuncKeys = Object.keys(builtinFuncs);
+  const autoFuncKeys = name => {
+    const prefix = makePrefix(name);
+    return builtinFuncKeys.filter(x => x.startsWith(prefix)).map(x => x.slice(prefix.length)).filter(x => !x.startsWith('prototype_'));
+  };
+  const autoFuncs = name => ({
+    ...props({
+      writable: true,
+      enumerable: false,
+      configurable: true
+    }, autoFuncKeys(name)),
+    ...(this[`__${name}_prototype`] ? {
+      prototype: {
+        writable: false,
+        enumerable: false,
+        configurable: false
+      }
+    } : {})
+  });
+
+  object('Math', {
+    ...props({
+      writable: false,
+      enumerable: false,
+      configurable: false
+    }, {
+      E: Math.E,
+      LN10: Math.LN10,
+      LN2: Math.LN2,
+      LOG10E: Math.LOG10E,
+      LOG2E: Math.LOG2E,
+      PI: Math.PI,
+      SQRT1_2: Math.SQRT1_2,
+      SQRT2: Math.SQRT2,
+
+      // https://github.com/rwaldron/proposal-math-extensions/issues/10
+      RAD_PER_DEG: Math.PI / 180,
+      DEG_PER_RAD: 180 / Math.PI
+    }),
+
+    ...autoFuncs('Math')
+  });
+
+  // automatically generate objects for prototypes
+  for (const x of builtinFuncKeys.reduce((acc, x) => {
+    const ind = x.indexOf('_prototype_');
+    if (ind === -1) return acc;
+
+    acc.add(x.slice(0, ind + 10));
+    return acc;
+  }, new Set())) {
+    const props = autoFuncs(x);
+
+    // special case: Object.prototype.__proto__ = null
+    if (x === '__Object_prototype') {
+      Object.defineProperty(props, '__proto__', { value: { value: null, configurable: true }, enumerable: true });
+    }
+
+    // special case: Function.prototype.length = 0
+    // special case: Function.prototype.name = ''
+    if (x === '__Function_prototype') {
+      props.length = { value: 0, configurable: true };
+      props.name = { value: '', configurable: true };
+    }
+
+    // add constructor for constructors
+    const name = x.slice(2, x.indexOf('_', 2));
+    if (builtinFuncs[name]?.constr) {
+      const value = (scope, { funcRef }) => funcRef(name);
+      value.type = TYPES.function;
+
+      props.constructor = {
+        value,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      };
+    }
+
+    object(x, props);
+  }
+
+
+  object('Number', {
+    ...props({
+      writable: false,
+      enumerable: false,
+      configurable: false
+    }, {
+      NaN: NaN,
+      POSITIVE_INFINITY: Infinity,
+      NEGATIVE_INFINITY: -Infinity,
+      MAX_VALUE: valtype === 'i32' ? 2147483647 : 1.7976931348623157e+308,
+      MIN_VALUE: valtype === 'i32' ? -2147483648 : 5e-324,
+      MAX_SAFE_INTEGER: valtype === 'i32' ? 2147483647 : 9007199254740991,
+      MIN_SAFE_INTEGER: valtype === 'i32' ? -2147483648 : -9007199254740991,
+      EPSILON: 2.220446049250313e-16
+    }),
+
+    ...autoFuncs('Number')
+  });
+
+  // these technically not spec compliant as it should be classes or non-enumerable but eh
+  object('navigator', {
+    ...props({
+      writable: false,
+      enumerable: true,
+      configurable: false
+    }, {
+      userAgent: `Porffor/${globalThis.version}`
+    })
+  });
+
+  for (const x of [
+    'console',
+    'crypto',
+    'performance',
+  ]) {
+    object(x, props({
+      writable: true,
+      enumerable: true,
+      configurable: true
+    }, autoFuncKeys(x).slice(0, 12)));
+  }
+
+  for (const x of [ 'Array', 'ArrayBuffer', 'Atomics', 'Date', 'Error', 'JSON', 'Object', 'Promise', 'Reflect', 'String', 'Symbol', 'Uint8Array', 'Int8Array', 'Uint8ClampedArray', 'Uint16Array', 'Int16Array', 'Uint32Array', 'Int32Array', 'Float32Array', 'Float64Array', 'BigInt64Array', 'BigUint64Array', 'SharedArrayBuffer', 'BigInt', 'Boolean', 'DataView', 'AggregateError', 'TypeError', 'ReferenceError', 'SyntaxError', 'RangeError', 'EvalError', 'URIError', 'Function', 'Map', 'RegExp', 'Set', 'WeakMap', 'WeakRef', 'WeakSet' ]) {
+    object(x, autoFuncs(x));
+  }
+
+  const enumerableGlobals = [ 'atob', 'btoa', 'performance', 'crypto', 'navigator' ];
+  object('globalThis', {
+    // 19.1 Value Properties of the Global Object
+    // https://tc39.es/ecma262/#sec-value-properties-of-the-global-object
+    // 19.1.1 globalThis
+    globalThis: {
+      writable: true,
+      enumerable: false,
+      configurable: true
+    },
+
+    // 19.1.2 Infinity
+    // 19.1.3 NaN
+    // 19.1.4 undefined
+    ...props({
+      writable: false,
+      enumerable: false,
+      configurable: false
+    }, [ 'Infinity', 'NaN', 'undefined' ]),
+
+    // 19.2 Function Properties of the Global Object
+    // https://tc39.es/ecma262/#sec-function-properties-of-the-global-object
+    // 19.3 Constructor Properties of the Global Object
+    // https://tc39.es/ecma262/#sec-constructor-properties-of-the-global-object
+    ...props({
+      writable: true,
+      enumerable: false,
+      configurable: true
+    }, builtinFuncKeys.filter(x => !x.startsWith('__') && !enumerableGlobals.includes(x) && !x.startsWith('f64') && !x.startsWith('i32'))),
+
+    ...props({
+      writable: true,
+      enumerable: true,
+      configurable: true
+    }, enumerableGlobals)
+  });
+
+  if (Prefs.logMissingObjects) for (const x of Object.keys(builtinFuncs).concat(Object.keys(this))) {
+    if (!x.startsWith('__')) continue;
+    const name = x.split('_').slice(2, -1).join('_');
+
+    let t = globalThis;
+    for (const x of name.split('_')) {
+      t = t[x];
+      if (!t) break;
+    }
+    if (!t) continue;
+
+    if (!done.has(name) && !done.has('__' + name)) {
+      console.log(name, !!builtinFuncs[name]);
+      done.add(name);
+    }
+  }
 };
 
 export const BuiltinFuncs = function() {
@@ -820,7 +1162,7 @@ export const BuiltinFuncs = function() {
         number(funcs.bytesPerFuncLut(), Valtype.i32)
       ] ],
       [ Opcodes.i32_mul ],
-      [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocLargePage(scope, 'func lut')) ]
+      [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocLargePage(scope, '#func lut')) ]
     ],
     table: true
   };
@@ -837,7 +1179,7 @@ export const BuiltinFuncs = function() {
       [ Opcodes.i32_mul ],
       number(2, Valtype.i32),
       [ Opcodes.i32_add ],
-      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocLargePage(scope, 'func lut')) ]
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocLargePage(scope, '#func lut')) ]
     ],
     table: true
   };
@@ -854,7 +1196,7 @@ export const BuiltinFuncs = function() {
       [ Opcodes.i32_mul ],
       number(3, Valtype.i32),
       [ Opcodes.i32_add ],
-      number(allocLargePage(scope, 'func lut'), Valtype.i32),
+      number(allocLargePage(scope, '#func lut'), Valtype.i32),
       [ Opcodes.i32_add ]
     ],
     table: true

package/compiler/codegen.js

@@ -5,9 +5,68 @@ import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './bui
 import { TYPES, TYPE_FLAGS, TYPE_NAMES } from './types.js';
 import parse from './parse.js';
 import { log } from './log.js';
-import { allocPage, allocStr } from './allocator.js';
 import './prefs.js';
 
+const pagePtr = ind => {
+  if (ind === 0) return 16;
+  return ind * pageSize;
+};
+
+const allocPage = (scope, name) => {
+  if (!name.startsWith('#')) {
+    name = `${scope.name}/${name}`;
+    if (globalThis.precompile) name = `${globalThis.precompile}/${name}`;
+  }
+
+  if (pages.has(name)) {
+    return pagePtr(pages.get(name));
+  }
+
+  const ind = pages.size;
+  pages.set(name, ind);
+
+  scope.pages ??= new Map();
+  scope.pages.set(name, ind);
+
+  return pagePtr(ind);
+};
+
+const allocBytes = (scope, reason, bytes) => {
+  bytes += 2; // overallocate by 2 bytes to ensure null termination
+
+  const allocs = pages.allocs ??= new Map();
+  const bins = pages.bins ??= [];
+
+  if (allocs.has(reason)) {
+    return allocs.get(reason);
+  }
+
+  let bin = bins.find(x => (pageSize - x.used) >= bytes);
+  if (!bin) {
+    // new bin
+    const page = pages.size;
+    bin = {
+      used: 0,
+      page
+    };
+
+    const id = bins.push(bin);
+    pages.set(`#bin: ${id}`, page);
+  }
+
+  const ptr = pagePtr(bin.page) + bin.used;
+  bin.used += bytes;
+
+  allocs.set(reason, ptr);
+  return ptr;
+};
+
+export const allocStr = (scope, str, bytestring) => {
+  // basic string interning for ~free
+  const bytes = 4 + str.length * (bytestring ? 1 : 2);
+  return allocBytes(scope, str, bytes);
+};
+
 const todo = (scope, msg, expectsValue = undefined) => {
   msg = `todo: ${msg}`;
 
@@ -1465,10 +1524,10 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
     wasm.push(Opcodes.i32_to_u);
     return wasm;
   },
-  allocPage: (scope, name) => allocPage({ scope, pages }, name),
+  allocPage,
   allocLargePage: (scope, name) => {
-    const _ = allocPage({ scope, pages }, name);
-    allocPage({ scope, pages }, name + '#2');
+    const _ = allocPage(scope, name);
+    allocPage(scope, name + '#2');
 
     return _;
   }
@@ -2638,7 +2697,8 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       args.push({
         type: 'ArrayExpression',
         elements: restArgs,
-        _doNotMarkTypeUsed: true
+        _doNotMarkTypeUsed: true,
+        _staticAlloc: func.internal
       });
     }
   }
@@ -5581,7 +5641,7 @@ const makeString = (scope, str, bytestring = true) => {
     if (c > 0xFF) bytestring = false;
   }
 
-  const ptr = allocStr({ scope, pages }, str, bytestring);
+  const ptr = allocStr(scope, str, bytestring);
   makeData(scope, elements, str, bytestring ? 'i8' : 'i16');
 
   return [ number(ptr) ];
@@ -5594,10 +5654,10 @@ const generateArray = (scope, decl, global = false, name = '$undeclared', static
   const out = [];
   let pointer;
 
-  if (staticAlloc) {
+  if (staticAlloc || decl._staticAlloc) {
     const uniqueName = name === '$undeclared' ? name + uniqId() : name;
 
-    const ptr = allocPage({ scope, pages }, uniqueName);
+    const ptr = allocPage(scope, uniqueName);
     pointer = number(ptr, Valtype.i32);
 
     scope.arrays ??= new Map();

package/compiler/precompile.js

@@ -57,7 +57,7 @@ const compile = async (file, _funcs) => {
     first = source.slice(0, source.indexOf('\n'));
   }
 
-  let args = ['--module', '--todo-time=compile', '--truthy=no_nan_negative', '--no-rm-unused-types', '--scoped-page-names', '--fast-length', '--parse-types', '--opt-types', '--no-passive-data', '--active-data', '--no-treeshake-wasm-imports', '--no-coctc'];
+  let args = ['--module', '--todo-time=compile', '--truthy=no_nan_negative', '--no-rm-unused-types', '--fast-length', '--parse-types', '--opt-types', '--no-passive-data', '--active-data', '--no-treeshake-wasm-imports', '--no-coctc'];
   if (first.startsWith('// @porf')) {
     args = first.slice('// @porf '.length).split(' ').concat(args);
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.60.6",
+  "version": "0.60.8",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/runtime/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.60.6';
+globalThis.version = '0.60.8';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {

package/AGENT.md

@@ -1,20 +0,0 @@
-you are an assistant coder for Porffor - an early javascript and typescript to webassembly and native ahead-of-time compiler. the codebase is written in js and ts.
-
-- built-ins apis (Date, String.prototype, etc) are written in ts inside `compiler/builtins`
-- once you update a file inside that directory, you MUST run `./porf precompile` to compile to make your changes effective
-- test your work using the test262 tools available, iterate independently but do not get stuck on one chain of thought or approach. paths for test262 tools should be relative to the 'test262/test' directory (e.g., 'built-ins/RegExp' NOT 'test262/test/built-ins/RegExp').
-- to get an overview of the most failing directories, use the command: `node test262/fails.cjs`
-- to just evaluate code in the engine, use the command: `./porf -p "..."`
-- after finishing, check if your work/diff could be simplified
-- always use single quotes (unless double is required)
-- 2-space indentation, LF line endings, no trailing whitespace
-- built-in APIs in `compiler/builtins/` written in TypeScript
-- inline code in built-ins, avoid helper functions
-- use semicolons
-- do not use trailing commas
-- use const/let, avoid var
-- follow existing naming: camelCase for variables, PascalCase for types
-- when possible, do not concat strings and instead write to them directly using wasm memory
-- there are no closures, you cannot use locals between functions. use arguments or globals if really necessary
-- The user prefers that prototype functions not have explicit return types in this codebase.
-- The user prefers not to use global variables in built-in functions.

package/compiler/allocator.js

@@ -1,65 +0,0 @@
-import './prefs.js';
-
-const pagePtr = ind => {
-  if (ind === 0) return 16;
-  return ind * pageSize;
-};
-
-export const nameToReason = (scope, name) => {
-  let scopeName = scope.name;
-  if (globalThis.precompile && scopeName === '#main') scopeName = globalThis.precompile;
-
-  return `${Prefs.scopedPageNames ? (scopeName + '/') : ''}${name}`;
-};
-
-export const allocPage = ({ scope, pages }, name) => {
-  const reason = nameToReason(scope, name);
-
-  if (pages.has(reason)) {
-    return pagePtr(pages.get(reason));
-  }
-
-  const ind = pages.size;
-  pages.set(reason, ind);
-
-  scope.pages ??= new Map();
-  scope.pages.set(reason, ind);
-
-  return pagePtr(ind);
-};
-
-export const allocBytes = ({ scope, pages }, reason, bytes) => {
-  bytes += 2; // overallocate by 2 bytes to ensure null termination
-
-  const allocs = pages.allocs ??= new Map();
-  const bins = pages.bins ??= [];
-
-  if (allocs.has(reason)) {
-    return allocs.get(reason);
-  }
-
-  let bin = bins.find(x => (pageSize - x.used) >= bytes);
-  if (!bin) {
-    // new bin
-    const page = pages.size;
-    bin = {
-      used: 0,
-      page
-    };
-
-    const id = bins.push(bin);
-    pages.set(`#bin: ${id}`, page);
-  }
-
-  const ptr = pagePtr(bin.page) + bin.used;
-  bin.used += bytes;
-
-  allocs.set(reason, ptr);
-  return ptr;
-};
-
-export const allocStr = ({ scope, pages }, str, bytestring) => {
-  // basic string interning for ~free
-  const bytes = 4 + str.length * (bytestring ? 1 : 2);
-  return allocBytes({ scope, pages }, str, bytes);
-};

package/compiler/builtins_objects.js

@@ -1,349 +0,0 @@
-import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
-import { TYPES } from './types.js';
-import { number } from './encoding.js';
-
-export default function ({ builtinFuncs }, Prefs) {
-  const makePrefix = name => (name.startsWith('__') ? '' : '__') + name + '_';
-
-  const done = new Set();
-  const object = (name, props) => {
-    done.add(name);
-    const prefix = name === 'globalThis' ? '' : makePrefix(name);
-
-    // already a func
-    const existingFunc = builtinFuncs[name];
-
-    builtinFuncs['#get_' + name] = {
-      params: [],
-      locals: [ Valtype.i32 ],
-      returns: [ Valtype.i32 ],
-      returnType: TYPES.object,
-      wasm: (scope, { allocPage, makeString, generate, getNodeType, builtin, funcRef, glbl }) => {
-        if (globalThis.precompile) return [ [ 'get object', name ] ];
-
-        // todo/perf: precompute bytes here instead of calling real funcs if we really care about perf later
-
-        let ptr;
-        if (existingFunc) {
-          ptr = funcRef(name)[0][1];
-        } else {
-          ptr = allocPage(scope, `builtin object: ${name}`);
-        }
-
-        const getPtr = glbl(Opcodes.global_get, `getptr_${name}`, Valtype.i32)[0];
-        const out = [
-          // check if already made/cached
-          getPtr,
-          [ Opcodes.if, Blocktype.void ],
-            getPtr,
-            [ Opcodes.return ],
-          [ Opcodes.end ],
-
-          // set cache & ptr for use
-          number(ptr, Valtype.i32),
-          [ Opcodes.local_tee, 0 ],
-          glbl(Opcodes.global_set, `getptr_${name}`, Valtype.i32)[0],
-
-          [ Opcodes.local_get, 0 ],
-          Opcodes.i32_from_u,
-          number(existingFunc ? TYPES.function : TYPES.object, Valtype.i32),
-          [ Opcodes.call, builtin('__Porffor_object_underlying') ],
-          [ Opcodes.drop ],
-          [ Opcodes.local_set, 0 ]
-        ];
-
-        for (const x in props) {
-          let value = {
-            type: 'Identifier',
-            name: prefix + x
-          };
-
-          if (x === '__proto__') {
-            out.push(
-              [ Opcodes.local_get, 0 ],
-              number(TYPES.object, Valtype.i32),
-
-              ...generate(scope, value),
-              Opcodes.i32_to_u,
-              ...getNodeType(scope, value),
-
-              [ Opcodes.call, builtin('__Porffor_object_setPrototype') ]
-            );
-            continue;
-          }
-
-          let add = true;
-          if (existingFunc && (x === 'prototype' || x === 'constructor')) add = false;
-
-          let flags = 0b0000;
-          const d = props[x];
-          if (d.configurable) flags |= 0b0010;
-          if (d.enumerable) flags |= 0b0100;
-          if (d.writable) flags |= 0b1000;
-
-          out.push(
-            [ Opcodes.local_get, 0 ],
-            number(TYPES.object, Valtype.i32),
-
-            ...makeString(scope, x),
-            Opcodes.i32_to_u,
-            number(TYPES.bytestring, Valtype.i32),
-
-            ...generate(scope, value),
-            ...getNodeType(scope, value),
-
-            number(flags, Valtype.i32),
-            number(TYPES.number, Valtype.i32),
-
-            [ Opcodes.call, builtin(add ? '__Porffor_object_fastAdd' : '__Porffor_object_define') ]
-          );
-        }
-
-        // return ptr
-        out.push(getPtr);
-        return out;
-      }
-    };
-
-    this[name] = (scope, { builtin }) => [
-      [ Opcodes.call, builtin('#get_' + name) ],
-      Opcodes.i32_from_u
-    ];
-    this[name].type = existingFunc ? TYPES.function : TYPES.object;
-
-    for (const x in props) {
-      const d = props[x];
-      const k = prefix + x;
-
-      if (Object.hasOwn(d, 'value') && !Object.hasOwn(builtinFuncs, k) && !Object.hasOwn(this, k)) {
-        if (Array.isArray(d.value) || typeof d.value === 'function') {
-          this[k] = d.value;
-          continue;
-        }
-
-        if (typeof d.value === 'number') {
-          this[k] = [ number(d.value) ];
-          this[k].type = TYPES.number;
-          continue;
-        }
-
-        if (typeof d.value === 'string') {
-          this[k] = (scope, { makeString }) => makeString(scope, d.value);
-          this[k].type = TYPES.bytestring;
-          continue;
-        }
-
-        if (d.value === null) {
-          this[k] = this.null;
-          continue;
-        }
-
-        throw new Error(`unsupported value type (${typeof d.value})`);
-      }
-    }
-  };
-
-  const props = (base, vals) => {
-    const out = {};
-
-    if (Array.isArray(vals)) {
-      // array of keys with no value
-      for (const x of vals) {
-        out[x] = {
-          ...base
-        };
-      }
-    } else for (const x in vals) {
-      // object of key values
-      out[x] = {
-        ...base,
-        value: vals[x]
-      };
-    }
-
-    return out;
-  };
-
-  const builtinFuncKeys = Object.keys(builtinFuncs);
-  const autoFuncKeys = name => {
-    const prefix = makePrefix(name);
-    return builtinFuncKeys.filter(x => x.startsWith(prefix)).map(x => x.slice(prefix.length)).filter(x => !x.startsWith('prototype_'));
-  };
-  const autoFuncs = name => ({
-    ...props({
-      writable: true,
-      enumerable: false,
-      configurable: true
-    }, autoFuncKeys(name)),
-    ...(this[`__${name}_prototype`] ? {
-      prototype: {
-        writable: false,
-        enumerable: false,
-        configurable: false
-      }
-    } : {})
-  });
-
-  object('Math', {
-    ...props({
-      writable: false,
-      enumerable: false,
-      configurable: false
-    }, {
-      E: Math.E,
-      LN10: Math.LN10,
-      LN2: Math.LN2,
-      LOG10E: Math.LOG10E,
-      LOG2E: Math.LOG2E,
-      PI: Math.PI,
-      SQRT1_2: Math.SQRT1_2,
-      SQRT2: Math.SQRT2,
-
-      // https://github.com/rwaldron/proposal-math-extensions/issues/10
-      RAD_PER_DEG: Math.PI / 180,
-      DEG_PER_RAD: 180 / Math.PI
-    }),
-
-    ...autoFuncs('Math')
-  });
-
-  // automatically generate objects for prototypes
-  for (const x of builtinFuncKeys.reduce((acc, x) => {
-    const ind = x.indexOf('_prototype_');
-    if (ind === -1) return acc;
-
-    acc.add(x.slice(0, ind + 10));
-    return acc;
-  }, new Set())) {
-    const props = autoFuncs(x);
-
-    // special case: Object.prototype.__proto__ = null
-    if (x === '__Object_prototype') {
-      Object.defineProperty(props, '__proto__', { value: { value: null, configurable: true }, enumerable: true });
-    }
-
-    // special case: Function.prototype.length = 0
-    // special case: Function.prototype.name = ''
-    if (x === '__Function_prototype') {
-      props.length = { value: 0, configurable: true };
-      props.name = { value: '', configurable: true };
-    }
-
-    // add constructor for constructors
-    const name = x.slice(2, x.indexOf('_', 2));
-    if (builtinFuncs[name]?.constr) {
-      const value = (scope, { funcRef }) => funcRef(name);
-      value.type = TYPES.function;
-
-      props.constructor = {
-        value,
-        writable: true,
-        enumerable: false,
-        configurable: true
-      };
-    }
-
-    object(x, props);
-  }
-
-
-  object('Number', {
-    ...props({
-      writable: false,
-      enumerable: false,
-      configurable: false
-    }, {
-      NaN: NaN,
-      POSITIVE_INFINITY: Infinity,
-      NEGATIVE_INFINITY: -Infinity,
-      MAX_VALUE: valtype === 'i32' ? 2147483647 : 1.7976931348623157e+308,
-      MIN_VALUE: valtype === 'i32' ? -2147483648 : 5e-324,
-      MAX_SAFE_INTEGER: valtype === 'i32' ? 2147483647 : 9007199254740991,
-      MIN_SAFE_INTEGER: valtype === 'i32' ? -2147483648 : -9007199254740991,
-      EPSILON: 2.220446049250313e-16
-    }),
-
-    ...autoFuncs('Number')
-  });
-
-  // these technically not spec compliant as it should be classes or non-enumerable but eh
-  object('navigator', {
-    ...props({
-      writable: false,
-      enumerable: true,
-      configurable: false
-    }, {
-      userAgent: `Porffor/${globalThis.version}`
-    })
-  });
-
-  for (const x of [
-    'console',
-    'crypto',
-    'performance',
-  ]) {
-    object(x, props({
-      writable: true,
-      enumerable: true,
-      configurable: true
-    }, autoFuncKeys(x).slice(0, 12)));
-  }
-
-  for (const x of [ 'Array', 'ArrayBuffer', 'Atomics', 'Date', 'Error', 'JSON', 'Object', 'Promise', 'Reflect', 'String', 'Symbol', 'Uint8Array', 'Int8Array', 'Uint8ClampedArray', 'Uint16Array', 'Int16Array', 'Uint32Array', 'Int32Array', 'Float32Array', 'Float64Array', 'BigInt64Array', 'BigUint64Array', 'SharedArrayBuffer', 'BigInt', 'Boolean', 'DataView', 'AggregateError', 'TypeError', 'ReferenceError', 'SyntaxError', 'RangeError', 'EvalError', 'URIError', 'Function', 'Map', 'RegExp', 'Set', 'WeakMap', 'WeakRef', 'WeakSet' ]) {
-    object(x, autoFuncs(x));
-  }
-
-  const enumerableGlobals = [ 'atob', 'btoa', 'performance', 'crypto', 'navigator' ];
-  object('globalThis', {
-    // 19.1 Value Properties of the Global Object
-    // https://tc39.es/ecma262/#sec-value-properties-of-the-global-object
-    // 19.1.1 globalThis
-    globalThis: {
-      writable: true,
-      enumerable: false,
-      configurable: true
-    },
-
-    // 19.1.2 Infinity
-    // 19.1.3 NaN
-    // 19.1.4 undefined
-    ...props({
-      writable: false,
-      enumerable: false,
-      configurable: false
-    }, [ 'Infinity', 'NaN', 'undefined' ]),
-
-    // 19.2 Function Properties of the Global Object
-    // https://tc39.es/ecma262/#sec-function-properties-of-the-global-object
-    // 19.3 Constructor Properties of the Global Object
-    // https://tc39.es/ecma262/#sec-constructor-properties-of-the-global-object
-    ...props({
-      writable: true,
-      enumerable: false,
-      configurable: true
-    }, builtinFuncKeys.filter(x => !x.startsWith('__') && !enumerableGlobals.includes(x) && !x.startsWith('f64') && !x.startsWith('i32'))),
-
-    ...props({
-      writable: true,
-      enumerable: true,
-      configurable: true
-    }, enumerableGlobals)
-  });
-
-  if (Prefs.logMissingObjects) for (const x of Object.keys(builtinFuncs).concat(Object.keys(this))) {
-    if (!x.startsWith('__')) continue;
-    const name = x.split('_').slice(2, -1).join('_');
-
-    let t = globalThis;
-    for (const x of name.split('_')) {
-      t = t[x];
-      if (!t) break;
-    }
-    if (!t) continue;
-
-    if (!done.has(name) && !done.has('__' + name)) {
-      console.log(name, !!builtinFuncs[name]);
-      done.add(name);
-    }
-  }
-};