porffor 0.0.0-ba812f2 → 0.0.0-beff13f

package/README.md

@@ -1,6 +1,6 @@
 # porffor
 a basic experimental wip *aot* optimizing js -> wasm/c engine/compiler/runtime in js. not serious/intended for (real) use. (this is a straight forward, honest readme)<br>
-age: ~1 month
+age: ~2 months
 
 ## design
 porffor is a very unique js engine, due a very different approach. it is seriously limited, but what it can do, it does pretty well. key differences:
@@ -83,6 +83,8 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
 - truthy/falsy (eg `!'' == true`)
 - string comparison (eg `'a' == 'a'`, `'a' != 'b'`)
 - nullish coalescing operator (`??`)
+- `for...of` (arrays and strings)
+- array member setting (`arr[0] = 2`, `arr[0] += 2`, etc)
 
 ### built-ins
 
@@ -110,11 +112,9 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
 no particular order and no guarentees, just what could happen soon™
 
 - arrays
-  - member setting (`arr[0] = 2`)
   - more of `Array` prototype
   - arrays/strings inside arrays
   - destructuring
-  - for .. of
 - strings
   - member setting
 - objects
@@ -132,10 +132,9 @@ no particular order and no guarentees, just what could happen soon™
   - rewrite local indexes per func for smallest local header and remove unused idxs
   - smarter inline selection (snapshots?)
   - remove const ifs (`if (true)`, etc)
-  - use data segments for initing arrays
 
 ## porfformance
