Refactored builtins

Author: dcodeIO

assembly.d.ts

@@ -39,18 +39,18 @@ declare function popcnt<T = i32 | i64>(value: T): T;
 declare function rotl<T = i32 | i64>(value: T, shift: T): T;
 /** Performs the sign-agnostic rotate right operation on a 32-bit or 64-bit integer. */
 declare function rotr<T = i32 | i64>(value: T, shift: T): T;
-/** Computes the absolute value of a 32-bit or 64-bit float. */
-declare function abs<T = f32 | f64>(value: T): T;
+/** Computes the absolute value of an integer or float. */
+declare function abs<T = i32 | i64 | f32 | f64>(value: T): T;
+/** Determines the maximum of two integers or floats. If either operand is `NaN`, returns `NaN`. */
+declare function max<T = i32 | i64 | f32 | f64>(left: T, right: T): T;
+/** Determines the minimum of two integers or floats. If either operand is `NaN`, returns `NaN`. */
+declare function min<T = i32 | i64 | f32 | f64>(left: T, right: T): T;
 /** Performs the ceiling operation on a 32-bit or 64-bit float. */
 declare function ceil<T = f32 | f64>(value: T): T;
 /** Composes a 32-bit or 64-bit float from the magnitude of `x` and the sign of `y`. */
 declare function copysign<T = f32 | f64>(x: T, y: T): T;
 /** Performs the floor operation on a 32-bit or 64-bit float. */
 declare function floor<T = f32 | f64>(value: T): T;
-/** Determines the maximum of two 32-bit or 64-bit floats. If either operand is `NaN`, returns `NaN`. */
-declare function max<T = f32 | f64>(left: T, right: T): T;
-/** Determines the minimum of two 32-bit or 64-bit floats. If either operand is `NaN`, returns `NaN`. */
-declare function min<T = f32 | f64>(left: T, right: T): T;
 /** Rounds to the nearest integer tied to even of a 32-bit or 64-bit float. */
 declare function nearest<T = f32 | f64>(value: T): T;
 /** Reinterprets the bits of a value of type `T1` as type `T2`. Valid reinterpretations are i32 to/from f32 and i64 to/from f64. */

src/builtins.ts

@@ -14,3 +14,6 @@ declare type bool = boolean;
 // Raw memory access (here: Binaryen memory)
 declare function store<T = u8>(ptr: usize, val: T): void;
 declare function load<T = u8>(ptr: usize): T;
+
+// Other things that might or might not be useful
+declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;

src/compiler.ts

@@ -8,6 +8,10 @@ globalScope["load"] = function load_u8(ptr: number) {
   return binaryen.HEAPU8[ptr];
 };
 
+globalScope["select"] = function select<T>(ifTrue: T, ifFalse: T, condition: bool): T {
+  return condition ? ifTrue : ifFalse;
+};
+
 const binaryen = require("binaryen");
 for (const key in binaryen)
   if (/^_(?:Binaryen|Relooper|malloc$|free$)/.test(key))

src/glue/js.d.ts

@@ -1,6 +1,7 @@
+import { initialize as initializeBuiltins } from "./builtins";
 import { Target } from "./compiler";
 import { GETTER_PREFIX, SETTER_PREFIX, PATH_DELIMITER } from "./constants";
