porffor 0.16.0-688a50c13 → 0.16.0-7339fdd79

package/compiler/builtins/z_ecma262.ts

@@ -0,0 +1,62 @@
+// general widely used ecma262/spec functions
+
+// 7.1.5 ToIntegerOrInfinity (argument)
+// https://tc39.es/ecma262/#sec-tointegerorinfinity
+export const __ecma262_ToIntegerOrInfinity = (argument: unknown): number => {
+  // 1. Let number be ? ToNumber(argument).
+  let number: number = Number(argument);
+
+  // 2. If number is one of NaN, +0𝔽, or -0𝔽, return 0.
+  if (Number.isNaN(number)) return 0;
+
+  // 3. If number is +∞𝔽, return +∞.
+  // 4. If number is -∞𝔽, return -∞.
+  if (!Number.isFinite(number)) return number;
+
+  // 5. Return truncate(ℝ(number)).
+  number = Math.trunc(number);
+
+  // return 0 for -0
+  if (number == 0) return 0;
+  return number;
+};
+
+// todo: support non-bytestring properly
+// 7.1.17 ToString (argument)
+// https://tc39.es/ecma262/#sec-tostring
+export const __ecma262_ToString = (argument: unknown): bytestring => {
+  let out: bytestring = '';
+  const type: i32 = Porffor.rawType(argument);
+
+  // 1. If argument is a String, return argument.
+  if (Porffor.fastOr(
+    type == Porffor.TYPES.string,
+    type == Porffor.TYPES.bytestring)) return argument;
+
+  // 2. If argument is a Symbol, throw a TypeError exception.
+  if (type == Porffor.TYPES.symbol) throw new TypeError('Cannot convert a Symbol value to a string');
+
+  // 3. If argument is undefined, return "undefined".
+  if (type == Porffor.TYPES.undefined) return out = 'undefined';
+
+  // 4. If argument is null, return "null".
+  if (Porffor.fastAnd(
+    type == Porffor.TYPES.object,
+    argument == 0)) return out = 'null';
+
+  if (type == Porffor.TYPES.boolean) {
+    // 5. If argument is true, return "true".
+    if (argument == true) return out = 'true';
+
+    // 6. If argument is false, return "false".
+    return out = 'false';
+  }
+
+  // 7. If argument is a Number, return Number::toString(argument, 10).
+  // 8. If argument is a BigInt, return BigInt::toString(argument, 10).
+  // 9. Assert: argument is an Object.
+  // 10. Let primValue be ? ToPrimitive(argument, string).
+  // 11. Assert: primValue is not an Object.
+  // 12. Return ? ToString(primValue).
+  return argument.toString();
+};

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,9 +426,9 @@ 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);
+  }, assign ? false : global, assign ? undefined : name, true, 'i16', true);
 
   return [
     // setup left
@@ -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) ],
@@ -963,12 +958,9 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
       [ Opcodes.end ],
     ]));
 
-    // if not already in block, add a block
-    // if (endOut.length === 0) {
-      startOut.push(stringOnly([ Opcodes.block, Valtype.i32 ]));
-      // endOut.push(stringOnly([ Opcodes.end ]));
-      endOut.unshift(stringOnly([ Opcodes.end ]));
-    // }
+    // add a surrounding block
+    startOut.push(stringOnly([ Opcodes.block, Valtype.i32 ]));
+    endOut.unshift(stringOnly([ Opcodes.end ]));
   }
 
   return finalize([
@@ -1003,7 +995,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 +1009,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);
   }
 