-*for the things it supports*, porffor is blazingly faster compared to most interpreters, and engines running without JIT. for those with JIT, it is not that much slower like a traditional interpreter would be.
+*for the things it supports most of the time*, porffor is blazingly fast compared to most interpreters, and common engines running without JIT. for those with JIT, it is not that much slower like a traditional interpreter would be; mostly the same or a bit faster/slower depending on what.
 
 ![Screenshot of comparison chart](https://github.com/CanadaHonk/porffor/assets/19228318/76c75264-cc68-4be1-8891-c06dc389d97a)
 
@@ -158,6 +157,7 @@ mostly for reducing size. do not really care about compiler perf/time as long as
 - remove unneeded single just used vars
 - remove unneeded blocks (no `br`s inside)
 - remove unused imports
+- use data segments for initing arrays/strings
 
 ### wasm module
 - type cache/index (no repeated types)

package/compiler/2c.js

@@ -2,8 +2,6 @@ import { read_ieee754_binary64, read_signedLEB128 } from './encoding.js';
 import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
 import { operatorOpcode } from './expression.js';
 
-import fs from 'fs';
-
 const CValtype = {
   i8: 'char',
   i16: 'unsigned short', // presume all i16 stuff is unsigned
@@ -36,18 +34,24 @@ const todo = msg => {
   throw new TodoError(`todo: ${msg}`);
 };
 
+const removeBrackets = str => str.startsWith('(') && str.endsWith(')') ? str.slice(1, -1) : str;
+
 export default ({ funcs, globals, tags, exceptions, pages }) => {
-  const invOperatorOpcode = inv(operatorOpcode[valtype]);
+  const invOperatorOpcode = Object.values(operatorOpcode).reduce((acc, x) => {
+    for (const k in x) {
+      acc[x[k]] = k;
+    }
+    return acc;
+  }, {});
   const invGlobals = inv(globals, x => x.idx);
 
-  const includes = new Map();
+  const includes = new Map(), unixIncludes = new Map(), winIncludes = new Map();
   let out = '';
 
   for (const x in globals) {
     const g = globals[x];
 
-    out += `${CValtype[g.type]} ${x}`;
-    if (x.init) out += ` ${x.init}`;
+    out += `${CValtype[g.type]} ${x} = ${g.init ?? 0}`;
     out += ';\n';
   }
 
@@ -58,7 +62,43 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
   if (out) out += '\n';
 
+  let depth = 1;
+  const line = (str, semi = true) => out += `${' '.repeat(depth * 2)}${str}${semi ? ';' : ''}\n`;
+  const lines = lines => {
+    for (const x of lines) {
+      out += `${' '.repeat(depth * 2)}${x}\n`;
+    }
+  };
+
+  const platformSpecific = (win, unix, add = true) => {
+    let tmp = '';
+
+    if (win) {
+      if (add) out += '#ifdef _WIN32\n';
+        else tmp += '#ifdef _WIN32\n';
+
+      if (add) lines(win.split('\n'));
+        else tmp += win + (win.endsWith('\n') ? '' : '\n');
+    }
+
+    if (unix) {
+      if (add) out += (win ? '#else' : '#ifndef _WIN32') + '\n';
+        else tmp += (win ? '#else' : '#ifndef _WIN32') + '\n';
+
+      if (add) lines(unix.split('\n'));
+        else tmp += unix + (unix.endsWith('\n') ? '' : '\n');
+    }
+
+    if (win || unix)
+      if (add) out += '#endif\n';
+        else tmp += '#endif\n';
+
+    return tmp;
+  };
+
   for (const f of funcs) {
+    depth = 1;
+
     const invLocals = inv(f.locals, x => x.idx);
     if (f.returns.length > 1) todo('funcs returning >1 value unsupported');
 
@@ -66,16 +106,13 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
     const returns = f.returns.length === 1;
 
-    const shouldInline = ['f64_%'].includes(f.name);
+    const shouldInline = f.internal;
     out += `${f.name === 'main' ? 'int' : CValtype[f.returns[0]]} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
 
-    let depth = 1;
-    const line = (str, semi = true) => out += `${' '.repeat(depth * 2)}${str}${semi ? ';' : ''}\n`;
-
     const localKeys = Object.keys(f.locals).sort((a, b) => f.locals[a].idx - f.locals[b].idx).slice(f.params.length).sort((a, b) => f.locals[a].idx - f.locals[b].idx);
     for (const x of localKeys) {
       const l = f.locals[x];
-      line(`${CValtype[l.type]} ${x}`);
+      line(`${CValtype[l.type]} ${x} = 0`);
     }
 
     if (localKeys.length !== 0) out += '\n';
@@ -96,7 +133,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
         if (['==', '!=', '>', '>=', '<', '<='].includes(op)) lastCond = true;
           else lastCond = false;
 
-        vals.push(`${a} ${op} ${b}`);
+        // vals.push(`${a} ${op} ${b}`);
+        vals.push(`(${removeBrackets(a)} ${op} ${b})`);
         continue;
       }
 
@@ -120,6 +158,7 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
       switch (i[0]) {
         case Opcodes.i32_const:
+        case Opcodes.i64_const:
           vals.push(read_signedLEB128(i.slice(1)).toString());
           break;
 
@@ -132,24 +171,42 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
           break;
 
         case Opcodes.local_set:
-          line(`${invLocals[i[1]]} = ${vals.pop()}`);
+          line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
           break;
 
         case Opcodes.local_tee:
-          vals.push(`${invLocals[i[1]]} = ${vals.pop()}`);
+          line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
+          vals.push(`${invLocals[i[1]]}`);
+          // vals.push(`${invLocals[i[1]]} = ${vals.pop()}`);
+          break;
+
+        case Opcodes.global_get:
+          vals.push(`${invGlobals[i[1]]}`);
+          break;
+
+        case Opcodes.global_set:
+          line(`${invGlobals[i[1]]} = ${removeBrackets(vals.pop())}`);
           break;
 
         case Opcodes.f64_trunc:
           // vals.push(`trunc(${vals.pop()})`);
-          vals.push(`(int)(${vals.pop()})`); // this is ~10x faster with clang. what the fuck.
+          vals.push(`(int)(${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:
+        case Opcodes.f64_convert_i64_s:
+          // int to double
+          vals.push(`(double)${vals.pop()}`);
           break;
 
         case Opcodes.return:
-          line(`return${returns ? ` ${vals.pop()}` : ''}`);
+          line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
           break;
 
         case Opcodes.if:
-          let cond = vals.pop();
+          let cond = removeBrackets(vals.pop());
           if (!lastCond) {
             if (cond.startsWith('(long)')) cond = `${cond.slice(6)} == 1e+0`;
               else cond += ' == 1';
@@ -214,12 +271,44 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
                 line(`printf("%f\\n", ${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);
+QueryPerformanceCounter(&_time_t);
+_time_out = ((double)_time_t.QuadPart / _time_freq.QuadPart) * 1000.;`,
+`struct timespec _time;
+clock_gettime(CLOCK_MONOTONIC, &_time);
+_time_out = _time.tv_nsec / 1000000.;`);
+                vals.push(`_time_out`);
+
+                unixIncludes.set('time.h', true);
+                winIncludes.set('windows.h', true);
+                break;
+
+              default:
+                log('2c', `unimplemented import: ${importFunc.name}`);
+                break;
             }
+
             break;
           }
 
           let args = [];
-          for (let j = 0; j < func.params.length; j++) args.unshift(vals.pop());
+          for (let j = 0; j < func.params.length; j++) args.unshift(removeBrackets(vals.pop()));
 
           if (func.returns.length === 1) vals.push(`${sanitize(func.name)}(${args.join(', ')})`)
             else line(`${sanitize(func.name)}(${args.join(', ')})`);
@@ -251,7 +340,11 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     out += '}\n\n';
   }
 
-  out = [...includes.keys()].map(x => `#include <${x}>`).join('\n') + '\n\n' + out;
+  depth = 0;
+
+  const makeIncludes = includes => [...includes.keys()].map(x => `#include <${x}>\n`).join('');
+
+  out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + out;
 
   return out;
 };

package/compiler/builtins.js

@@ -26,6 +26,12 @@ export const importedFuncs = [
     import: 't',
     params: 0,
     returns: 1
+  },
+  {
+    name: 'printStr',
+    import: 's',
+    params: 1,
+    returns: 0
   }
 ];