porffor 0.47.6 → 0.47.7

package/compiler/2c.js

@@ -2,7 +2,7 @@ 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 {} from './prefs.js';
+import './prefs.js';
 
 const CValtype = {
   i8: 'u8',
@@ -222,7 +222,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
   const activeData = data.filter(x => x.page != null);
   if (activeData.length > 0) {
-    const dataOffset = x => pages.get(x.page).ind * pageSize;
+    const dataOffset = x => pages.allocs.get(x.page) ?? (pages.get(x.page) * pageSize);
     if (Prefs['2cMemcpy']) {
       prependMain.set('_data', activeData.map(x => `memcpy(_memory + ${dataOffset(x)}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n  '));
     } else {
@@ -857,7 +857,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}(i32 align, i32 offset, ${func.args.map((x, i) => `${func.argTypes[i]} ${x}`).join(', ')}) {\n  ${func.c.replaceAll('\n', '\n  ')}\n}\n`);
+              prepend.set(name, `inline ${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)) ];
@@ -915,5 +915,5 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
   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 `// generated by porffor ${globalThis.version ?? '0.17.0'}\n` + out.trim();
+  return `// generated by porffor ${globalThis.version}\n` + out.trim();
 };

package/compiler/allocator.js

@@ -0,0 +1,64 @@
+import { PageSize } from './wasmSpec.js';
+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) => {
+  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/assemble.js

@@ -2,7 +2,7 @@ import { Valtype, FuncType, ExportDesc, Section, Magic, ModuleVersion, Opcodes,
 import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128, unsignedLEB128_into, signedLEB128_into, ieee754_binary64, ieee754_binary64_into } from './encoding.js';
 import { importedFuncs } from './builtins.js';
 import { log } from './log.js';
-import {} from './prefs.js';
+import './prefs.js';
 
 const createSection = (type, data) => [
   type,
@@ -372,7 +372,7 @@ export default (funcs, globals, tags, pages, data, noTreeshake = false) => {
       const bytes = unsignedLEB128(x.bytes.length).concat(x.bytes);
       if (x.page != null) {
         // type: active
-        let offset = pages.get(x.page).ind * pageSize;
+        let offset = pages.allocs.get(x.page) ?? (pages.get(x.page) * pageSize);
         if (offset === 0) offset = 16;
         bytes.unshift(0x00, Opcodes.i32_const, ...signedLEB128(offset), Opcodes.end);
       } else {

package/compiler/builtins/__internal_string.ts

@@ -158,44 +158,127 @@ end`;
       return true;
     } else {
       // string, string
-      let ap: i32 = a - 4;
-      let bp: i32 = b - 4;
+      // change char lengths to byte lengths
+      al *= 2;
+      bl *= 2;
+
+      // copied from bytestring, bytestring
+      let ap32: i32 = a - 28;
+      let bp32: i32 = b - 28;
+      let ap8: i32 = a - 4;
+      let bp8: i32 = b - 4;
       Porffor.wasm`
-loop 64
-  local.get ${ap}
-  local.get ${al}
-  i32.const 2
-  i32.mul
-  i32.add
-  i64.load 0 0
-
-  local.get ${bp}
-  local.get ${al}
-  i32.const 2
-  i32.mul
-  i32.add
-  i64.load 0 0
-
-  i64.ne
-  if 64
-    i32.const 0
-    i32.const 2
-    return
+;; load in 2 i64x2 chunks while length >= 32
+local.get ${al}
+i32.const 32
+i32.ge_s
+if 64
+  loop 64
+    local.get ${ap32}
+    local.get ${al}
+    i32.add
+    v128.load 0 0
+
+    local.get ${bp32}
+    local.get ${al}
+    i32.add
+    v128.load 0 0
+    v128.xor
+
+    local.get ${ap32}
+    local.get ${al}
+    i32.add
+    v128.load 0 16
+
+    local.get ${bp32}
+    local.get ${al}
+    i32.add
+    v128.load 0 16
+    v128.xor
+
+    v128.or
+    v128.any_true
+    if 64
+      i32.const 0
+      i32.const 2
+      return
+    end
+
+    local.get ${al}
+    i32.const 32
+    i32.sub
+    local.tee ${al}
+    i32.const 32
+    i32.ge_s
+    br_if 0
   end
+end
 
-  local.get ${al}
-  i32.const 4
-  i32.sub
-  local.tee ${al}
-  i32.const 4
-  i32.ge_s
-  br_if 0
-end`;
+;; load in i64 chunks while length >= 8
+local.get ${al}
+i32.const 8
+i32.ge_s
+if 64
+  loop 64
+    local.get ${ap8}
+    local.get ${al}
+    i32.add
+    i64.load 0 0
 
-      for (let i: i32 = 0; i < al; i++) {
-        if (Porffor.wasm.i32.load16_u(Porffor.wasm`local.get ${a}` + i*2, 0, 4) !=
-            Porffor.wasm.i32.load16_u(Porffor.wasm`local.get ${b}` + i*2, 0, 4)) return false;
-      }
+    local.get ${bp8}
+    local.get ${al}
+    i32.add
+    i64.load 0 0
+
+    i64.ne
+    if 64
+      i32.const 0
+      i32.const 2
+      return
+    end
+
+    local.get ${al}
+    i32.const 8
+    i32.sub
+    local.tee ${al}
+    i32.const 8
+    i32.ge_s
+    br_if 0
+  end
+end
+
+;; load in u16 chunks while length >= 2
+local.get ${al}
+i32.const 2
+i32.ge_s
+if 64
+  loop 64
+    local.get ${a}
+    local.get ${al}
+    i32.add
+    i32.load16_u 0 2
+
+    local.get ${b}
+    local.get ${al}
+    i32.add
+    i32.load16_u 0 2
+
+    i32.ne
+    if 64
+      i32.const 0
+      i32.const 2
+      return
+    end
+
+    local.get ${al}
+    i32.const 2
+    i32.sub
+    local.tee ${al}
+    i32.const 2
+    i32.ge_s
+    br_if 0
+  end
+end`;
       return true;
     }
   }

package/compiler/builtins/function.ts

@@ -1,7 +1,16 @@
 import type {} from './porffor.d.ts';
 
 export const __Function_prototype_toString = (_this: Function) => {
-  // todo: actually use source
-  let out: bytestring = 'function () {}';
+  const out: bytestring = Porffor.allocate();
+
+  const prefix: bytestring = 'function ';
+  Porffor.bytestring.appendStr(out, prefix);
+
+  Porffor.bytestring.appendStr(out, _this.name);
+
+  const postfix: bytestring = '() { [native code] }';
+  Porffor.bytestring.appendStr(out, postfix);
   return out;
-};
+};
+
+export const __Function_prototype_toLocaleString = (_this: Function) => __Function_prototype_toString(_this);

package/compiler/builtins.js

@@ -3,7 +3,7 @@ import ObjectBuiltins from './builtins_objects.js';
 import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
 import { number } from './embedding.js';
 import { TYPES, TYPE_NAMES } from './types.js';
-import {} from './prefs.js';
+import './prefs.js';
 import { unsignedLEB128 } from './encoding.js';
 
 export const importedFuncs = [
@@ -860,7 +860,7 @@ export const BuiltinFuncs = function() {
     wasm: (scope, { typeSwitch, makeString }) => {
       const bc = {};
       for (const x in TYPE_NAMES) {
-        bc[x] = makeString(scope, TYPE_NAMES[x], false, '#Porffor_type_result');
+        bc[x] = makeString(scope, TYPE_NAMES[x]);
       }
 
       return typeSwitch(scope, [ [ Opcodes.local_get, 1 ] ], bc);

package/compiler/builtins_objects.js

@@ -64,7 +64,7 @@ export default function({ builtinFuncs }, Prefs) {
             getPtr,
             ...number(existingFunc ? TYPES.function : TYPES.object, Valtype.i32),
 
-            ...makeString(scope, x, false, `#builtin_object_${name}_${x}`),
+            ...makeString(scope, x),
             Opcodes.i32_to_u,
             ...number(TYPES.bytestring, Valtype.i32),
 
@@ -109,7 +109,7 @@ export default function({ builtinFuncs }, Prefs) {
         }
 
         if (typeof d.value === 'string') {
-          this[k] = (scope, { makeString }) => makeString(scope, d.value, false, k);
+          this[k] = (scope, { makeString }) => makeString(scope, d.value);
           this[k].type = TYPES.bytestring;
           continue;
         }