@@ -1271,7 +1263,15 @@ const getNodeType = (scope, node) => {
     }
 
     if (node.type === 'AssignmentExpression') {
-      return getNodeType(scope, node.right);
+      const op = node.operator.slice(0, -1) || '=';
+      if (op === '=') return getNodeType(scope, node.right);
+
+      return getNodeType(scope, {
+        type: ['||', '&&', '??'].includes(op) ? 'LogicalExpression' : 'BinaryExpression',
+        left: node.left,
+        right: node.right,
+        operator: op
+      });
     }
 
     if (node.type === 'ArrayExpression') {
@@ -1290,23 +1290,6 @@ const getNodeType = (scope, node) => {
       if (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring) return TYPES.bytestring;
 
       return TYPES.number;
-
-      // todo: string concat types
-      // if (node.operator !== '+') return TYPES.number;
-      //   else return [
-      //     // if left is string
-      //     ...getNodeType(scope, node.left),
-      //     ...number(TYPES.string, Valtype.i32),
-      //     [ Opcodes.i32_eq ],
-
-      //     // if right is string
-      //     ...getNodeType(scope, node.right),
-      //     ...number(TYPES.string, Valtype.i32),
-      //     [ Opcodes.i32_eq ],
-
-      //     // if either are true
-      //     [ Opcodes.i32_or ],
-      //   ];
     }
 
     if (node.type === 'UnaryExpression') {
@@ -1326,7 +1309,6 @@ const getNodeType = (scope, node) => {
         if (Prefs.fastLength) return TYPES.number;
       }
 
-
       const objectKnownType = knownType(scope, getNodeType(scope, node.object));
       if (objectKnownType != null) {
         if (name === 'length') {
@@ -1337,7 +1319,6 @@ const getNodeType = (scope, node) => {
         if (node.computed) {
           if (objectKnownType === TYPES.string) return TYPES.string;
           if (objectKnownType === TYPES.bytestring) return TYPES.bytestring;
-          if (objectKnownType === TYPES.array) return TYPES.number;
         }
       }
 
@@ -1403,10 +1384,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]);
@@ -1951,13 +1932,18 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       continue;
     }
 
-    if (valtypeBinary !== Valtype.i32 && (
+    if (valtypeBinary !== Valtype.i32 &&
       (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32)
-      // (importedFuncs[name] && name.startsWith('profile'))
-    )) {
+    ) {
       out.push(Opcodes.i32_to);
     }
 
+    if (valtypeBinary === Valtype.i32 &&
+      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.f64)
+    ) {
+      out.push(Opcodes.f64_convert_i32_s);
+    }
+
     if (typedParams) out = out.concat(getNodeType(scope, arg));
   }
 
@@ -1979,6 +1965,10 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     out.push(Opcodes.i32_from);
   }
 
+  if (builtinFuncs[name] && builtinFuncs[name].returns?.[0] === Valtype.f64 && valtypeBinary === Valtype.i32) {
+    out.push(Opcodes.i32_trunc_sat_f64_s);
+  }
+
   return out;
 };
 
@@ -2002,9 +1992,9 @@ const generateNew = (scope, decl, _global, _name) => {
   if (
     (builtinFuncs[name] && !builtinFuncs[name].constr) ||
     (internalConstrs[name] && builtinFuncs[name].notConstr)
-  ) return internalThrow(scope, 'TypeError', `${name} is not a constructor`);
+  ) return internalThrow(scope, 'TypeError', `${name} is not a constructor`, true);
 
-  if (!builtinFuncs[name]) return todo(scope, `new statement is not supported yet`); // return todo(scope, `new statement is not supported yet (new ${unhackName(name)})`);
+  if (!builtinFuncs[name]) return todo(scope, `new statement is not supported yet`, true); // return todo(scope, `new statement is not supported yet (new ${unhackName(name)})`);
 
   return generateCall(scope, decl, _global, _name);
 };
@@ -2452,9 +2442,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
     [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
     [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
 
-    // todo: string concat types
-
-    ...setType(scope, name, TYPES.number)
+    ...setType(scope, name, getNodeType(scope, decl))
   ];
 };
 
@@ -3117,8 +3105,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 +3142,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 +3201,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 +3253,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 ];
@@ -3479,7 +3521,7 @@ const generateMember = (scope, decl, _global, _name) => {
   // // todo: we should only do this for strings but we don't know at compile-time :(
   // hack: this is naughty and will break things!
   let newOut = number(0, Valtype.i32), newPointer = number(0, Valtype.i32);
-  if (pages.hasAnyString) {
+  if (pages.hasAnyString && knownType(scope, getNodeType(scope, decl.object)) !== TYPES.array) {
     // todo: we use i16 even for bytestrings which should not make a bad thing happen, just be confusing for debugging?
     0, [ newOut, newPointer ] = makeArray(scope, {
       rawElements: new Array(0)
@@ -3694,9 +3736,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 +3747,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 +3937,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' };