-import { DiagnosticCode, DiagnosticMessage, DiagnosticEmitter, DiagnosticCategory } from "./diagnostics";
+import { DiagnosticCode, DiagnosticMessage, DiagnosticEmitter } from "./diagnostics";
 import { Type, typesToString } from "./types";
 import { I64 } from "./util";
 import {
@@ -57,7 +58,7 @@ class QueuedImport {
   declaration: ImportDeclaration;
 }
 
-const reusableTypesStub: Map<string,Type> = new Map();
+const noTypesYet: Map<string,Type> = new Map();
 
 export class Program extends DiagnosticEmitter {
 
@@ -70,7 +71,7 @@ export class Program extends DiagnosticEmitter {
   /** Elements by internal name. */
   elements: Map<string,Element> = new Map();
   /** Types by internal name. */
-  types: Map<string,Type> = reusableTypesStub;
+  types: Map<string,Type> = noTypesYet;
   /** Exports of individual files by internal name. Not global exports. */
   exports: Map<string,Element> = new Map();
 
@@ -82,6 +83,22 @@ export class Program extends DiagnosticEmitter {
   /** Initializes the program and its elements prior to compilation. */
   initialize(target: Target = Target.WASM32): void {
     this.target = target;
+    this.types = new Map([
+      ["i8", Type.i8],
+      ["i16", Type.i16],
+      ["i32", Type.i32],
+      ["i64", Type.i64],
+      ["isize", target == Target.WASM64 ? Type.isize64 : Type.isize32],
+      ["u8", Type.u8],
+      ["u16", Type.u16],
+      ["u32", Type.u32],
+      ["u64", Type.u64],
+      ["usize", target == Target.WASM64 ? Type.usize64 : Type.usize32],
+      ["bool", Type.bool],
+      ["f32", Type.f32],
+      ["f64", Type.f64],
+      ["void", Type.void]
+    ]);
 
     initializeBuiltins(this);
 
@@ -1110,120 +1127,3 @@ export class Interface extends Class {
     super(template, internalName, typeArguments, base);
   }
 }
-
-const builtinIntTypes: Type[] = [ Type.i32, Type.i64 ];
-const builtinFloatTypes: Type[] = [ Type.f32, Type.f64 ];
-
-function initializeBuiltins(program: Program): void {
-
-  // types
-
-  program.types = new Map([
-    ["i8", Type.i8],
-    ["i16", Type.i16],
-    ["i32", Type.i32],
-    ["i64", Type.i64],
-    ["isize", program.target == Target.WASM64 ? Type.isize64 : Type.isize32],
-    ["u8", Type.u8],
-    ["u16", Type.u16],
-    ["u32", Type.u32],
-    ["u64", Type.u64],
-    ["usize", program.target == Target.WASM64 ? Type.usize64 : Type.usize32],
-    ["bool", Type.bool],
-    ["f32", Type.f32],
-    ["f64", Type.f64],
-    ["void", Type.void]
-  ]);
-
-  // functions
-
-  const usize: Type = program.target == Target.WASM64 ? Type.usize64 : Type.usize32;
-
-  addGenericUnaryBuiltin(program, "clz", builtinIntTypes);
-  addGenericUnaryBuiltin(program, "ctz", builtinIntTypes);
-  addGenericUnaryBuiltin(program, "popcnt", builtinIntTypes);
-  addGenericBinaryBuiltin(program, "rotl", builtinIntTypes);
-  addGenericBinaryBuiltin(program, "rotr", builtinIntTypes);
-
-  addGenericUnaryBuiltin(program, "abs", builtinFloatTypes);
-  addGenericUnaryBuiltin(program, "ceil", builtinFloatTypes);
-  addGenericBinaryBuiltin(program, "copysign", builtinFloatTypes);
-  addGenericUnaryBuiltin(program, "floor", builtinFloatTypes);
-  addGenericBinaryBuiltin(program, "max", builtinFloatTypes);
-  addGenericBinaryBuiltin(program, "min", builtinFloatTypes);
-  addGenericUnaryBuiltin(program, "nearest", builtinFloatTypes);
-  addGenericUnaryBuiltin(program, "sqrt", builtinFloatTypes);
-  addGenericUnaryBuiltin(program, "trunc", builtinFloatTypes);
-
-  addSimpleBuiltin(program, "current_memory", [], usize);
-  addSimpleBuiltin(program, "grow_memory", [ usize ], usize);
-  addSimpleBuiltin(program, "unreachable", [], Type.void);
-
-  addGenericAnyBuiltin(program, "load");
-  addGenericAnyBuiltin(program, "store");
-  addGenericAnyBuiltin(program, "reinterpret");
-  addGenericAnyBuiltin(program, "select");
-
-  addGenericAnyBuiltin(program, "sizeof");
-  addGenericUnaryTestBuiltin(program, "isNaN", builtinFloatTypes);
-  addGenericUnaryTestBuiltin(program, "isFinite", builtinFloatTypes);
-  addSimpleBuiltin(program, "assert", [ Type.bool ], Type.void);
-}
-
-/** Adds a simple (non-generic) builtin. */
-function addSimpleBuiltin(program: Program, name: string, parameterTypes: Type[], returnType: Type) {
-  let prototype: FunctionPrototype = new FunctionPrototype(program, name, null, null);
-  prototype.isGeneric = false;
-  prototype.isBuiltin = true;
-  const k: i32 = parameterTypes.length;
-  const parameters: Parameter[] = new Array(k);
-  for (let i: i32 = 0; i < k; ++i)
-    parameters[i] = new Parameter("arg" + i, parameterTypes[i], null);
-  prototype.instances.set("", new Function(prototype, name, [], parameters, returnType, null));
-  program.elements.set(name, prototype);
-}
-
-/** Adds a generic unary builtin that takes and returns a value of its generic type. */
-function addGenericUnaryBuiltin(program: Program, name: string, types: Type[]): void {
-  let prototype: FunctionPrototype = new FunctionPrototype(program, name, null, null);
-  prototype.isGeneric = true;
-  prototype.isBuiltin = true;
-  for (let i: i32 = 0, k = types.length; i < k; ++i) {
-    const typeName: string = types[i].toString();
-    prototype.instances.set(typeName, new Function(prototype, name + "<" + typeName + ">", [ types[i] ], [ new Parameter("value", types[i], null) ], types[i], null));
-  }
-  program.elements.set(name, prototype);
-}
-
-/** Adds a generic binary builtin that takes two and returns a value of its generic type. */
-function addGenericBinaryBuiltin(program: Program, name: string, types: Type[]): void {
-  let prototype: FunctionPrototype = new FunctionPrototype(program, name, null, null);
-  prototype.isGeneric = true;
-  prototype.isBuiltin = true;
-  for (let i: i32 = 0, k = types.length; i < k; ++i) {
-    const typeName: string = types[i].toString();
-    prototype.instances.set(typeName, new Function(prototype, name + "<" + typeName + ">", [ types[i], types[i] ], [ new Parameter("left", types[i], null), new Parameter("right", types[i], null) ], types[i], null));
-  }
-  program.elements.set(name, prototype);
-}
-
-/** Adds a generic unary builtin that alwways returns `bool`. */
-function addGenericUnaryTestBuiltin(program: Program, name: string, types: Type[]): void {
-  let prototype: FunctionPrototype = new FunctionPrototype(program, name, null, null);
-  prototype.isGeneric = true;
-  prototype.isBuiltin = true;
-  for (let i: i32 = 0, k = types.length; i < k; ++i) {
-    const typeName: string = types[i].toString();
-    prototype.instances.set(typeName, new Function(prototype, name + "<" + typeName + ">", [ types[i] ], [ new Parameter("value", types[i], null) ], Type.bool, null));
-  }
-  program.elements.set(name, prototype);
-}
-
-/** Adds a special generic builtin that takes any type argument. */
-function addGenericAnyBuiltin(program: Program, name: string): void {
-  let prototype: FunctionPrototype = new FunctionPrototype(program, name, null, null);
-  prototype.isGeneric = true;
-  prototype.isBuiltin = true;
-  program.elements.set(name, prototype);
-  // instances are hard coded in compiler.ts
-}

src/glue/js.ts

@@ -50,8 +50,10 @@ glob.sync(filter, { cwd: __dirname + "/compiler" }).forEach(filename => {
     }
     module.optimize();
     actualOptimized = module.toText();
-  } else
+  } else {
+    process.exitCode = 1;
     console.log(chalk.default.red("validate ERROR"));
+  }
 
   if (isCreate) {
     fs.writeFileSync(__dirname + "/compiler/" + fixture, actual, { encoding: "utf8" });