porffor 0.20.1 → 0.20.2

package/compiler/2c.js

@@ -231,6 +231,20 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
     prependMain.set('argv', `_argc = argc; _argv = argv;`);
   }
 
+  prepend.set('func decls', funcs.filter(x => x.name !== 'main').map(f => {
+    const returns = f.returns.length > 0;
+    const typedReturns = f.returnType == null;
+
+    const invLocals = inv(f.locals, x => x.idx);
+    for (const x in invLocals) {
+      invLocals[x] = sanitize(invLocals[x]);
+    }
+
+    const shouldInline = false;
+
+    return `${!typedReturns ? (returns ? CValtype[f.returns[0]] : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')});`;
+  }).join('\n'));
+
   if (out) out += '\n';
 
   const line = (str, semi = true) => out += `${str}${semi ? ';' : ''}\n`;
@@ -309,11 +323,26 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
     let tmpId = 0;
 
     const invLocals = inv(f.locals, x => x.idx);
-
+    const invLocalTypes = {};
     for (const x in invLocals) {
+      invLocalTypes[x] = CValtype[f.locals[invLocals[x]].type];
       invLocals[x] = sanitize(invLocals[x]);
     }
 
+    let localTmpId = 0;
+    const localGet = idx => {
+      if (Prefs['2cDirectLocalGet']) {
+        // this just does local.get via the variable name
+        // nice but does not get the value at this moment
+        // so breaks some wasm principles :(
+        vals.push(`${invLocals[i[1]]}`);
+      } else {
+        const id = localTmpId++;
+        line(`const ${invLocalTypes[idx]} _get${id} = ${invLocals[idx]}`);
+        vals.push(`_get${id}`);
+      }
+    };
+
     const returns = f.returns.length > 0;
     const typedReturns = f.returnType == null;
 
@@ -408,19 +437,22 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
           break;
         }
 
-        case Opcodes.local_get:
-          vals.push(`${invLocals[i[1]]}`);
+        case Opcodes.local_get: {
+          localGet(i[1]);
           break;
+        }
 
         case Opcodes.local_set:
           line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
           break;
 
-        case Opcodes.local_tee:
+        case Opcodes.local_tee: {
           line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
-          vals.push(`${invLocals[i[1]]}`);
+          localGet(i[1]);
+
           // vals.push(`((${invLocals[i[1]]} = ${vals.pop()}))`);
           break;
+        }
 
         case Opcodes.global_get:
           vals.push(`${invGlobals[i[1]]}`);
@@ -430,11 +462,6 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
           line(`${invGlobals[i[1]]} = ${removeBrackets(vals.pop())}`);
           break;
 
-        case Opcodes.f64_trunc:
-          // vals.push(`trunc(${vals.pop()})`);
-          vals.push(`(i32)(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
-          break;
-
         case Opcodes.f64_convert_i32_u:
         case Opcodes.f64_convert_i32_s:
         case Opcodes.f64_convert_i64_u:
@@ -686,6 +713,15 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
           break;
         }
 
+        case Opcodes.select: {
+          const cond = vals.pop();
+          const b = vals.pop();
+          const a = vals.pop();
+
+          vals.push(`(${cond} ? ${a} : ${b})`);
+          break;
+        }
+
         case Opcodes.throw: {
           const id = vals.pop();
 
@@ -718,25 +754,35 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
           break;
         }
 
-        // case Opcodes.f64_abs: {
-        //   break;
-        // }
-        // case Opcodes.f64_neg: {
-        //   break;
-        // }
+        case Opcodes.f64_abs: {
+          const id = tmpId++;
+          line(`const f64 _tmp${id} = ${vals.pop()}`);
+          vals.push(`(_tmp${id} < 0 ? -_tmp${id} : _tmp${id})`);
+          break;
+        }
+        case Opcodes.f64_neg: {
+          vals.push(`(-${vals.pop()})`);
+          break;
+        }
 
-        // case Opcodes.f64_ceil: {
-        //   break;
-        // }
-        // case Opcodes.f64_floor: {
-        //   break;
-        // }
-        // case Opcodes.f64_trunc: {
-        //   break;
-        // }
-        // case Opcodes.f64_nearest: {
-        //   break;
-        // }
+        case Opcodes.f64_ceil:
+          vals.push(`ceil(${vals.pop()})`);
+          includes.set('math.h', true);
+          break;
+        case Opcodes.f64_floor:
+          vals.push(`floor(${vals.pop()})`);
+          includes.set('math.h', true);
+          break;
+        case Opcodes.f64_trunc:
+          // vals.push(`trunc(${vals.pop()})`);
+          // includes.set('math.h', true);
+
+          vals.push(`(i32)(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
+          break;
+        case Opcodes.f64_nearest:
+          vals.push(`round(${vals.pop()})`);
+          includes.set('math.h', true);
+          break;
 
         // case Opcodes.f64_sqrt: {
         //   break;
@@ -765,7 +811,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
             break;
           }
 
-          log.warning('2c', `unimplemented op: ${invOpcodes[i[0]]}`);
+          log.warning('2c', `unimplemented op: ${invOpcodes[i[0]]} \x1b[90m(${f.name})`);
       }
 
       lastCond = false;

package/compiler/builtins/string_f64.ts

@@ -4,7 +4,7 @@ import type {} from './porffor.d.ts';
 // todo: support constructor/string objects properly
 export const String = function (value: any): bytestring {
   if (!new.target && Porffor.rawType(value) == Porffor.TYPES.symbol) return __Symbol_prototype_toString(value);
-  return __ecma262_ToString(value);
+  return ecma262.ToString(value);
 };
 
 export const __String_fromCharCode = (...codes: any[]): bytestring|string => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.20.1+3a57b9280",
+  "version": "0.20.2+fe061341a",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

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