porffor 0.2.0-c7b7423 → 0.2.0-eaee2da

package/README.md

@@ -1,5 +1,5 @@
 # Porffor &nbsp;<sup><sub>/ˈpɔrfɔr/ &nbsp;*(poor-for)*</sup></sub>
-A from-scratch experimental **AOT** optimizing JS -> Wasm/C engine/compiler/runtime in JS. Not serious/intended for (real) use. (this is a straight forward, honest readme)<br>
+A from-scratch experimental **AOT** optimizing JS/TS -> Wasm/C engine/compiler/runtime in JS. Not serious/intended for (real) use. (this is a straight forward, honest readme)<br>
 Age: ~6 months (very on and off)
 
 ## Design
@@ -118,7 +118,7 @@ No particular order and no guarentees, just what could happen soon™
 - Objects
   - Basic object expressions (eg `{}`, `{ a: 0 }`)
 - Wasm
-  - *Basic* Wasm engine (interpreter) in js
+  - *Basic* Wasm engine (interpreter) in JS
 - More math operators (`**`, etc)
 - `do { ... } while (...)`
 - Rewrite `console.log` to work with strings/arrays
@@ -130,7 +130,21 @@ 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 type(script) information to remove unneeded typechecker code
+  - Experiment with byte strings?
+- Runtime
+  - WASI target
+  - Run precompiled Wasm file if given
+- Cool proposals
+  - [Optional Chaining Assignment](https://github.com/tc39/proposal-optional-chaining-assignment)
+  - [Modulus and Additional Integer Math](https://github.com/tc39/proposal-integer-and-modulus-math)
+  - [Array Equality](https://github.com/tc39/proposal-array-equality)
+  - [Declarations in Conditionals](https://github.com/tc39/proposal-Declarations-in-Conditionals)
+  - [Seeded Pseudo-Random Numbers](https://github.com/tc39/proposal-seeded-random)
+  - [`do` expressions](https://github.com/tc39/proposal-do-expressions)
+  - [String Trim Characters](https://github.com/Kingwl/proposal-string-trim-characters)
+- Posts
+  - Inlining investigation
+- Self hosted testing?
 
 ## Performance
 *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.
@@ -157,10 +171,12 @@ Mostly for reducing size. I do not really care about compiler perf/time as long
 - Remove unneeded blocks (no `br`s inside)
 - Remove unused imports
 - Use data segments for initing arrays/strings
+- (Likely more not documented yet, todo)
 
 ### Wasm module
 - Type cache/index (no repeated types)
 - No main func if empty (and other exports)
+- No tags if unused/optimized out
 
 ## Test262
 Porffor can run Test262 via some hacks/transforms which remove unsupported features whilst still doing the same asserts (eg simpler error messages using literals only). It currently passes >10% (see latest commit desc for latest and details). Use `node test262` to test, it will also show a difference of overall results between the last commit and current results.
@@ -180,7 +196,7 @@ Porffor can run Test262 via some hacks/transforms which remove unsupported featu
   - `wasmSpec.js`: "enums"/info from wasm spec
   - `wrap.js`: wrapper for compiler which instantiates and produces nice exports
 
-- `runner`: contains utils for running js with the compiler
+- `runner`: contains utils for running JS with the compiler
   - `index.js`: the main file, you probably want to use this
   - `info.js`: runs with extra info printed
   - `repl.js`: basic repl (uses `node:repl`)
@@ -193,10 +209,13 @@ Porffor can run Test262 via some hacks/transforms which remove unsupported featu
 - `test262`: test262 runner and utils
 
 ## Usecases
-Basically none (other than giving people headaches). Potential ideas to come?
+Basically none right now (other than giving people headaches). Potential ideas:
+- Safety. As Porffor is written in JS, a memory-safe language\*, and compiles JS to Wasm, a fully sandboxed environment\*, it is quite safe. (\* These rely on the underlying implementations being secure. You could also run Wasm, or even Porffor itself, with an interpreter instead of a JIT for bonus security points too.)
+- Compiling JS to native binaries. This is still very early, [`2c`](#2c) is not that good yet :(
+- More in future probably?
 
 ## Usage
-Basically nothing will work :). See files in `test` for examples.
+Basically nothing will work :). See files in `test` and `bench` for examples.
 
 1. Clone repo
 2. `npm install`
@@ -212,11 +231,14 @@ You can also use Deno (`deno run -A ...` instead of `node ...`), or Bun (`bun ..
 - `-target=native` only:
   - `-compiler=clang` to set compiler binary (path/name) to use to compile
   - `-cO=O3` to set compiler opt argument
+- `-parser=acorn|@babel/parser|meriyah|hermes-parser` (default: `acorn`) to set which parser to use
+- `-parse-types` to enable parsing type annotations/typescript. if `-parser` is unset, changes default to `@babel/parser`. does not type check
+- `-opt-types` to perform optimizations using type annotations as compiler hints. does not type check
 - `-valtype=i32|i64|f64` (default: `f64`) to set valtype
 - `-O0` to disable opt
 - `-O1` (default) to enable basic opt (simplify insts, treeshake wasm imports)
-- `-O2` to enable advanced opt (inlining)
-- `-O3` to enable advanceder opt (precompute const math)
+- `-O2` to enable advanced opt (inlining). unstable
+- `-O3` to enable advanceder opt (precompute const math). unstable
 - `-no-run` to not run wasm output, just compile
 - `-opt-log` to log some opts
 - `-code-log` to log some codegen (you probably want `-funcs`)
@@ -230,20 +252,20 @@ You can also use Deno (`deno run -A ...` instead of `node ...`), or Bun (`bun ..
 - `-compile-hints` to enable V8 compilation hints (experimental + doesn't seem to do much?)
 
 ## VSCode extension
-There is a vscode extension in `porffor-for-vscode` which tweaks js syntax highlighting to be nicer with porffor features (eg highlighting wasm inside of inline asm).
+There is a vscode extension in `porffor-for-vscode` which tweaks JS syntax highlighting to be nicer with porffor features (eg highlighting wasm inside of inline asm).
 
 ## Isn't this the same as AssemblyScript/other Wasm langs?
 No. they are not alike at all internally and have very different goals/ideals:
 - Porffor is made as a generic JS engine, not for Wasm stuff specifically
-- Porffor takes in JS, not a different language or typescript
-- Porffor is made in pure JS and compiles itself, not using Binaryen/etc
+- Porffor primarily consumes JS
+- Porffor is written in pure JS and compiles itself, not using Binaryen/etc
 - (Also I didn't know it existed when I started this, lol)
 
 ## FAQ
 
 ### 1. Why the name?
 `purple` in Welsh is `porffor`. Why purple?
-- No other js engine is purple colored
+- No other JS engine is purple colored
 - Purple is pretty cool
 - Purple apparently represents "ambition", which is.. one word to describe this project
 - The hard to speak name is also the noise your brain makes in reaction to this idea!

package/compiler/2c.js

@@ -124,7 +124,7 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     const returns = f.returns.length > 0;
 
     const shouldInline = f.internal;
-    out += `${f.name === 'main' ? 'int' : (f.internal ? 'double' : 'struct ReturnValue')} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+    out += `${f.name === 'main' ? 'int' : (f.internal ? (returns ? 'double' : 'void') : 'struct ReturnValue')} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\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) {
@@ -367,6 +367,11 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
       line(`return ${vals.pop()}`);
     }
 
+    if (f.name === 'main') {
+      out += '\n';
+      line(`return 0`);
+    }
+
     out += '}\n\n';
   }
 

package/compiler/builtins.js

@@ -1,4 +1,4 @@
-import { Blocktype, Opcodes, Valtype } from "./wasmSpec.js";
+import { Blocktype, Opcodes, Valtype, ValtypeSize } from "./wasmSpec.js";
 import { number, i32x4 } from "./embedding.js";
 
 export const importedFuncs = [
@@ -29,6 +29,21 @@ for (let i = 0; i < importedFuncs.length; i++) {
 
 const char = c => number(c.charCodeAt(0));
 
+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;
+};
+
 // todo: somehow diff between these (undefined != null) while remaining falsey in wasm as a number value
 export const UNDEFINED = 0;
 export const NULL = 0;
@@ -187,12 +202,125 @@ export const BuiltinFuncs = function() {
 
 
   this.__console_log = {
-    params: [ valtypeBinary ],
-    locals: [],
+    params: [ valtypeBinary, Valtype.i32 ],
+    typedParams: true,
+    locals: [ Valtype.i32, Valtype.i32 ],
     returns: [],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.call, importedFuncs.print ],
+    wasm: (scope, { TYPES, typeSwitch }) => [
+      ...typeSwitch(scope, [ [ Opcodes.local_get, 1 ] ], {
+        [TYPES.number]: [
+          [ Opcodes.local_get, 0 ],
+          [ Opcodes.call, importedFuncs.print ],
+        ],
+        [TYPES.boolean]: [
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.if, Blocktype.void ],
+          ...printStaticStr('true'),
+          [ Opcodes.else ],
+          ...printStaticStr('false'),
+          [ Opcodes.end ]
+        ],
+        [TYPES.string]: [
+          // simply print a string :))
+          // cache input pointer as i32
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.local_tee, 2 ],
+
+          // make end pointer
+          [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+          ...number(ValtypeSize.i16, Valtype.i32),
+          [ Opcodes.i32_mul ],
+
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_set, 3 ],
+
+          [ Opcodes.loop, Blocktype.void ],
+
+          // print current char
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+          Opcodes.i32_from_u,
+          [ Opcodes.call, importedFuncs.printChar ],
+
+          // increment pointer by sizeof i16
+          [ Opcodes.local_get, 2 ],
+          ...number(ValtypeSize.i16, Valtype.i32),
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_tee, 2 ],
+
+          // if pointer != end pointer, loop
+          [ Opcodes.local_get, 3 ],
+          [ Opcodes.i32_ne ],
+          [ Opcodes.br_if, 0 ],
+
+          [ Opcodes.end ]
+        ],
+        [TYPES._array]: [
+          ...printStaticStr('[ '),
+
+          // cache input pointer as i32
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.local_tee, 2 ],
+
+          // make end pointer
+          [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+          ...number(ValtypeSize[valtype], Valtype.i32),
+          [ Opcodes.i32_mul ],
+
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_set, 3 ],
+
+          [ Opcodes.loop, Blocktype.void ],
+
+          // print current char
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.load, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+          [ Opcodes.call, importedFuncs.print ],
+
+          // increment pointer by sizeof valtype
+          [ Opcodes.local_get, 2 ],
+          ...number(ValtypeSize[valtype], Valtype.i32),
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_tee, 2 ],
+
+          // if pointer != end pointer, print separator and loop
+          [ Opcodes.local_get, 3 ],
+          [ Opcodes.i32_ne ],
+          [ Opcodes.if, Blocktype.void ],
+          ...printStaticStr(', '),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
+
+          [ Opcodes.end ],
+
+          ...printStaticStr(' ]'),
+        ],
+        [TYPES.undefined]: [
+          ...printStaticStr('undefined')
+        ],
+        [TYPES.function]: [
+          ...printStaticStr('function () {}')
+        ],
+        [TYPES.object]: [
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.if, Blocktype.void ],
+          ...printStaticStr('{}'),
+          [ Opcodes.else ],
+          ...printStaticStr('null'),
+          [ Opcodes.end ]
+        ],
+        default: [
+          [ Opcodes.local_get, 0 ],
+          [ Opcodes.call, importedFuncs.print ],
+        ]
+      }, Blocktype.void),
+
       ...char('\n'),
       [ Opcodes.call, importedFuncs.printChar ]
     ]