[MERGE #4074 @arunetm] WASM.SIMD: Trunc & Conv ops for 64x2 types

arunetm-zz · arunetm-zz · commit f70f51c7bf7a · 2017-10-30T16:27:23.000-07:00
Merge pull request #4074 from arunetm:arunetm/wasm.simd.trunc64x2 Truncation & conversion operstions for 64x2 types. Xplat link error fixes
diff --git a/lib/Backend/IRBuilderAsmJs.cpp b/lib/Backend/IRBuilderAsmJs.cpp
@@ -4672,7 +4672,11 @@ IRBuilderAsmJs::BuildInt64x2_3(Js::OpCodeAsmJs newOpcode, uint32 offset, BUILD_S
 void
 IRBuilderAsmJs::BuildInt64x2_2(Js::OpCodeAsmJs newOpcode, uint32 offset, BUILD_SIMD_ARGS_REG2)
 {
-    Assert(newOpcode == Js::OpCodeAsmJs::Simd128_Neg_I2);
+    Assert(newOpcode == Js::OpCodeAsmJs::Simd128_Neg_I2 ||
+           newOpcode == Js::OpCodeAsmJs::Simd128_FromUint64x2_D2 ||
+           newOpcode == Js::OpCodeAsmJs::Simd128_FromInt64x2_D2 ||
+           newOpcode == Js::OpCodeAsmJs::Simd128_FromFloat64x2_I2 ||
+           newOpcode == Js::OpCodeAsmJs::Simd128_FromFloat64x2_U2);
     BuildSimd_2(newOpcode, offset, dstRegSlot, src1RegSlot, TySimd128I2);
 }
 
diff --git a/lib/Backend/JnHelperMethodList.h b/lib/Backend/JnHelperMethodList.h
@@ -355,6 +355,10 @@ HELPERCALL(Simd128ShRtByScalarU2, Js::SIMDInt64x2Operation::OpShiftRightByScalar
 HELPERCALL(Simd128ShRtByScalarI2, Js::SIMDInt64x2Operation::OpShiftRightByScalar, 0)
 HELPERCALL(Simd128ShLtByScalarI2, Js::SIMDInt64x2Operation::OpShiftLeftByScalar, 0)
 HELPERCALL(Simd128ReplaceLaneI2, Js::SIMDInt64x2Operation::OpReplaceLane, 0)
+HELPERCALL(Simd128TruncateI2, (void(*)(SIMDValue*, SIMDValue*))&Js::SIMDInt64x2Operation::OpTrunc<int64>, AttrCanThrow)
+HELPERCALL(Simd128TruncateU2, (void(*)(SIMDValue*, SIMDValue*))&Js::SIMDInt64x2Operation::OpTrunc<uint64>, AttrCanThrow)
+HELPERCALL(Simd128ConvertSD2, (void(*)(SIMDValue*, SIMDValue*))&Js::SIMDFloat64x2Operation::OpConv<int64>, 0)
+HELPERCALL(Simd128ConvertUD2, (void(*)(SIMDValue*, SIMDValue*))&Js::SIMDFloat64x2Operation::OpConv<uint64>, 0)
 #endif
 
 HELPERCALL(Op_TryCatch, nullptr, 0)
diff --git a/lib/Backend/LowerMDShared.h b/lib/Backend/LowerMDShared.h
@@ -347,6 +347,7 @@ class LowererMD
     void                EmitExtractInt64(IR::Opnd* dst, IR::Opnd* src, uint index, IR::Instr *instr);
     void                EmitInsertInt64(IR::Opnd* dst, uint index, IR::Instr *instr);
     void                EmitShiftByScalarI2(IR::Instr *instr, IR::JnHelperMethod helper);
+    IR::Instr*          EmitSimdConversion(IR::Instr *instr, IR::JnHelperMethod helper);
     IR::Instr*          SIMD128LowerReplaceLane_4(IR::Instr *instr);
     IR::Instr*          SIMD128LowerReplaceLane_8(IR::Instr *instr);
     IR::Instr*          SIMD128LowerReplaceLane_16(IR::Instr *instr);
diff --git a/lib/Backend/LowerMDSharedSimd128.cpp b/lib/Backend/LowerMDSharedSimd128.cpp
@@ -772,6 +772,14 @@ IR::Instr* LowererMD::Simd128LowerUnMappedInstruction(IR::Instr *instr)
     case Js::OpCode::Simd128_FromFloat32x4_U4:
         return Simd128LowerUint32x4FromFloat32x4(instr);
 
+    case Js::OpCode::Simd128_FromInt64x2_D2:
+        return EmitSimdConversion(instr, IR::HelperSimd128ConvertSD2);
+    case Js::OpCode::Simd128_FromUint64x2_D2:
+        return EmitSimdConversion(instr, IR::HelperSimd128ConvertUD2);
+    case Js::OpCode::Simd128_FromFloat64x2_I2:
+        return EmitSimdConversion(instr, IR::HelperSimd128TruncateI2);
+    case Js::OpCode::Simd128_FromFloat64x2_U2:
+        return EmitSimdConversion(instr, IR::HelperSimd128TruncateU2);
     case Js::OpCode::Simd128_Neq_I4:
     case Js::OpCode::Simd128_Neq_I8:
     case Js::OpCode::Simd128_Neq_I16:
@@ -901,6 +909,20 @@ IR::Instr* LowererMD::Simd128CanonicalizeToBools(IR::Instr* instr, const Js::OpC
     return instr;
 }
 
+IR::Instr* LowererMD::EmitSimdConversion(IR::Instr *instr, IR::JnHelperMethod helper)
+{
+    IR::MemRefOpnd* srcMemRef = LoadSimdHelperArgument(instr, 0);
+    IR::MemRefOpnd* dstMemRef = LoadSimdHelperArgument(instr, 1);
+    m_lowerer->InsertMove(srcMemRef, instr->UnlinkSrc1(), instr);
+
+    IR::Instr * helperCall = IR::Instr::New(Js::OpCode::CALL, this->m_func);
+    instr->InsertBefore(helperCall);
+    this->ChangeToHelperCall(helperCall, helper);
+
+    m_lowerer->InsertMove(instr->UnlinkDst(), dstMemRef, instr);
+    return removeInstr(instr);
+}
+
 void LowererMD::EmitShiftByScalarI2(IR::Instr *instr, IR::JnHelperMethod helper)
 {
     IR::Opnd* src2 = instr->GetSrc2();
diff --git a/lib/Runtime/ByteCode/OpCodesSimd.h b/lib/Runtime/ByteCode/OpCodesSimd.h
@@ -144,6 +144,8 @@ MACRO_SIMD_EXTEND_WMS(Simd128_ShRtByScalar_I2, Int64x2_2Int1, None, None, 0)
 MACRO_SIMD_EXTEND_WMS(Simd128_ShRtByScalar_U2, Int64x2_2Int1, None, None, 0)
 MACRO_SIMD_EXTEND_WMS(Simd128_AnyTrue_B2, Int1Bool64x2_1, None, None, 0)
 MACRO_SIMD_EXTEND_WMS(Simd128_AllTrue_B2, Int1Bool64x2_1, None, None, 0)
+MACRO_SIMD_EXTEND_WMS(Simd128_FromFloat64x2_I2, Int64x2_2, None, None, 0)
+MACRO_SIMD_EXTEND_WMS(Simd128_FromFloat64x2_U2, Int64x2_2, None, None, 0)
 
 // Float64x2
 MACRO_SIMD_EXTEND_WMS(Simd128_Splat_D2, Float64x2_1Double1, None, None, 0)
@@ -164,6 +166,8 @@ MACRO_SIMD_EXTEND_WMS(Simd128_Sub_D2, Float64x2_3, None, None, 0)
 MACRO_SIMD_EXTEND_WMS(Simd128_Mul_D2, Float64x2_3, None, None, 0)
 MACRO_SIMD_EXTEND_WMS(Simd128_Div_D2, Float64x2_3, None, None, 0)
 MACRO_SIMD_EXTEND_WMS(Simd128_Sqrt_D2, Float64x2_2, None, None, 0)
+MACRO_SIMD_EXTEND_WMS(Simd128_FromInt64x2_D2, Int64x2_2, None, None, 0)  //Int64x2_2 is intentional
+MACRO_SIMD_EXTEND_WMS(Simd128_FromUint64x2_D2, Int64x2_2, None, None, 0)
 // Float64x2
 #if 0 //Disabling this type until the specification decides to include or not.
 MACRO_SIMD_EXTEND_WMS(Simd128_DoublesToD2, Float64x2_1Double2, None, None, 0)
diff --git a/lib/Runtime/Language/InterpreterHandlerAsmJs.inl b/lib/Runtime/Language/InterpreterHandlerAsmJs.inl
@@ -723,6 +723,10 @@ EXDEF2_WMS(SIMD_D2_2toD2_1, Simd128_Neq_D2, Js::SIMDFloat64x2Operation::OpNotEqu
 EXDEF2_WMS(SIMD_D2_2toD2_1, Simd128_GtEq_D2, Js::SIMDFloat64x2Operation::OpGreaterThanOrEqual)
 EXDEF2_WMS(SIMD_D2_2toD2_1, Simd128_Gt_D2, Js::SIMDFloat64x2Operation::OpGreaterThan)
 EXDEF2_WMS(SIMD_D2_1toD2_1, Simd128_Sqrt_D2, SIMDFloat64x2Operation::OpSqrt)
+EXDEF2_WMS(SIMD_I2_1toI2_P, Simd128_FromInt64x2_D2, SIMDFloat64x2Operation::OpConv<int64>)
+EXDEF2_WMS(SIMD_I2_1toI2_P, Simd128_FromUint64x2_D2, SIMDFloat64x2Operation::OpConv<uint64>)
+EXDEF2_WMS(SIMD_I2_1toI2_P, Simd128_FromFloat64x2_I2, SIMDInt64x2Operation::OpTrunc<int64>)
+EXDEF2_WMS(SIMD_I2_1toI2_P, Simd128_FromFloat64x2_U2, SIMDInt64x2Operation::OpTrunc<uint64>)
 
 #if 0
 EXDEF2_WMS(SIMD_D2toD2_1, Simd128_DoublesToD2, SIMDFloat64x2Operation::OpFloat64x2)
diff --git a/lib/Runtime/Language/InterpreterProcessOpCodeAsmJs.h b/lib/Runtime/Language/InterpreterProcessOpCodeAsmJs.h
@@ -42,7 +42,6 @@
 
 #define PROCESS_FUNCtoA1Mem(name, func) PROCESS_FUNCtoA1Mem_COMMON(name, func,)
 
-
 #define PROCESS_CUSTOM_ASMJS_COMMON(name, func, layout, suffix) \
     case OpCodeAsmJs::name: \
     { \
@@ -873,6 +872,18 @@ if (switchProfileMode) \
     }
 #define PROCESS_SIMD_I2_1toI2_1  (name, func) PROCESS_SIMD_I2_1toI2_1_COMMON(name, func,)
 
+#define PROCESS_SIMD_I2_1toI2_P_COMMON(name, func, suffix) \
+    case OpCodeAsmJs::name: \
+    { \
+    PROCESS_READ_LAYOUT_ASMJS(name, Int64x2_2, suffix); \
+    SIMDValue result {0}; \
+    SIMDValue src = GetRegRawSimd(playout->I2_1); \
+    func(&result, &src); \
+    SetRegRawSimd(playout->I2_0, result); \
+    break; \
+    }
+#define PROCESS_SIMD_I2_1toI2_P(name, func) PROCESS_SIMD_I2_1toI2_P_COMMON(name, func,)
+
 #define PROCESS_SIMD_I2_1I1toI2_1_COMMON(name, func, suffix) \
     case OpCodeAsmJs::name: \
     { \
diff --git a/lib/Runtime/Language/InterpreterStackFrame.cpp b/lib/Runtime/Language/InterpreterStackFrame.cpp
@@ -3803,12 +3803,14 @@ namespace Js
         case AsmJsRetType::Uint32x4:
         case AsmJsRetType::Uint16x8:
         case AsmJsRetType::Uint8x16:
+#if _WIN32 //WASM.SIMD ToDo: Enable thunk for Xplat
 #if _M_X64
             X86SIMDValue simdVal;
             simdVal.m128_value = JavascriptFunction::CallAsmJsFunction<__m128>(function, entrypointInfo->jsMethod, m_outParams, alignedArgsSize, reg);
             m_localSimdSlots[returnReg] = X86SIMDValue::ToSIMDValue(simdVal);
 #else
             m_localSimdSlots[returnReg] = JavascriptFunction::CallAsmJsFunction<AsmJsSIMDValue>(function, entrypointInfo->jsMethod, m_outParams, alignedArgsSize, reg);
+#endif
 #endif
             break;
 #endif
diff --git a/lib/Runtime/Language/SimdFloat64x2Operation.h b/lib/Runtime/Language/SimdFloat64x2Operation.h
@@ -43,6 +43,7 @@ namespace Js {
         static SIMDValue OpGreaterThan(const SIMDValue& aValue, const SIMDValue& bValue);
         static SIMDValue OpGreaterThanOrEqual(const SIMDValue& aValue, const SIMDValue& bValue);
         static SIMDValue OpSelect(const SIMDValue& mV, const SIMDValue& tV, const SIMDValue& fV);
+        template<typename T> static void OpConv(SIMDValue* dst, SIMDValue* src);
     };
 
 } // namespace Js
diff --git a/lib/Runtime/Language/SimdFloat64x2OperationX86X64.cpp b/lib/Runtime/Language/SimdFloat64x2OperationX86X64.cpp
@@ -318,6 +318,16 @@ namespace Js
         return X86SIMDValue::ToSIMDValue(x86Result);
     }
 
+    template<typename T>
+    void SIMDFloat64x2Operation::OpConv(SIMDValue* dst, SIMDValue* src)
+    {
+        dst->f64[0] = (double) (T)src->i64[0];
+        dst->f64[1] = (double) (T)src->i64[1];
+    }
+
+    template void SIMDFloat64x2Operation::OpConv<int64>(SIMDValue* dst, SIMDValue* src);
+    template void SIMDFloat64x2Operation::OpConv<uint64>(SIMDValue* dst, SIMDValue* src);
+
 }
 
 #endif
diff --git a/lib/Runtime/Language/SimdInt64x2Operation.cpp b/lib/Runtime/Language/SimdInt64x2Operation.cpp
@@ -7,7 +7,6 @@
 
 namespace Js
 {
-
     SIMDValue SIMDInt64x2Operation::OpSplat(int64 val)
     {
         SIMDValue result;
@@ -40,6 +39,57 @@ namespace Js
         return result;
     }
 
+    static bool IsInRange(double val, uint64& out)
+    {
+        if (val != val || val <= (double)0)
+        {
+            out = 0;
+            return false;
+        }
+
+        if (val >= (double)ULLONG_MAX)
+        {
+            out = ULLONG_MAX;
+            return false;
+        }
+
+        return true;
+    }
+
+    static bool IsInRange(double val, int64& out)
+    {
+        if (val != val)
+        {
+            out = 0;
+            return false;
+        }
+
+        if (val <= (double)LLONG_MIN)
+        {
+            out = LLONG_MIN;
+            return false;
+        }
+
+        if (val >= (double)LLONG_MAX)
+        {
+            out = LLONG_MAX;
+            return false;
+        }
+
+        return true;
+    }
+
+    template<typename T>
+    void SIMDInt64x2Operation::OpTrunc(SIMDValue* dst, SIMDValue* src)
+    {
+        T convertedVal;
+        dst->i64[0] = IsInRange(src->f64[0], convertedVal) ? (T)src->f64[0] : convertedVal;
+        dst->i64[1] = IsInRange(src->f64[1], convertedVal) ? (T)src->f64[1] : convertedVal;
+    }
+
+    template void SIMDInt64x2Operation::OpTrunc<int64>(SIMDValue* dst, SIMDValue* src);
+    template void SIMDInt64x2Operation::OpTrunc<uint64>(SIMDValue* dst, SIMDValue* src);
+
     void SIMDInt64x2Operation::OpShiftLeftByScalar(SIMDValue* dst, SIMDValue* src, int count)
     {
         count = count & SIMDUtils::SIMDGetShiftAmountMask(8);
diff --git a/lib/Runtime/Language/SimdInt64x2Operation.h b/lib/Runtime/Language/SimdInt64x2Operation.h
@@ -16,6 +16,7 @@ namespace Js {
         //pointer-based arguments are used to ensure that calling conventions are consistent across x86/x64
         //and match call sequences JIT generates.
         //TODO: nikolayk back to "const SIMDValue& a"
+        template<typename T> static void OpTrunc(SIMDValue* dst, SIMDValue* src);
         static void OpShiftLeftByScalar(SIMDValue* dst, SIMDValue* src, int count);
         static void OpShiftRightByScalar(SIMDValue* dst, SIMDValue* src, int count);
         static void OpShiftRightByScalarU(SIMDValue* dst, SIMDValue* src, int count);
diff --git a/lib/Runtime/Library/amd64/JavascriptFunctionA.S b/lib/Runtime/Library/amd64/JavascriptFunctionA.S
@@ -184,11 +184,11 @@ LEAF_ENTRY _ZN2Js18JavascriptFunction17CallAsmJsFunctionIdEET_PNS_16RecyclableOb
     jmp C_FUNC(_ZN2Js18JavascriptFunction17CallAsmJsFunctionIiEET_PNS_16RecyclableObjectEPFPvS4_NS_8CallInfoEzEPS5_jPh)
 LEAF_END _ZN2Js18JavascriptFunction17CallAsmJsFunctionIdEET_PNS_16RecyclableObjectEPFPvS4_NS_8CallInfoEzEPS5_jPh, _TEXT
 
-// __m128 CallAsmJsFunction<__m128>(RecyclableObject *function, JavascriptMethod entryPoint, uint argc, Var *argv);
+// AsmJsSIMDValue CallAsmJsFunction<AsmJsSIMDValue>(RecyclableObject *function, JavascriptMethod entryPoint, uint argc, Var *argv);
 .balign 16
 LEAF_ENTRY _ZN2Js18JavascriptFunction17CallAsmJsFunctionIDv4_fEET_PNS_16RecyclableObjectEPFPvS5_NS_8CallInfoEzEjPS6_, _TEXT
-    int 3 //TODO: Verify this code path when enabling WASM.SIMD for xplat
-    jmp C_FUNC(_ZN2Js18JavascriptFunction17CallAsmJsFunctionIiEET_PNS_16RecyclableObjectEPFPvS4_NS_8CallInfoEzEjPS5_)
+    int 3  //TODO: Verify this code path when enabling WASM.SIMD for xplat
+    jmp C_FUNC(_ZN2Js18JavascriptFunction17CallAsmJsFunctionIiEET_PNS_16RecyclableObjectEPFPvS4_NS_8CallInfoEzEPS5_jPh)
 LEAF_END _ZN2Js18JavascriptFunction17CallAsmJsFunctionIDv4_fEET_PNS_16RecyclableObjectEPFPvS5_NS_8CallInfoEzEjPS6_, _TEXT
 
 #endif // _ENABLE_DYNAMIC_THUNKS
diff --git a/lib/WasmReader/WasmBinaryOpcodesSimd.h b/lib/WasmReader/WasmBinaryOpcodesSimd.h
@@ -195,12 +195,12 @@ WASM_UNARY__OPCODE(F4Sqrt, 0x182, M128_M128, Simd128_Sqrt_F4, false)
 WASM_UNARY__OPCODE(F2Sqrt, 0x183, M128_M128, Simd128_Sqrt_D2, false)
 WASM_UNARY__OPCODE(F4ConvertS, 0x184, M128_M128, Simd128_FromInt32x4_F4, false)
 WASM_UNARY__OPCODE(F4ConvertU, 0x185, M128_M128, Simd128_FromUint32x4_F4, false)
-WASM_MISC_OPCODE(F2ConvertS, 0x186, Limit, true)
-WASM_MISC_OPCODE(F2ConvertU, 0x187, Limit, true)
+WASM_UNARY__OPCODE(F2ConvertS, 0x186, M128_M128, Simd128_FromInt64x2_D2, false)
+WASM_UNARY__OPCODE(F2ConvertU, 0x187, M128_M128, Simd128_FromUint64x2_D2, false)
 WASM_UNARY__OPCODE(I4TruncS, 0x188, M128_M128, Simd128_FromFloat32x4_I4, false)
 WASM_UNARY__OPCODE(I4TruncU, 0x189, M128_M128, Simd128_FromFloat32x4_U4, false)
-WASM_MISC_OPCODE(I2TruncS, 0x18a, Limit, true)
-WASM_MISC_OPCODE(I2TruncU, 0x18b, Limit, true)
+WASM_UNARY__OPCODE(I2TruncS, 0x18a, M128_M128, Simd128_FromFloat64x2_I2, false)
+WASM_UNARY__OPCODE(I2TruncU, 0x18b, M128_M128, Simd128_FromFloat64x2_U2, false)
 
 #undef WASM_SIMD_BUILD_OPCODE
 #undef WASM_LANE_OPCODE
diff --git a/test/wasm.simd/math.wasm b/test/wasm.simd/math.wasm
diff --git a/test/wasm.simd/math.wast b/test/wasm.simd/math.wast
@@ -311,4 +311,24 @@
         (set_local $v1 (m128.load offset=0 align=4 (i32.const 0)))
         (m128.store offset=0 (i32.const 0) (f64x2.sqrt (get_local $v1)))
     )
+
+    (func (export "func_i64x2_trunc_s")  (local $v1 m128)
+        (set_local $v1 (m128.load offset=0 align=4 (i32.const 0)))
+        (m128.store offset=0 (i32.const 0) (i64x2.trunc_s (get_local $v1)))
+    )
+
+    (func (export "func_i64x2_trunc_u")  (local $v1 m128)
+        (set_local $v1 (m128.load offset=0 align=4 (i32.const 0)))
+        (m128.store offset=0 (i32.const 0) (i64x2.trunc_u (get_local $v1)))
+    )
+
+    (func (export "func_f64x2_convert_s")  (local $v1 m128)
+        (set_local $v1 (m128.load offset=0 align=4 (i32.const 0)))
+        (m128.store offset=0 (i32.const 0) (f64x2.convert_s (get_local $v1)))
+    )
+
+    (func (export "func_f64x2_convert_u")  (local $v1 m128)
+        (set_local $v1 (m128.load offset=0 align=4 (i32.const 0)))
+        (m128.store offset=0 (i32.const 0) (f64x2.convert_u (get_local $v1)))
+    )
 )
diff --git a/test/wasm.simd/mathTests.js b/test/wasm.simd/mathTests.js
@@ -20,7 +20,8 @@ const arrays = {
     "i16x8" : new Int16Array (memObj.buffer),
     "i8x16" : new Int8Array (memObj.buffer),
     "f32x4" : new Float32Array (memObj.buffer),
-    "f64x2" : new Float64Array (memObj.buffer)
+    "f64x2" : new Float64Array (memObj.buffer),
+    "i64x2" : new Int32Array (memObj.buffer)
 };
 
 function moveArgsIntoArray(args, offset, arr) {
@@ -70,6 +71,28 @@ let testMathOps = function (funcname, args1, args2, resultArr) {
     }
 }
 
+let reverse64x2Type = (type) => type === "f64x2" ? "i64x2" : "f64x2";
+let testTruncConvOps = function (funcname, args1, resultArr) {
+
+    const len = args1.length;
+    const type = funcname.split('_')[1];
+    const resultType = reverse64x2Type(type);
+    const arr = arrays[resultType];
+    const resultArrView = arrays[type];
+
+    moveArgsIntoArray(args1, 0, arr);
+    instance[funcname]();
+
+    for (let i = 0; i < resultArr.length; i++) {
+        if (type === "f64x2" && Number.isNaN(resultArr[i])) {
+            assertEquals(true, Number.isNaN(resultArrView[i]));
+        } else {
+            assertEquals(resultArr[i], resultArrView[i]);
+        }
+
+    }
+}
+
 //i32x4
 testMathOps("func_i32x4_add",
     [2147483645 , 0, -1, 65536],
@@ -357,6 +380,36 @@ testMathOps("func_i8x16_shuffle_test2",
     [0  , 17 , 1  , 18 , 2  , 19 , 3  , 20 , 4  , 21 , 5  , 22 , 6  , 23  , 7  , 24]
 );
 
+testTruncConvOps("func_f64x2_convert_u",
+    [0xffffffff|0, 0xffffffff|0, 0, 0],
+    [1.8446744073709552e+19, 0]
+);
+
+testTruncConvOps("func_f64x2_convert_s",
+    [0xffffffff|0, 0x7fffffff|0, 0x0|0, 0x80000000|0],
+    [9.2233720368547758e+18, -9.2233720368547758e+18]
+);
+
+testTruncConvOps("func_i64x2_trunc_u",
+    [1.8446744073709553e+19, -1],
+    [0xffffffff|0, 0xffffffff|0, 0, 0]
+);
+
+testTruncConvOps("func_i64x2_trunc_u",
+    [12345.6, Number.NaN],
+    [12345, 0, 0, 0]
+);
+
+testTruncConvOps("func_i64x2_trunc_s",
+    [9.2233720368547759e+18, -9.2233720368547759e+18],
+    [0xffffffff|0, 0x7fffffff|0, 0x0|0, 0x80000000|0]
+);
+
+testTruncConvOps("func_i64x2_trunc_s",
+    [-12345.6, Number.NaN],
+    [-12345, -1, 0, 0]
+);
+
 if (passed) {
     print("Passed");
 }

Original file line number	Diff line number	Diff line change
`@@ -4672,7 +4672,11 @@ IRBuilderAsmJs::BuildInt64x2_3(Js::OpCodeAsmJs newOpcode, uint32 offset, BUILD_S`
`4672`	`4672`	`void`
`4673`	`4673`	`IRBuilderAsmJs::BuildInt64x2_2(Js::OpCodeAsmJs newOpcode, uint32 offset, BUILD_SIMD_ARGS_REG2)`
`4674`	`4674`	`{`
`4675`		`- Assert(newOpcode == Js::OpCodeAsmJs::Simd128_Neg_I2);`
	`4675`	`+ Assert(newOpcode == Js::OpCodeAsmJs::Simd128_Neg_I2 \|\|`
	`4676`	`+ newOpcode == Js::OpCodeAsmJs::Simd128_FromUint64x2_D2 \|\|`
	`4677`	`+ newOpcode == Js::OpCodeAsmJs::Simd128_FromInt64x2_D2 \|\|`
	`4678`	`+ newOpcode == Js::OpCodeAsmJs::Simd128_FromFloat64x2_I2 \|\|`
	`4679`	`+ newOpcode == Js::OpCodeAsmJs::Simd128_FromFloat64x2_U2);`
`4676`	`4680`	`BuildSimd_2(newOpcode, offset, dstRegSlot, src1RegSlot, TySimd128I2);`
`4677`	`4681`	`}`
`4678`	`4682`