Add SIMD prerequisites (AssemblyScript#469)

Author: dcodeIO

cli/asc.json

@@ -162,6 +162,7 @@
       " sign-extension  Enables sign-extension operations",
       " mutable-global  Enables mutable global imports and exports",
       " bulk-memory     Enables bulk memory operations",
+      " simd            Enables SIMD types and operations.",
       ""
     ],
     "type": "s"

src/builtins.ts

@@ -3513,7 +3513,7 @@ export function compileIterateRoots(compiler: Compiler): void {
                 ? module.createI64(i64_low(value), i64_high(value))
                 : module.createI32(i64_low(value))
             ],
-            "iv"
+            "i_"
           )
         );
       } else {
@@ -3526,7 +3526,7 @@ export function compileIterateRoots(compiler: Compiler): void {
                 compiler.options.nativeSizeType
               )
             ],
-            "iv"
+            "i_"
           )
         );
       }
@@ -3610,7 +3610,7 @@ export function ensureGCHook(
         [
           module.createGetLocal(0, nativeSizeType)
         ],
-        nativeSizeType == NativeType.I64 ? "Iv" : "iv"
+        nativeSizeType == NativeType.I64 ? "I_" : "i_"
       )
     );
 

src/compiler.ts

@@ -235,7 +235,9 @@ export const enum Feature {
   /** Mutable global imports and exports. */
   MUTABLE_GLOBAL = 1 << 1, // see: https://github.com/WebAssembly/mutable-global
   /** Bulk memory operations. */
-  BULK_MEMORY = 1 << 2 // see: https://github.com/WebAssembly/bulk-memory-operations
+  BULK_MEMORY = 1 << 2, // see: https://github.com/WebAssembly/bulk-memory-operations
+  /** SIMD types and operations. */
+  SIMD = 1 << 3 // see: https://github.com/WebAssembly/simd
 }
 
 /** Indicates the desired kind of a conversion. */

src/decompiler.ts

@@ -880,6 +880,7 @@ function nativeTypeToType(type: NativeType): string {
     case NativeType.I64: return "i64";
     case NativeType.F32: return "f32";
     case NativeType.F64: return "f64";
+    case NativeType.V128: return "v128";
     case NativeType.Unreachable: throw new Error("unreachable type");
     case NativeType.Auto: throw new Error("auto type");
     default: throw new Error("unexpected type");

src/definitions.ts

@@ -480,6 +480,7 @@ export class TSDBuilder extends ExportsWalker {
       case TypeKind.BOOL: return "bool";
       case TypeKind.F32: return "f32";
       case TypeKind.F64: return "f64";
+      case TypeKind.V128: return "v128";
       case TypeKind.VOID: return "void";
       default: {
         assert(false);

src/glue/binaryen.d.ts

@@ -18,6 +18,7 @@ declare function _BinaryenTypeInt32(): BinaryenType;
 declare function _BinaryenTypeInt64(): BinaryenType;
 declare function _BinaryenTypeFloat32(): BinaryenType;
 declare function _BinaryenTypeFloat64(): BinaryenType;
+declare function _BinaryenTypeVec128(): BinaryenType;
 declare function _BinaryenTypeUnreachable(): BinaryenType;
 declare function _BinaryenTypeAuto(): BinaryenType;
 

src/index.ts

@@ -130,6 +130,8 @@ export const FEATURE_SIGN_EXTENSION = Feature.SIGN_EXTENSION;
 export const FEATURE_MUTABLE_GLOBAL = Feature.MUTABLE_GLOBAL;
 /** Bulk memory operations. */
 export const FEATURE_BULK_MEMORY = Feature.BULK_MEMORY;
+/** SIMD types and operations. */
+export const FEATURE_SIMD = Feature.SIMD;
 
 /** Enables a specific feature. */
 export function enableFeature(options: Options, feature: Feature): void {

src/module.ts

@@ -18,14 +18,15 @@ export type RelooperRef = usize;
 export type RelooperBlockRef = usize;
 export type Index = u32;
 
-export const enum NativeType {
-  None = 0,        // _BinaryenTypeNone(),
-  I32  = 1,        // _BinaryenTypeInt32(),
-  I64  = 2,        // _BinaryenTypeInt64(),
-  F32  = 3,        // _BinaryenTypeFloat32(),
-  F64  = 4,        // _BinaryenTypeFloat64(),
-  Unreachable = 5, // _BinaryenTypeUnreachable(),
-  Auto = -1        // _BinaryenTypeAuto()
+export enum NativeType {
+  None = _BinaryenTypeNone(),
+  I32  = _BinaryenTypeInt32(),
+  I64  = _BinaryenTypeInt64(),
+  F32  = _BinaryenTypeFloat32(),
+  F64  = _BinaryenTypeFloat64(),
+  V128 = _BinaryenTypeVec128(),
+  Unreachable = _BinaryenTypeUnreachable(),
+  Auto = _BinaryenTypeAuto()
 }
 
 export enum ExpressionId {
@@ -442,6 +443,15 @@ export class Module {
     return _BinaryenConst(this.ref, out);
   }
 
+  createV128(bytes: Uint8Array): ExpressionRef {
+    assert(bytes.length == 16);
+    var out = this.lit;
+    // FIXME: does this work or do we need to malloc?
+    for (let i = 0; i < 16; ++i) store<u8>(out + i, bytes[i]);
+    _BinaryenLiteralVec128(out, out);
+    return _BinaryenConst(this.ref, out);
+  }
+
   // expressions
 
   createUnary(

src/program.ts

@@ -415,6 +415,7 @@ export class Program extends DiagnosticEmitter {
       ["number", Type.f64],
       ["boolean", Type.bool]
     ]);
+    if (options.hasFeature(Feature.SIMD)) this.typesLookup.set("v128", Type.v128);
 
     // add compiler hints
     this.setConstantInteger("ASC_TARGET", Type.i32,
@@ -433,6 +434,10 @@ export class Program extends DiagnosticEmitter {
       i64_new(options.hasFeature(Feature.MUTABLE_GLOBAL) ? 1 : 0, 0));
     this.setConstantInteger("ASC_FEATURE_SIGN_EXTENSION", Type.bool,
       i64_new(options.hasFeature(Feature.SIGN_EXTENSION) ? 1 : 0, 0));
+    this.setConstantInteger("ASC_FEATURE_BULK_MEMORY", Type.bool,
+      i64_new(options.hasFeature(Feature.BULK_MEMORY) ? 1 : 0, 0));
+    this.setConstantInteger("ASC_FEATURE_SIMD", Type.bool,
+      i64_new(options.hasFeature(Feature.SIMD) ? 1 : 0, 0));
 
     // remember deferred elements
     var queuedImports = new Array<QueuedImport>();
@@ -659,6 +664,7 @@ export class Program extends DiagnosticEmitter {
     this.registerBasicClass(TypeKind.BOOL, "Bool");
     this.registerBasicClass(TypeKind.F32, "F32");
     this.registerBasicClass(TypeKind.F64, "F64");
+    if (options.hasFeature(Feature.SIMD)) this.registerBasicClass(TypeKind.V128, "V128");
 
     // register 'start'
     {

src/resolver.ts

@@ -234,6 +234,7 @@ export class Resolver extends DiagnosticEmitter {
         case TypeKind.U64: return Type.u64;
         case TypeKind.F32: return Type.f32;
         case TypeKind.F64: return Type.f64;
+        case TypeKind.V128: return Type.v128;
         case TypeKind.VOID: return Type.void;
         default: assert(false);
       }