SIMDutils code refactoring

Refactoring SIMDUtils to clean up Js name space and to have better code
reuse.

lib/Backend/LowerMDSharedSimd128.cpp

@@ -1273,7 +1273,7 @@ IR::Instr* LowererMD::Simd128LowerShift(IR::Instr *instr)
     IR::RegOpnd *shamt = IR::RegOpnd::New(src2->GetType(), m_func);
     // en-register
     IR::Opnd *origShamt = EnregisterIntConst(instr, src2); //unnormalized shift amount
-    pInstr = IR::Instr::New(Js::OpCode::AND, shamt, origShamt, IR::IntConstOpnd::New(Js::SIMDGetShiftAmountMask(elementSizeInBytes), TyInt8, m_func), m_func); // normalizing by elm width (i.e. shamt % elm_width)
+    pInstr = IR::Instr::New(Js::OpCode::AND, shamt, origShamt, IR::IntConstOpnd::New(Js::SIMDUtils::SIMDGetShiftAmountMask(elementSizeInBytes), TyInt8, m_func), m_func); // normalizing by elm width (i.e. shamt % elm_width)
     instr->InsertBefore(pInstr);
     Legalize(pInstr);
 

lib/Runtime/Base/ThreadContext.cpp

@@ -576,7 +576,7 @@ void ThreadContext::AddSimdFuncToMaps(Js::OpCode op, ...)
         simdFuncSignature.args[iArg] = va_arg(arguments, ValueType);
     }
 
-    simdOpcodeToSignatureMap[Js::SimdOpcodeAsIndex(op)] = simdFuncSignature;
+    simdOpcodeToSignatureMap[Js::SIMDUtils::SimdOpcodeAsIndex(op)] = simdFuncSignature;
 
     va_end(arguments);
 }
@@ -625,8 +625,7 @@ Js::OpCode ThreadContext::GetSimdOpcodeFromFuncInfo(Js::FunctionInfo * funcInfo)
 void ThreadContext::GetSimdFuncSignatureFromOpcode(Js::OpCode op, SimdFuncSignature &funcSignature)
 {
     Assert(simdOpcodeToSignatureMap != nullptr);
-    funcSignature = simdOpcodeToSignatureMap[SimdOpcodeAsIndex(op)];
-
+    funcSignature = simdOpcodeToSignatureMap[Js::SIMDUtils::SimdOpcodeAsIndex(op)];
 }
 #endif
 

lib/Runtime/Language/InterpreterHandlerAsmJs.inl

@@ -187,12 +187,12 @@ EXDEF2    (NOPASMJS          , NopEx        , Empty
   //DEF2_WMS( SIMD_D2_1toF4_1  , Simd128_FromFloat64x2_F4    ,SIMDFloat32x4Operation::OpFromFloat64x2      )
   //DEF2_WMS( SIMD_D2_1toF4_1  , Simd128_FromFloat64x2Bits_F4,Js::FromSimdBits                             )
   DEF2_WMS( SIMD_I4_1toF4_1  , Simd128_FromInt32x4_F4      ,SIMDFloat32x4Operation::OpFromInt32x4        )
-  DEF2_WMS( SIMD_I4_1toF4_1  , Simd128_FromInt32x4Bits_F4  ,Js::FromSimdBits                             )
+  DEF2_WMS( SIMD_I4_1toF4_1  , Simd128_FromInt32x4Bits_F4  ,Js::SIMDUtils::FromSimdBits                  )
   DEF3_WMS( CUSTOM_ASMJS     , Simd128_FromFloat32x4_I4    , OP_SimdInt32x4FromFloat32x4 ,  Int32x4_1Float32x4_1 )
 
   //DEF2_WMS( SIMD_D2_1toI4_1  , Simd128_FromFloat64x2_I4    ,SIMDInt32x4Operation::OpFromFloat64x2        )
   //DEF2_WMS( SIMD_D2_1toI4_1  , Simd128_FromFloat64x2Bits_I4,Js::FromSimdBits                             )
-  DEF2_WMS( SIMD_F4_1toI4_1  , Simd128_FromFloat32x4Bits_I4,Js::FromSimdBits                             )
+  DEF2_WMS( SIMD_F4_1toI4_1  , Simd128_FromFloat32x4Bits_I4,Js::SIMDUtils::FromSimdBits                  )
 
   DEF2_WMS( SIMD_F4_1toF4_1  , Simd128_Abs_F4              ,SIMDFloat32x4Operation::OpAbs                )
 
@@ -203,19 +203,18 @@ EXDEF2    (NOPASMJS          , NopEx        , Empty
   DEF2_WMS( SIMD_F4_1toF4_1  , Simd128_RcpSqrt_F4          ,SIMDFloat32x4Operation::OpReciprocalSqrt     )
   DEF2_WMS( SIMD_F4_1toF4_1  , Simd128_Sqrt_F4             ,SIMDFloat32x4Operation::OpSqrt               )
 
-
   DEF2_WMS( SIMD_I4_1toI4_1  , Simd128_Not_I4              , Js::SIMDInt32x4Operation::OpNot             )
-  EXDEF2_WMS( SIMD_B4_1toB4_1, Simd128_Not_B4              , Js::SIMDInt32x4Operation::OpNot            )
-  EXDEF2_WMS( SIMD_B8_1toB8_1, Simd128_Not_B8              , Js::SIMDInt32x4Operation::OpNot            )
-  DEF2_WMS( SIMD_B16_1toB16_1, Simd128_Not_B16           , Js::SIMDInt32x4Operation::OpNot            )
+  EXDEF2_WMS( SIMD_B4_1toB4_1, Simd128_Not_B4              , Js::SIMDInt32x4Operation::OpNot             )
+  EXDEF2_WMS( SIMD_B8_1toB8_1, Simd128_Not_B8              , Js::SIMDInt32x4Operation::OpNot             )
+  DEF2_WMS( SIMD_B16_1toB16_1, Simd128_Not_B16             , Js::SIMDInt32x4Operation::OpNot             )
     
   EXDEF2_WMS( SIMD_B4_1toI1, Simd128_AllTrue_B4            , Js::SIMDBool32x4Operation::OpAllTrue        )
   EXDEF2_WMS( SIMD_B8_1toI1, Simd128_AllTrue_B8            , Js::SIMDBool32x4Operation::OpAllTrue        )
   EXDEF2_WMS( SIMD_B16_1toI1, Simd128_AllTrue_B16          , Js::SIMDBool32x4Operation::OpAllTrue        )
 
-  EXDEF2_WMS( SIMD_B4_1toI1, Simd128_AnyTrue_B4            , Js::SIMDBool32x4Operation::OpAnyTrue          )
-  EXDEF2_WMS( SIMD_B8_1toI1, Simd128_AnyTrue_B8            , Js::SIMDBool32x4Operation::OpAnyTrue          )
-  EXDEF2_WMS( SIMD_B16_1toI1, Simd128_AnyTrue_B16          , Js::SIMDBool32x4Operation::OpAnyTrue          )
+  EXDEF2_WMS( SIMD_B4_1toI1, Simd128_AnyTrue_B4            , Js::SIMDBool32x4Operation::OpAnyTrue        )
+  EXDEF2_WMS( SIMD_B8_1toI1, Simd128_AnyTrue_B8            , Js::SIMDBool32x4Operation::OpAnyTrue        )
+  EXDEF2_WMS( SIMD_B16_1toI1, Simd128_AnyTrue_B16          , Js::SIMDBool32x4Operation::OpAnyTrue        )
 
   DEF2_WMS(SIMD_I4_1I1toI4_1 , Simd128_ShLtByScalar_I4     , Js::SIMDInt32x4Operation::OpShiftLeftByScalar)
   DEF2_WMS(SIMD_I4_1I1toI4_1 , Simd128_ShRtByScalar_I4     , Js::SIMDInt32x4Operation::OpShiftRightByScalar)
@@ -284,11 +283,11 @@ EXDEF2    (NOPASMJS          , NopEx        , Empty
   DEF2_WMS   ( SIMD_F4_1toF4_1   , Simd128_I_Conv_VTF4     , (AsmJsSIMDValue)                            )
   DEF2_WMS   ( SIMD_I4_1toI4_1   , Simd128_I_Conv_VTI4     , (AsmJsSIMDValue)                            )
 
-  DEF2_WMS   ( SIMD_F4_1I4toF4_1   , Simd128_Swizzle_F4      , SIMD128InnerShuffle                       )
-  DEF2_WMS   ( SIMD_F4_2I4toF4_1   , Simd128_Shuffle_F4      , SIMD128InnerShuffle                       )
+  DEF2_WMS   ( SIMD_F4_1I4toF4_1   , Simd128_Swizzle_F4      , SIMDUtils::SIMD128InnerShuffle            )
+  DEF2_WMS   ( SIMD_F4_2I4toF4_1   , Simd128_Shuffle_F4      , SIMDUtils::SIMD128InnerShuffle            )
 
-  DEF2_WMS   ( SIMD_I4_1I4toI4_1   , Simd128_Swizzle_I4      , SIMD128InnerShuffle                       )
-  DEF2_WMS   ( SIMD_I4_2I4toI4_1   , Simd128_Shuffle_I4      , SIMD128InnerShuffle                       )
+  DEF2_WMS   ( SIMD_I4_1I4toI4_1   , Simd128_Swizzle_I4      , SIMDUtils::SIMD128InnerShuffle            )
+  DEF2_WMS   ( SIMD_I4_2I4toI4_1   , Simd128_Shuffle_I4      , SIMDUtils::SIMD128InnerShuffle            )
 
   
   DEF2_WMS    ( SIMD_I8_1toI8_1      , Simd128_Ld_I8           , (AsmJsSIMDValue)                           )
@@ -346,56 +345,58 @@ EXDEF2    (NOPASMJS          , NopEx        , Empty
   EXDEF2_WMS ( SIMD_I16_1toI16_1  , Simd128_I_Conv_VTI16     , (AsmJsSIMDValue)                            )
   
   //Lane Access
-  DEF2_WMS   ( SIMD_I16_1I1toI1    , Simd128_ExtractLane_I16  , SIMD128InnerExtractLaneI16                 )
-  DEF2_WMS   ( SIMD_I16_1I2toI16_1 , Simd128_ReplaceLane_I16  , SIMD128InnerReplaceLaneI16                 )
-  EXDEF2_WMS   ( SIMD_I4_1I1toI1   , Simd128_ExtractLane_I4  , SIMD128InnerExtractLaneI4                   )
-  EXDEF2_WMS   ( SIMD_F4_1I1toF1   , Simd128_ExtractLane_F4  , SIMD128InnerExtractLaneF4                   )
-  EXDEF2_WMS   ( SIMD_I8_1I1toI1   , Simd128_ExtractLane_I8  , SIMD128InnerExtractLaneI8                   )
-  EXDEF2_WMS   ( SIMD_U4_1I1toI1   , Simd128_ExtractLane_U4  , SIMD128InnerExtractLaneI4                   )
-  EXDEF2_WMS   ( SIMD_U8_1I1toI1   , Simd128_ExtractLane_U8  , SIMD128InnerExtractLaneI8                   )
-  EXDEF2_WMS   ( SIMD_U16_1I1toI1  , Simd128_ExtractLane_U16 , SIMD128InnerExtractLaneI16                  )
-  EXDEF2_WMS   ( SIMD_B4_1I1toI1   , Simd128_ExtractLane_B4  , SIMD128InnerExtractLaneI4                   )
-  EXDEF2_WMS   ( SIMD_B8_1I1toI1   , Simd128_ExtractLane_B8  , SIMD128InnerExtractLaneI8                   )
-  EXDEF2_WMS   ( SIMD_B16_1I1toI1  , Simd128_ExtractLane_B16 , SIMD128InnerExtractLaneI16                  )
-
-  EXDEF2_WMS   ( SIMD_I4_1I2toI4_1   , Simd128_ReplaceLane_I4 , SIMD128InnerReplaceLaneI4                  )
-  EXDEF2_WMS   ( SIMD_F4_1I1F1toF4_1 , Simd128_ReplaceLane_F4 , SIMD128InnerReplaceLaneF4                  )
-  EXDEF2_WMS   ( SIMD_I8_1I2toI8_1   , Simd128_ReplaceLane_I8 , SIMD128InnerReplaceLaneI8                  )
-  EXDEF2_WMS   ( SIMD_U4_1I2toU4_1   , Simd128_ReplaceLane_U4 , SIMD128InnerReplaceLaneI4                  )
-  EXDEF2_WMS   ( SIMD_U8_1I2toU8_1   , Simd128_ReplaceLane_U8 , SIMD128InnerReplaceLaneI8                  )
-  EXDEF2_WMS   ( SIMD_U16_1I2toU16_1 , Simd128_ReplaceLane_U16, SIMD128InnerReplaceLaneI16                 )
-  EXDEF2_WMS   ( SIMD_B4_1I2toB4_1   , Simd128_ReplaceLane_B4 , SIMD128InnerReplaceLaneI4                  )
-  EXDEF2_WMS   ( SIMD_B8_1I2toB8_1   , Simd128_ReplaceLane_B8 , SIMD128InnerReplaceLaneI8                  )
-  EXDEF2_WMS   ( SIMD_B16_1I2toB16_1 , Simd128_ReplaceLane_B16, SIMD128InnerReplaceLaneI16                 )
+  DEF2_WMS   ( SIMD_I16_1I1toI1    , Simd128_ExtractLane_I16 , SIMDUtils::SIMD128InnerExtractLaneI16       )
+  DEF2_WMS   ( SIMD_I16_1I2toI16_1 , Simd128_ReplaceLane_I16 , SIMDUtils::SIMD128InnerReplaceLaneI16       )
+  EXDEF2_WMS   ( SIMD_I4_1I1toI1   , Simd128_ExtractLane_I4  , SIMDUtils::SIMD128InnerExtractLaneI4        )
+  EXDEF2_WMS   ( SIMD_F4_1I1toF1   , Simd128_ExtractLane_F4  , SIMDUtils::SIMD128InnerExtractLaneF4        )
+  EXDEF2_WMS   ( SIMD_I8_1I1toI1   , Simd128_ExtractLane_I8  , SIMDUtils::SIMD128InnerExtractLaneI8        )
+  EXDEF2_WMS   ( SIMD_U4_1I1toI1   , Simd128_ExtractLane_U4  , SIMDUtils::SIMD128InnerExtractLaneI4        )
+  EXDEF2_WMS   ( SIMD_U8_1I1toI1   , Simd128_ExtractLane_U8  , SIMDUtils::SIMD128InnerExtractLaneI8        )
+  EXDEF2_WMS   ( SIMD_U16_1I1toI1  , Simd128_ExtractLane_U16 , SIMDUtils::SIMD128InnerExtractLaneI16       )
+  EXDEF2_WMS   ( SIMD_B4_1I1toI1   , Simd128_ExtractLane_B4  , SIMDUtils::SIMD128InnerExtractLaneI4        )
+  EXDEF2_WMS   ( SIMD_B8_1I1toI1   , Simd128_ExtractLane_B8  , SIMDUtils::SIMD128InnerExtractLaneI8        )
+  EXDEF2_WMS   ( SIMD_B16_1I1toI1  , Simd128_ExtractLane_B16 , SIMDUtils::SIMD128InnerExtractLaneI16       )
+
+  EXDEF2_WMS   ( SIMD_I4_1I2toI4_1   , Simd128_ReplaceLane_I4 , SIMDUtils::SIMD128InnerReplaceLaneI4       )
+  EXDEF2_WMS   ( SIMD_F4_1I1F1toF4_1 , Simd128_ReplaceLane_F4 , SIMDUtils::SIMD128InnerReplaceLaneF4       )
+  EXDEF2_WMS   ( SIMD_I8_1I2toI8_1   , Simd128_ReplaceLane_I8 , SIMDUtils::SIMD128InnerReplaceLaneI8       )
+  EXDEF2_WMS   ( SIMD_U4_1I2toU4_1   , Simd128_ReplaceLane_U4 , SIMDUtils::SIMD128InnerReplaceLaneI4       )
+  EXDEF2_WMS   ( SIMD_U8_1I2toU8_1   , Simd128_ReplaceLane_U8 , SIMDUtils::SIMD128InnerReplaceLaneI8       )
+  EXDEF2_WMS   ( SIMD_U16_1I2toU16_1 , Simd128_ReplaceLane_U16, SIMDUtils::SIMD128InnerReplaceLaneI16      )
+  EXDEF2_WMS   ( SIMD_B4_1I2toB4_1   , Simd128_ReplaceLane_B4 , SIMDUtils::SIMD128InnerReplaceLaneI4       )
+  EXDEF2_WMS   ( SIMD_B8_1I2toB8_1   , Simd128_ReplaceLane_B8 , SIMDUtils::SIMD128InnerReplaceLaneI8       )
+  EXDEF2_WMS   ( SIMD_B16_1I2toB16_1 , Simd128_ReplaceLane_B16, SIMDUtils::SIMD128InnerReplaceLaneI16      )
 
   EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_LdArr_F4        , OP_SimdLdArrGeneric , AsmSimdTypedArr       )
   EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_LdArr_I4        , OP_SimdLdArrGeneric , AsmSimdTypedArr       )
   EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_StArr_F4        , OP_SimdStArrGeneric , AsmSimdTypedArr       )
   EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_StArr_I4        , OP_SimdStArrGeneric , AsmSimdTypedArr       )
 
-  EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_LdArrConst_F4        , OP_SimdLdArrConstIndex  , AsmSimdTypedArr       )
-  EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_LdArrConst_I4        , OP_SimdLdArrConstIndex  , AsmSimdTypedArr       )
-  EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_StArrConst_F4        , OP_SimdStArrConstIndex  , AsmSimdTypedArr       )
-  EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_StArrConst_I4        , OP_SimdStArrConstIndex  , AsmSimdTypedArr       )
+  EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_LdArrConst_F4   , OP_SimdLdArrConstIndex  , AsmSimdTypedArr   )
+  EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_LdArrConst_I4   , OP_SimdLdArrConstIndex  , AsmSimdTypedArr   )
+  EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_StArrConst_F4   , OP_SimdStArrConstIndex  , AsmSimdTypedArr   )
+  EXDEF3_WMS   ( CUSTOM_ASMJS      , Simd128_StArrConst_I4   , OP_SimdStArrConstIndex  , AsmSimdTypedArr   )
 
   EXDEF2_WMS   ( SIMD_F4_2toF4_1    , Simd128_MinNum_F4            , Js::SIMDFloat32x4Operation::OpMinNum   )
   EXDEF2_WMS   ( SIMD_F4_2toF4_1    , Simd128_MaxNum_F4            , Js::SIMDFloat32x4Operation::OpMaxNum   )
   
   EXDEF2_WMS   ( SIMD_U4_1toF4_1    , Simd128_FromUint32x4_F4      , Js::SIMDFloat32x4Operation::OpFromUint32x4  )
-  EXDEF2_WMS   ( SIMD_I8_1toF4_1    , Simd128_FromInt16x8Bits_F4       , Js::FromSimdBits                   )
-  EXDEF2_WMS   ( SIMD_I16_1toF4_1   , Simd128_FromInt8x16Bits_F4       , Js::FromSimdBits                   )
-  EXDEF2_WMS   ( SIMD_U4_1toF4_1    , Simd128_FromUint32x4Bits_F4      , Js::FromSimdBits                   )
-  EXDEF2_WMS   ( SIMD_U8_1toF4_1    , Simd128_FromUint16x8Bits_F4      , Js::FromSimdBits                   )
-  EXDEF2_WMS   ( SIMD_U16_1toF4_1   , Simd128_FromUint8x16Bits_F4      , Js::FromSimdBits                   )
+  EXDEF2_WMS   ( SIMD_I8_1toF4_1    , Simd128_FromInt16x8Bits_F4   , Js::SIMDUtils::FromSimdBits            )
+  EXDEF2_WMS   ( SIMD_I16_1toF4_1   , Simd128_FromInt8x16Bits_F4   , Js::SIMDUtils::FromSimdBits            )
+  EXDEF2_WMS   ( SIMD_U4_1toF4_1    , Simd128_FromUint32x4Bits_F4  , Js::SIMDUtils::FromSimdBits            )
+  EXDEF2_WMS   ( SIMD_U8_1toF4_1    , Simd128_FromUint16x8Bits_F4  , Js::SIMDUtils::FromSimdBits            )
+  EXDEF2_WMS   ( SIMD_U16_1toF4_1   , Simd128_FromUint8x16Bits_F4  , Js::SIMDUtils::FromSimdBits            )
+
+  
   
-  EXDEF2_WMS   ( SIMD_I8_1toI4_1    , Simd128_FromInt16x8Bits_I4       , Js::FromSimdBits                   )
-  EXDEF2_WMS   ( SIMD_I16_1toI4_1   , Simd128_FromInt8x16Bits_I4       , Js::FromSimdBits                   )
-  EXDEF2_WMS   ( SIMD_U4_1toI4_1    , Simd128_FromUint32x4Bits_I4      , Js::FromSimdBits                   )
-  EXDEF2_WMS   ( SIMD_U8_1toI4_1    , Simd128_FromUint16x8Bits_I4      , Js::FromSimdBits                   )
-  EXDEF2_WMS   ( SIMD_U16_1toI4_1   , Simd128_FromUint8x16Bits_I4      , Js::FromSimdBits                   )
+  EXDEF2_WMS   ( SIMD_I8_1toI4_1    , Simd128_FromInt16x8Bits_I4   , Js::SIMDUtils::FromSimdBits            )
+  EXDEF2_WMS   ( SIMD_I16_1toI4_1   , Simd128_FromInt8x16Bits_I4   , Js::SIMDUtils::FromSimdBits            )
+  EXDEF2_WMS   ( SIMD_U4_1toI4_1    , Simd128_FromUint32x4Bits_I4  , Js::SIMDUtils::FromSimdBits            )
+  EXDEF2_WMS   ( SIMD_U8_1toI4_1    , Simd128_FromUint16x8Bits_I4  , Js::SIMDUtils::FromSimdBits            )
+  EXDEF2_WMS   ( SIMD_U16_1toI4_1   , Simd128_FromUint8x16Bits_I4  , Js::SIMDUtils::FromSimdBits            )
 
   EXDEF3_WMS   ( CUSTOM_ASMJS       , Simd128_IntsToI8                 , OP_SimdInt16x8     , Int16x8_1Int8 )
-  DEF3_WMS   ( CUSTOM_ASMJS       , Simd128_IntsToI16                , OP_SimdInt8x16     , Int8x16_1Int16)
+  DEF3_WMS     ( CUSTOM_ASMJS       , Simd128_IntsToI16                , OP_SimdInt8x16     , Int8x16_1Int16)
   EXDEF2_WMS   ( SIMD_I4toU4_1      , Simd128_IntsToU4                 , SIMDUint32x4Operation::OpUint32x4  )
   EXDEF3_WMS   ( CUSTOM_ASMJS       , Simd128_IntsToU8                 , OP_SimdUint16x8     , Uint16x8_1Int8)
   EXDEF3_WMS   ( CUSTOM_ASMJS       , Simd128_IntsToU16                , OP_SimdUint8x16     , Uint8x16_1Int16)
@@ -424,16 +425,16 @@ EXDEF2    (NOPASMJS          , NopEx        , Empty
   EXDEF2_WMS   ( SIMD_B8_1toB8_1   , Simd128_Return_B8       , (AsmJsSIMDValue)                            )
   EXDEF2_WMS   ( SIMD_B16_1toB16_1 , Simd128_Return_B16      , (AsmJsSIMDValue)                            )
   
-  EXDEF2_WMS   ( SIMD_I8_1I8toI8_1    , Simd128_Swizzle_I8   , SIMD128InnerShuffle                        )
-  EXDEF2_WMS   ( SIMD_I8_2I8toI8_1    , Simd128_Shuffle_I8   , SIMD128InnerShuffle                        )
-  DEF2_WMS   ( SIMD_I16_1I16toI16_1 , Simd128_Swizzle_I16  , SIMD128InnerShuffle                          )
-  DEF2_WMS   ( SIMD_I16_2I16toI16_1 , Simd128_Shuffle_I16  , SIMD128InnerShuffle                          )
-  EXDEF2_WMS   ( SIMD_U4_1I4toU4_1    , Simd128_Swizzle_U4   , SIMD128InnerShuffle                        )
-  EXDEF2_WMS   ( SIMD_U4_2I4toU4_1    , Simd128_Shuffle_U4   , SIMD128InnerShuffle                        )
-  EXDEF2_WMS   ( SIMD_U8_1I8toU8_1    , Simd128_Swizzle_U8   , SIMD128InnerShuffle                        )
-  EXDEF2_WMS   ( SIMD_U8_2I8toU8_1    , Simd128_Shuffle_U8   , SIMD128InnerShuffle                        )
-  EXDEF2_WMS   ( SIMD_U16_1I16toU16_1 , Simd128_Swizzle_U16  , SIMD128InnerShuffle                        )
-  EXDEF2_WMS   ( SIMD_U16_2I16toU16_1 , Simd128_Shuffle_U16  , SIMD128InnerShuffle                        )
+  EXDEF2_WMS   ( SIMD_I8_1I8toI8_1    , Simd128_Swizzle_I8   , SIMDUtils::SIMD128InnerShuffle              )
+  EXDEF2_WMS   ( SIMD_I8_2I8toI8_1    , Simd128_Shuffle_I8   , SIMDUtils::SIMD128InnerShuffle              )
+  DEF2_WMS     ( SIMD_I16_1I16toI16_1 , Simd128_Swizzle_I16  , SIMDUtils::SIMD128InnerShuffle              )
+  DEF2_WMS     ( SIMD_I16_2I16toI16_1 , Simd128_Shuffle_I16  , SIMDUtils::SIMD128InnerShuffle              )
+  EXDEF2_WMS   ( SIMD_U4_1I4toU4_1    , Simd128_Swizzle_U4   , SIMDUtils::SIMD128InnerShuffle              )
+  EXDEF2_WMS   ( SIMD_U4_2I4toU4_1    , Simd128_Shuffle_U4   , SIMDUtils::SIMD128InnerShuffle              )
+  EXDEF2_WMS   ( SIMD_U8_1I8toU8_1    , Simd128_Swizzle_U8   , SIMDUtils::SIMD128InnerShuffle              )
+  EXDEF2_WMS   ( SIMD_U8_2I8toU8_1    , Simd128_Shuffle_U8   , SIMDUtils::SIMD128InnerShuffle              )
+  EXDEF2_WMS   ( SIMD_U16_1I16toU16_1 , Simd128_Swizzle_U16  , SIMDUtils::SIMD128InnerShuffle              )
+  EXDEF2_WMS   ( SIMD_U16_2I16toU16_1 , Simd128_Shuffle_U16  , SIMDUtils::SIMD128InnerShuffle              )
 
   EXDEF2_WMS( SIMD_I1toI8_1    , Simd128_Splat_I8     ,Js::SIMDInt16x8Operation::OpSplat                   )
   EXDEF2_WMS( SIMD_I1toU4_1    , Simd128_Splat_U4     ,Js::SIMDUint32x4Operation::OpSplat                  )
@@ -515,41 +516,41 @@ EXDEF2    (NOPASMJS          , NopEx        , Empty
   EXDEF3_WMS( CUSTOM_ASMJS      , Simd128_StArr_U8              , OP_SimdStArrGeneric , AsmSimdTypedArr         )
   EXDEF3_WMS( CUSTOM_ASMJS      , Simd128_StArr_U16             , OP_SimdStArrGeneric , AsmSimdTypedArr         )
 
-  EXDEF2_WMS( SIMD_F4_1toI8_1  , Simd128_FromFloat32x4Bits_I8   , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_I4_1toI8_1  , Simd128_FromInt32x4Bits_I8     , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_I16_1toI8_1 , Simd128_FromInt8x16Bits_I8     , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_U4_1toI8_1  , Simd128_FromUint32x4Bits_I8    , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_U8_1toI8_1  , Simd128_FromUint16x8Bits_I8    , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_U16_1toI8_1 , Simd128_FromUint8x16Bits_I8    , Js::FromSimdBits                              )
+  EXDEF2_WMS( SIMD_F4_1toI8_1  , Simd128_FromFloat32x4Bits_I8   , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I4_1toI8_1  , Simd128_FromInt32x4Bits_I8     , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I16_1toI8_1 , Simd128_FromInt8x16Bits_I8     , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U4_1toI8_1  , Simd128_FromUint32x4Bits_I8    , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U8_1toI8_1  , Simd128_FromUint16x8Bits_I8    , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U16_1toI8_1 , Simd128_FromUint8x16Bits_I8    , Js::SIMDUtils::FromSimdBits                   )
       
-  EXDEF2_WMS( SIMD_F4_1toI16_1 , Simd128_FromFloat32x4Bits_I16  , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_I4_1toI16_1 , Simd128_FromInt32x4Bits_I16    , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_I8_1toI16_1 , Simd128_FromInt16x8Bits_I16    , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_U4_1toI16_1 , Simd128_FromUint32x4Bits_I16   , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_U8_1toI16_1 , Simd128_FromUint16x8Bits_I16   , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_U16_1toI16_1, Simd128_FromUint8x16Bits_I16   , Js::FromSimdBits                              )
-
-  EXDEF3_WMS( CUSTOM_ASMJS     , Simd128_FromFloat32x4_U4      , OP_SimdUint32x4FromFloat32x4 , Uint32x4_1Float32x4_1)
-  EXDEF2_WMS( SIMD_F4_1toU4_1  , Simd128_FromFloat32x4Bits_U4   , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_I4_1toU4_1  , Simd128_FromInt32x4Bits_U4     , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_I8_1toU4_1  , Simd128_FromInt16x8Bits_U4     , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_I16_1toU4_1 , Simd128_FromInt8x16Bits_U4     , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_U8_1toU4_1  , Simd128_FromUint16x8Bits_U4    , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_U16_1toU4_1 , Simd128_FromUint8x16Bits_U4    , Js::FromSimdBits                              )
-  
-  EXDEF2_WMS( SIMD_F4_1toU8_1  , Simd128_FromFloat32x4Bits_U8   , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_I4_1toU8_1  , Simd128_FromInt32x4Bits_U8     , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_I8_1toU8_1  , Simd128_FromInt16x8Bits_U8     , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_I16_1toU8_1 , Simd128_FromInt8x16Bits_U8     , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_U4_1toU8_1  , Simd128_FromUint32x4Bits_U8    , Js::FromSimdBits                              )
-  EXDEF2_WMS( SIMD_U16_1toU8_1 , Simd128_FromUint8x16Bits_U8    , Js::FromSimdBits                              )
-  
-  EXDEF2_WMS( SIMD_F4_1toU16_1  , Simd128_FromFloat32x4Bits_U16   , Js::FromSimdBits                            )
-  EXDEF2_WMS( SIMD_I4_1toU16_1  , Simd128_FromInt32x4Bits_U16     , Js::FromSimdBits                            )
-  EXDEF2_WMS( SIMD_I8_1toU16_1  , Simd128_FromInt16x8Bits_U16     , Js::FromSimdBits                            )
-  EXDEF2_WMS( SIMD_I16_1toU16_1 , Simd128_FromInt8x16Bits_U16     , Js::FromSimdBits                            )
-  EXDEF2_WMS( SIMD_U4_1toU16_1  , Simd128_FromUint32x4Bits_U16    , Js::FromSimdBits                            )
-  EXDEF2_WMS( SIMD_U8_1toU16_1  , Simd128_FromUint16x8Bits_U16    , Js::FromSimdBits                            )
+  EXDEF2_WMS( SIMD_F4_1toI16_1 , Simd128_FromFloat32x4Bits_I16  , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I4_1toI16_1 , Simd128_FromInt32x4Bits_I16    , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I8_1toI16_1 , Simd128_FromInt16x8Bits_I16    , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U4_1toI16_1 , Simd128_FromUint32x4Bits_I16   , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U8_1toI16_1 , Simd128_FromUint16x8Bits_I16   , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U16_1toI16_1, Simd128_FromUint8x16Bits_I16   , Js::SIMDUtils::FromSimdBits                   )
+
+  EXDEF3_WMS( CUSTOM_ASMJS     , Simd128_FromFloat32x4_U4       , OP_SimdUint32x4FromFloat32x4 , Uint32x4_1Float32x4_1)
+  EXDEF2_WMS( SIMD_F4_1toU4_1  , Simd128_FromFloat32x4Bits_U4   , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I4_1toU4_1  , Simd128_FromInt32x4Bits_U4     , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I8_1toU4_1  , Simd128_FromInt16x8Bits_U4     , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I16_1toU4_1 , Simd128_FromInt8x16Bits_U4     , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U8_1toU4_1  , Simd128_FromUint16x8Bits_U4    , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U16_1toU4_1 , Simd128_FromUint8x16Bits_U4    , Js::SIMDUtils::FromSimdBits                   )
+
+  EXDEF2_WMS( SIMD_F4_1toU8_1  , Simd128_FromFloat32x4Bits_U8   , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I4_1toU8_1  , Simd128_FromInt32x4Bits_U8     , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I8_1toU8_1  , Simd128_FromInt16x8Bits_U8     , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I16_1toU8_1 , Simd128_FromInt8x16Bits_U8     , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U4_1toU8_1  , Simd128_FromUint32x4Bits_U8    , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U16_1toU8_1 , Simd128_FromUint8x16Bits_U8    , Js::SIMDUtils::FromSimdBits                   )
+
+  EXDEF2_WMS( SIMD_F4_1toU16_1  , Simd128_FromFloat32x4Bits_U16 , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I4_1toU16_1  , Simd128_FromInt32x4Bits_U16   , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I8_1toU16_1  , Simd128_FromInt16x8Bits_U16   , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_I16_1toU16_1 , Simd128_FromInt8x16Bits_U16   , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U4_1toU16_1  , Simd128_FromUint32x4Bits_U16  , Js::SIMDUtils::FromSimdBits                   )
+  EXDEF2_WMS( SIMD_U8_1toU16_1  , Simd128_FromUint16x8Bits_U16  , Js::SIMDUtils::FromSimdBits                   )
 
   EXDEF2_WMS( SIMD_I8_2toB8_1  , Simd128_Lt_I8               , Js::SIMDInt16x8Operation::OpLessThan             )
   EXDEF2_WMS( SIMD_U4_2toB4_1  , Simd128_Lt_U4               , Js::SIMDUint32x4Operation::OpLessThan            )

lib/Runtime/Language/InterpreterProcessOpCodeAsmJs.h

@@ -827,7 +827,7 @@ if (switchProfileMode) \
     case OpCodeAsmJs::name: \
     { \
     PROCESS_READ_LAYOUT_ASMJS(name, Int8x16_2Int16, suffix); \
-    int32 lanes[16]; \
+    uint32 lanes[16]; \
     lanes[0] = GetRegRawInt(playout->I2);   lanes[1] = GetRegRawInt(playout->I3); \
     lanes[2] = GetRegRawInt(playout->I4);   lanes[3] = GetRegRawInt(playout->I5); \
     lanes[4] = GetRegRawInt(playout->I6);   lanes[5] = GetRegRawInt(playout->I7); \
@@ -846,7 +846,7 @@ if (switchProfileMode) \
     case OpCodeAsmJs::name: \
     { \
     PROCESS_READ_LAYOUT_ASMJS(name, Int8x16_3Int16, suffix); \
-    int32 lanes[16]; \
+    uint32 lanes[16]; \
     lanes[0] = GetRegRawInt(playout->I3);   lanes[1] = GetRegRawInt(playout->I4); \
     lanes[2] = GetRegRawInt(playout->I5);   lanes[3] = GetRegRawInt(playout->I6); \
     lanes[4] = GetRegRawInt(playout->I7);   lanes[5] = GetRegRawInt(playout->I8); \
@@ -1768,7 +1768,7 @@ if (switchProfileMode) \
     case OpCodeAsmJs::name: \
     { \
     PROCESS_READ_LAYOUT_ASMJS(name, Int16x8_2Int8, suffix); \
-    int32 lanes[8]; \
+    uint32 lanes[8]; \
     lanes[0] = GetRegRawInt(playout->I2); lanes[1] = GetRegRawInt(playout->I3); \
     lanes[2] = GetRegRawInt(playout->I4); lanes[3] = GetRegRawInt(playout->I5); \
     lanes[4] = GetRegRawInt(playout->I6); lanes[5] = GetRegRawInt(playout->I7); \
@@ -1783,7 +1783,7 @@ if (switchProfileMode) \
     case OpCodeAsmJs::name: \
     { \
     PROCESS_READ_LAYOUT_ASMJS(name, Int16x8_3Int8, suffix); \
-    int32 lanes[8]; \
+    uint32 lanes[8]; \
     lanes[0] = GetRegRawInt(playout->I3); lanes[1] = GetRegRawInt(playout->I4); \
     lanes[2] = GetRegRawInt(playout->I5); lanes[3] = GetRegRawInt(playout->I6); \
     lanes[4] = GetRegRawInt(playout->I7); lanes[5] = GetRegRawInt(playout->I8); \
@@ -1818,7 +1818,7 @@ if (switchProfileMode) \
     case OpCodeAsmJs::name: \
     { \
     PROCESS_READ_LAYOUT_ASMJS(name, Uint16x8_2Int8, suffix); \
-    int32 lanes[8]; \
+    uint32 lanes[8]; \
     lanes[0] = GetRegRawInt(playout->I2); lanes[1] = GetRegRawInt(playout->I3); \
     lanes[2] = GetRegRawInt(playout->I4); lanes[3] = GetRegRawInt(playout->I5); \
     lanes[4] = GetRegRawInt(playout->I6); lanes[5] = GetRegRawInt(playout->I7); \
@@ -1833,7 +1833,7 @@ if (switchProfileMode) \
     case OpCodeAsmJs::name: \
     { \
     PROCESS_READ_LAYOUT_ASMJS(name, Uint16x8_3Int8, suffix); \
-    int32 lanes[8]; \
+    uint32 lanes[8]; \
     lanes[0] = GetRegRawInt(playout->I3); lanes[1] = GetRegRawInt(playout->I4); \
     lanes[2] = GetRegRawInt(playout->I5); lanes[3] = GetRegRawInt(playout->I6); \
     lanes[4] = GetRegRawInt(playout->I7); lanes[5] = GetRegRawInt(playout->I8); \
@@ -1848,7 +1848,7 @@ if (switchProfileMode) \
     case OpCodeAsmJs::name: \
     { \
     PROCESS_READ_LAYOUT_ASMJS(name, Uint8x16_2Int16, suffix); \
-    int32 lanes[16]; \
+    uint32 lanes[16]; \
     lanes[0] = GetRegRawInt(playout->I2);   lanes[1] = GetRegRawInt(playout->I3); \
     lanes[2] = GetRegRawInt(playout->I4);   lanes[3] = GetRegRawInt(playout->I5); \
     lanes[4] = GetRegRawInt(playout->I6);   lanes[5] = GetRegRawInt(playout->I7); \
@@ -1867,7 +1867,7 @@ if (switchProfileMode) \
     case OpCodeAsmJs::name: \
     { \
     PROCESS_READ_LAYOUT_ASMJS(name, Uint8x16_3Int16, suffix); \
-    int32 lanes[16]; \
+    uint32 lanes[16]; \
     lanes[0] = GetRegRawInt(playout->I3);   lanes[1] = GetRegRawInt(playout->I4); \
     lanes[2] = GetRegRawInt(playout->I5);   lanes[3] = GetRegRawInt(playout->I6); \
     lanes[4] = GetRegRawInt(playout->I7);   lanes[5] = GetRegRawInt(playout->I8); \

lib/Runtime/Language/InterpreterStackFrame.cpp

@@ -7481,7 +7481,7 @@ const byte * InterpreterStackFrame::OP_ProfiledLoopBodyStart(const byte * ip)
         AsmJsSIMDValue *data = (AsmJsSIMDValue*)(buffer + index);
         AsmJsSIMDValue value;
 
-        value = SIMDLdData(data, dataWidth);
+        value = SIMDUtils::SIMDLdData(data, dataWidth);
         SetRegRawSimd(dstReg, value);
     }
 
@@ -7502,7 +7502,7 @@ const byte * InterpreterStackFrame::OP_ProfiledLoopBodyStart(const byte * ip)
         AsmJsSIMDValue *data = (AsmJsSIMDValue*)(buffer + index);
         AsmJsSIMDValue value;
 
-        value = SIMDLdData(data, dataWidth);
+        value = SIMDUtils::SIMDLdData(data, dataWidth);
         SetRegRawSimd(dstReg, value);
     }
 
@@ -7522,7 +7522,7 @@ const byte * InterpreterStackFrame::OP_ProfiledLoopBodyStart(const byte * ip)
         }
         AsmJsSIMDValue *data = (AsmJsSIMDValue*)(buffer + index);
         AsmJsSIMDValue value = GetRegRawSimd(srcReg);
-        SIMDStData(data, value, dataWidth);
+        SIMDUtils::SIMDStData(data, value, dataWidth);
     }
 
     template <class T>
@@ -7541,7 +7541,7 @@ const byte * InterpreterStackFrame::OP_ProfiledLoopBodyStart(const byte * ip)
         }
         AsmJsSIMDValue *data = (AsmJsSIMDValue*)(buffer + index);
         AsmJsSIMDValue value = GetRegRawSimd(srcReg);
-        SIMDStData(data, value, dataWidth);
+        SIMDUtils::SIMDStData(data, value, dataWidth);
 
     }
 

lib/Runtime/Language/JavascriptConversion.cpp

@@ -279,7 +279,7 @@ CommonNumber:
 
             default:
             {
-                if (IsSimdType(aValue))
+                if (SIMDUtils::IsSimdType(aValue))
                 {
                     *object = scriptContext->GetLibrary()->CreateSIMDObject(aValue, JavascriptOperators::GetTypeId(aValue));
                 }
@@ -428,7 +428,7 @@ CommonNumber:
             return JavascriptUInt64Number::FromVar(aValue)->ToJavascriptNumber();
 
         default:
-            if (IsSimdType(aValue))
+            if (SIMDUtils::IsSimdType(aValue))
             {
                 return aValue;
             }

lib/Runtime/Language/JavascriptOperators.cpp

@@ -276,7 +276,7 @@ namespace Js
 
     Var JavascriptOperators::Typeof(Var var, ScriptContext* scriptContext)
     {
-        if (IsSimdType(var) && scriptContext->GetConfig()->IsSimdjsEnabled())
+        if (SIMDUtils::IsSimdType(var) && scriptContext->GetConfig()->IsSimdjsEnabled())
         {
             switch ((JavascriptOperators::GetTypeId(var)))
             {
@@ -574,7 +574,7 @@ namespace Js
                 return result;
             }
         }
-        else if (IsSimdType(aLeft) && IsSimdType(aRight))
+        else if (SIMDUtils::IsSimdType(aLeft) && SIMDUtils::IsSimdType(aRight))
         {
             return StrictEqualSIMD(aLeft, aRight, requestContext);
         }
@@ -625,7 +625,7 @@ namespace Js
 
         double dblLeft, dblRight;
 
-        if (IsSimdType(aLeft) || IsSimdType(aRight))
+        if (SIMDUtils::IsSimdType(aLeft) || SIMDUtils::IsSimdType(aRight))
         {
             JavascriptError::ThrowTypeError(scriptContext, JSERR_SIMDConversion, _u("SIMD type"));
         }

lib/Runtime/Language/SimdInt16x8Operation.cpp

@@ -300,7 +300,7 @@ namespace Js
     {
         SIMDValue result;
 
-        count = count & SIMDGetShiftAmountMask(2);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(2);
 
         result.i16[0] = value.i16[0] << count;
         result.i16[1] = value.i16[1] << count;
@@ -318,7 +318,7 @@ namespace Js
     {
         SIMDValue result;
 
-        count = count & SIMDGetShiftAmountMask(2);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(2);
 
         result.i16[0] = value.i16[0] >> count;
         result.i16[1] = value.i16[1] >> count;

lib/Runtime/Language/SimdInt16x8OperationX86X64.cpp

@@ -239,7 +239,7 @@ namespace Js
         X86SIMDValue x86Result;
         X86SIMDValue tmpValue = X86SIMDValue::ToX86SIMDValue(value);
         // Shifts the 8 signed 16-bit integers in a left by count bits while shifting in zeros
-        x86Result.m128i_value = _mm_slli_epi16(tmpValue.m128i_value, count & SIMDGetShiftAmountMask(2));
+        x86Result.m128i_value = _mm_slli_epi16(tmpValue.m128i_value, count & SIMDUtils::SIMDGetShiftAmountMask(2));
 
         return X86SIMDValue::ToSIMDValue(x86Result);
     }
@@ -249,7 +249,7 @@ namespace Js
         X86SIMDValue x86Result;
         X86SIMDValue tmpValue = X86SIMDValue::ToX86SIMDValue(value);
         // Shifts the 8 signed 16-bit integers right by count bits while shifting in the sign bit
-        x86Result.m128i_value = _mm_srai_epi16(tmpValue.m128i_value, count &  SIMDGetShiftAmountMask(2));
+        x86Result.m128i_value = _mm_srai_epi16(tmpValue.m128i_value, count &  SIMDUtils::SIMDGetShiftAmountMask(2));
 
         return X86SIMDValue::ToSIMDValue(x86Result);
     }

lib/Runtime/Language/SimdInt32x4Operation.cpp

@@ -302,7 +302,7 @@ namespace Js
     {
         SIMDValue result;
 
-        count = count & SIMDGetShiftAmountMask(4);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(4);
 
         result.i32[SIMD_X] = value.i32[SIMD_X] << count;
         result.i32[SIMD_Y] = value.i32[SIMD_Y] << count;
@@ -316,7 +316,7 @@ namespace Js
     {
         SIMDValue result;
 
-        count = count & SIMDGetShiftAmountMask(4);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(4);
 
         result.i32[SIMD_X] = value.i32[SIMD_X] >> count;
         result.i32[SIMD_Y] = value.i32[SIMD_Y] >> count;

lib/Runtime/Language/SimdInt32x4OperationX86X64.cpp

@@ -296,7 +296,7 @@ namespace Js
         X86SIMDValue x86Result;
         X86SIMDValue tmpValue = X86SIMDValue::ToX86SIMDValue(value);
         // Shifts the 4 signed 32-bit integers in a left by count bits while shifting in zeros
-        x86Result.m128i_value = _mm_slli_epi32(tmpValue.m128i_value, count &  SIMDGetShiftAmountMask(4));
+        x86Result.m128i_value = _mm_slli_epi32(tmpValue.m128i_value, count & SIMDUtils::SIMDGetShiftAmountMask(4));
 
         return X86SIMDValue::ToSIMDValue(x86Result);
     }
@@ -306,7 +306,7 @@ namespace Js
         X86SIMDValue x86Result;
         X86SIMDValue tmpValue = X86SIMDValue::ToX86SIMDValue(value);
         // Shifts the 4 signed 32-bit integers right by count bits while shifting in the sign bit
-        x86Result.m128i_value = _mm_srai_epi32(tmpValue.m128i_value, count &  SIMDGetShiftAmountMask(4));
+        x86Result.m128i_value = _mm_srai_epi32(tmpValue.m128i_value, count & SIMDUtils::SIMDGetShiftAmountMask(4));
 
         return X86SIMDValue::ToSIMDValue(x86Result);
     }

lib/Runtime/Language/SimdInt8x16Operation.cpp

@@ -236,7 +236,7 @@ namespace Js
     {
         SIMDValue result;
 
-        count = count & SIMDGetShiftAmountMask(1);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(1);
 
         for(uint idx = 0; idx < 16; ++idx)
         {
@@ -250,7 +250,7 @@ namespace Js
     {
         SIMDValue result;
 
-        count = count & SIMDGetShiftAmountMask(1);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(1);
 
         for(uint idx = 0; idx < 16; ++idx)
         {

lib/Runtime/Language/SimdInt8x16OperationX86X64.cpp

@@ -228,7 +228,7 @@ namespace Js
         X86SIMDValue tmpaValue = X86SIMDValue::ToX86SIMDValue(value);
         X86SIMDValue x86tmp1;
 
-        count = count &  SIMDGetShiftAmountMask(1);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(1);
 
         x86tmp1.m128i_value = _mm_and_si128(tmpaValue.m128i_value, X86_HIGHBYTES_MASK.m128i_value);
         x86tmp1.m128i_value = _mm_slli_epi16(x86tmp1.m128i_value, count);
@@ -247,7 +247,7 @@ namespace Js
         X86SIMDValue tmpaValue = X86SIMDValue::ToX86SIMDValue(value);
         X86SIMDValue x86tmp1;
 
-        count = count &  SIMDGetShiftAmountMask(1);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(1);
 
         x86tmp1.m128i_value = _mm_slli_epi16(tmpaValue.m128i_value, 8);
         x86tmp1.m128i_value = _mm_srai_epi16(x86tmp1.m128i_value, count + 8);

lib/Runtime/Language/SimdUint16x8Operation.cpp

@@ -86,7 +86,7 @@ namespace Js
     {
         SIMDValue result;
 
-        count = count & SIMDGetShiftAmountMask(2);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(2);
 
         for (uint idx = 0; idx < 8; ++idx)
         {

lib/Runtime/Language/SimdUint16x8OperationX86X64.cpp

@@ -110,7 +110,7 @@ namespace Js
         X86SIMDValue x86Result = { { 0, 0, 0, 0 } };
         X86SIMDValue tmpaValue = X86SIMDValue::ToX86SIMDValue(value);
 
-        x86Result.m128i_value = _mm_srli_epi16(tmpaValue.m128i_value, count &  SIMDGetShiftAmountMask(2));
+        x86Result.m128i_value = _mm_srli_epi16(tmpaValue.m128i_value, count &  SIMDUtils::SIMDGetShiftAmountMask(2));
 
         return X86SIMDValue::ToSIMDValue(x86Result);
     }

lib/Runtime/Language/SimdUint32x4Operation.cpp

@@ -34,7 +34,7 @@ namespace Js
     {
         SIMDValue result;
 
-        count = count & SIMDGetShiftAmountMask(4);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(4);
 
         result.u32[SIMD_X] = (value.u32[SIMD_X] >> count);
         result.u32[SIMD_Y] = (value.u32[SIMD_Y] >> count);

lib/Runtime/Language/SimdUint32x4OperationX86X64.cpp

@@ -30,7 +30,7 @@ namespace Js
         X86SIMDValue x86Result;
         X86SIMDValue tmpValue = X86SIMDValue::ToX86SIMDValue(value);
         // Shifts the 4 signed 32-bit integers right by count bits while shifting in zeros
-        x86Result.m128i_value = _mm_srli_epi32(tmpValue.m128i_value, count &  SIMDGetShiftAmountMask(4));
+        x86Result.m128i_value = _mm_srli_epi32(tmpValue.m128i_value, count & SIMDUtils::SIMDGetShiftAmountMask(4));
 
         return X86SIMDValue::ToSIMDValue(x86Result);
     }

lib/Runtime/Language/SimdUint8x16Operation.cpp

@@ -85,7 +85,7 @@ namespace Js
     {
         SIMDValue result;
 
-        count = count & SIMDGetShiftAmountMask(1);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(1);
 
         for (uint idx = 0; idx < 16; ++idx)
         {

lib/Runtime/Language/SimdUint8x16OperationX86X64.cpp

@@ -106,7 +106,7 @@ namespace Js
         X86SIMDValue tmpaValue = X86SIMDValue::ToX86SIMDValue(value);
         __m128i x86tmp1;
 
-        count = count &  SIMDGetShiftAmountMask(1);
+        count = count & SIMDUtils::SIMDGetShiftAmountMask(1);
 
        __m128i mask = _mm_set1_epi8((unsigned char)0xff >> count);
         x86tmp1 = _mm_srli_epi16(tmpaValue.m128i_value, count);

lib/Runtime/Language/SimdUtils.cpp

@@ -7,38 +7,60 @@
 
 namespace Js
 {
-    bool IsSimdType(Var aVar)
+    bool SIMDUtils::IsSimdType(const Var aVar) //Needs SIMD Type Id's to be contiguous. 
     {
-        TypeId tid = JavascriptOperators::GetTypeId(aVar); //Depends on contiguous SIMD TypeIds
+        Assert(aVar);
+        TypeId tid = JavascriptOperators::GetTypeId(aVar);
         return (TypeIds_SIMDFloat32x4 <= tid && tid <= TypeIds_SIMDBool8x16) ? true : false;
     }
+    uint32 SIMDUtils::GetSIMDLaneCount(const Var aVar)
+    {
+        Assert(IsSimdType(aVar));
+        TypeId tid = JavascriptOperators::GetTypeId(aVar);
+        switch(tid)
+        {
+        case TypeIds_SIMDFloat32x4:
+        case TypeIds_SIMDInt32x4:
+        case TypeIds_SIMDUint32x4:
+        case TypeIds_SIMDBool32x4:
+            return 4;
+        case TypeIds_SIMDInt16x8:
+        case TypeIds_SIMDUint16x8:
+        case TypeIds_SIMDBool16x8:
+            return 8;
+        case TypeIds_SIMDInt8x16:
+        case TypeIds_SIMDUint8x16:
+        case TypeIds_SIMDBool8x16:
+            return 16;
+        default:
+            Assert(UNREACHED);
+        }
+        return 0;
+    }
 
-    int32 SIMDCheckTypedArrayIndex(ScriptContext* scriptContext, Var index)
+    uint32 SIMDUtils::SIMDCheckTypedArrayIndex(ScriptContext* scriptContext, const Var index)
     {
-        int32 int32Value;
+        uint32 uint32Value;
         Assert(index != NULL);
 
-        int32Value = SIMDCheckInt32Number(scriptContext, index);
-        return int32Value;
+        uint32Value = SIMDCheckUint32Number(scriptContext, index);
+        return uint32Value;
     }
 
-    int32 SIMDCheckLaneIndex(ScriptContext* scriptContext, Var lane, const int32 range)
+    uint32 SIMDUtils::SIMDCheckLaneIndex(ScriptContext* scriptContext, const Var lane, const uint32 range)
     {
-        int32 int32Value;
         Assert(lane != NULL);
+        uint32 uint32Value = SIMDCheckUint32Number(scriptContext, lane);
 
-        int32Value = SIMDCheckInt32Number(scriptContext, lane);
-
-        if (int32Value < 0 || int32Value >= range)
+        if (uint32Value >= range)
         {
             JavascriptError::ThrowRangeError(scriptContext, JSERR_SimdLaneRangeError);
         }
-
-        return int32Value;
+        return uint32Value;
     }
 
-    // Is Number with int32 value.
-    int32 SIMDCheckInt32Number(ScriptContext* scriptContext, Var value)
+    // Is Number with uint32 value.
+    uint32 SIMDUtils::SIMDCheckUint32Number(ScriptContext* scriptContext, const Var value)
     {
         int32 int32Value;
 
@@ -62,7 +84,7 @@ namespace Js
 
 
 #if _M_IX86 || _M_AMD64
-    SIMDValue FromSimdBits(SIMDValue value)
+    SIMDValue SIMDUtils::FromSimdBits(const SIMDValue value)
     {
         X86SIMDValue x86Result;
         X86SIMDValue v = X86SIMDValue::ToX86SIMDValue(value);
@@ -72,7 +94,7 @@ namespace Js
         return X86SIMDValue::ToSIMDValue(x86Result);
     }
 #else
-    SIMDValue FromSimdBits(SIMDValue value)
+    SIMDValue SIMDUtils::FromSimdBits(const SIMDValue value)
     {
         SIMDValue result;
         result.i32[SIMD_X] = value.i32[SIMD_X];
@@ -85,8 +107,8 @@ namespace Js
 
 
 
-    template <int laneCount>
-    SIMDValue SIMD128InnerShuffle(SIMDValue src1, SIMDValue src2, int32 lane0, int32 lane1, int32 lane2, int32 lane3)
+    template <uint32 laneCount>
+    SIMDValue SIMDUtils::SIMD128InnerShuffle(const SIMDValue src1, const SIMDValue src2, uint32 lane0, uint32 lane1, uint32 lane2, uint32 lane3)
     {
         SIMDValue result;
         CompileAssert(laneCount == 4 || laneCount == 2);
@@ -105,8 +127,8 @@ namespace Js
         return result;
     }
 
-    template <int laneCount>
-    SIMDValue SIMD128InnerShuffle(SIMDValue src1, SIMDValue src2, const int32* lanes)
+    template <uint32 laneCount>
+    SIMDValue SIMDUtils::SIMD128InnerShuffle(const SIMDValue src1, const SIMDValue src2, const uint32* lanes)
     {
         SIMDValue result = { 0 };
         CompileAssert(laneCount == 16 || laneCount == 8);
@@ -129,8 +151,8 @@ namespace Js
         return result;
     }
 
-    template <class SIMDType, int laneCount>
-    Var SIMD128SlowShuffle(Var src1, Var src2, Var* lanes, const uint range, ScriptContext* scriptContext)
+    template <class SIMDType, uint32 laneCount>
+    Var SIMDUtils::SIMD128SlowShuffle(Var src1, Var src2, Var* lanes, const uint32 range, ScriptContext* scriptContext)
     {
         SIMDType *a = SIMDType::FromVar(src1);
         SIMDType *b = SIMDType::FromVar(src2);
@@ -141,35 +163,35 @@ namespace Js
         SIMDValue src2Value = b->GetValue();
         SIMDValue result;
 
-        int32 laneValue[16] = { 0 };
+        uint32 laneValue[16] = { 0 };
         CompileAssert(laneCount == 16 || laneCount == 8);
 
         for (uint i = 0; i < laneCount; ++i)
         {
-            laneValue[i] = SIMDCheckLaneIndex(scriptContext, lanes[i], range);
+            laneValue[i] = SIMDUtils::SIMDCheckLaneIndex(scriptContext, lanes[i], range);
         }
 
         result = SIMD128InnerShuffle<laneCount>(src1Value, src2Value, laneValue);
 
         return SIMDType::New(&result, scriptContext);
     }
-    template Var SIMD128SlowShuffle<JavascriptSIMDInt8x16, 16>(Var src1, Var src2, Var *lanes, const uint range, ScriptContext* scriptContext);
-    template Var SIMD128SlowShuffle<JavascriptSIMDInt16x8, 8>(Var src1, Var src2, Var *lanes, const uint range, ScriptContext* scriptContext);
-    template Var SIMD128SlowShuffle<JavascriptSIMDUint8x16, 16>(Var src1, Var src2, Var *lanes, const uint range, ScriptContext* scriptContext);
-    template Var SIMD128SlowShuffle<JavascriptSIMDUint16x8, 8>(Var src1, Var src2, Var *lanes, const uint range, ScriptContext* scriptContext);
+    template Var SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDInt8x16, 16> (Var src1, Var src2, Var *lanes, const uint32 range, ScriptContext* scriptContext);
+    template Var SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDInt16x8, 8>  (Var src1, Var src2, Var *lanes, const uint32 range, ScriptContext* scriptContext);
+    template Var SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDUint8x16, 16>(Var src1, Var src2, Var *lanes, const uint32 range, ScriptContext* scriptContext);
+    template Var SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDUint16x8, 8> (Var src1, Var src2, Var *lanes, const uint32 range, ScriptContext* scriptContext);
 
-    template <class SIMDType, int laneCount>
-    Var SIMD128SlowShuffle(Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, int range, ScriptContext* scriptContext)
+    template <class SIMDType, uint32 laneCount>
+    Var SIMDUtils::SIMD128SlowShuffle(Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, uint32 range, ScriptContext* scriptContext)
     {
         SIMDType *a = SIMDType::FromVar(src1);
         SIMDType *b = SIMDType::FromVar(src2);
         Assert(a);
         Assert(b);
 
-        int32 lane0Value = 0;
-        int32 lane1Value = 0;
-        int32 lane2Value = 0;
-        int32 lane3Value = 0;
+        uint32 lane0Value = 0;
+        uint32 lane1Value = 0;
+        uint32 lane2Value = 0;
+        uint32 lane3Value = 0;
 
         SIMDValue src1Value = a->GetValue();
         SIMDValue src2Value = b->GetValue();
@@ -179,10 +201,10 @@ namespace Js
 
         if (laneCount == 4)
         {
-            lane0Value = SIMDCheckLaneIndex(scriptContext, lane0, range);
-            lane1Value = SIMDCheckLaneIndex(scriptContext, lane1, range);
-            lane2Value = SIMDCheckLaneIndex(scriptContext, lane2, range);
-            lane3Value = SIMDCheckLaneIndex(scriptContext, lane3, range);
+            lane0Value = SIMDUtils::SIMDCheckLaneIndex(scriptContext, lane0, range);
+            lane1Value = SIMDUtils::SIMDCheckLaneIndex(scriptContext, lane1, range);
+            lane2Value = SIMDUtils::SIMDCheckLaneIndex(scriptContext, lane2, range);
+            lane3Value = SIMDUtils::SIMDCheckLaneIndex(scriptContext, lane3, range);
 
             Assert(lane0Value >= 0 && lane0Value < range);
             Assert(lane1Value >= 0 && lane1Value < range);
@@ -193,8 +215,8 @@ namespace Js
         }
         else
         {
-            lane0Value = SIMDCheckLaneIndex(scriptContext, lane0, range);
-            lane1Value = SIMDCheckLaneIndex(scriptContext, lane1, range);
+            lane0Value = SIMDUtils::SIMDCheckLaneIndex(scriptContext, lane0, range);
+            lane1Value = SIMDUtils::SIMDCheckLaneIndex(scriptContext, lane1, range);
 
             Assert(lane0Value >= 0 && lane0Value < range);
             Assert(lane1Value >= 0 && lane1Value < range);
@@ -205,227 +227,12 @@ namespace Js
         return SIMDType::New(&result, scriptContext);
     }
 
-    template Var SIMD128SlowShuffle<JavascriptSIMDInt32x4  , 4> (Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, int range, ScriptContext* scriptContext);
-    template Var SIMD128SlowShuffle<JavascriptSIMDFloat32x4, 4> (Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, int range, ScriptContext* scriptContext);
-    template Var SIMD128SlowShuffle<JavascriptSIMDFloat64x2, 2> (Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, int range, ScriptContext* scriptContext);
-    template Var SIMD128SlowShuffle<JavascriptSIMDUint32x4 , 4> (Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, int range, ScriptContext* scriptContext);
-
-    //Int8x16 LaneAccess
-    inline int8 SIMD128InnerExtractLaneI16(const SIMDValue& src1, const int32 lane)
-    {
-        return src1.i8[lane];
-    }
-
-    inline SIMDValue SIMD128InnerReplaceLaneI16(const SIMDValue& src1, const int32 lane, const int8 value)
-    {
-        SIMDValue result = src1;
-        result.i8[lane] = value;
-        return result;
-    }
-
-    static inline int8 SIMD128GetLaneValue(JavascriptSIMDInt8x16 *jsVal, const int laneValue)
-    {
-        Assert(jsVal);
-        return SIMD128InnerExtractLaneI16(jsVal->GetValue(), laneValue);
-    }
-
-    static inline SIMDValue SIMD128SetLaneValue(JavascriptSIMDInt8x16 *jsVal, const int laneValue, int8 value)
-    {
-        Assert(jsVal);
-        return SIMD128InnerReplaceLaneI16(jsVal->GetValue(), laneValue, value);
-    }
-
-    //Int16x8 LaneAccess
-    inline int16 SIMD128InnerExtractLaneI8(const SIMDValue& src1, const int32 lane)
-    {
-        return src1.i16[lane];
-    }
-    inline SIMDValue SIMD128InnerReplaceLaneI8(const SIMDValue& src1, const int32 lane, const int16 value)
-    {
-        SIMDValue result = src1;
-        result.i16[lane] = value;
-        return result;
-    }
-    static inline int16 SIMD128GetLaneValue(JavascriptSIMDInt16x8 *jsVal, const int laneValue)
-    {
-        Assert(jsVal);
-        return SIMD128InnerExtractLaneI8(jsVal->GetValue(), laneValue);
-    }
-    static inline SIMDValue SIMD128SetLaneValue(JavascriptSIMDInt16x8 *jsVal, const int laneValue, int16 value)
-    {
-        Assert(jsVal);
-        return SIMD128InnerReplaceLaneI8(jsVal->GetValue(), laneValue, value);
-    }
-
-    //Int32x4 LaneAccess
-    inline int SIMD128InnerExtractLaneI4(const SIMDValue& src1, const int32 lane)
-    {
-        return src1.i32[lane];
-    }
-
-    inline SIMDValue SIMD128InnerReplaceLaneI4(const SIMDValue& src1, const int32 lane, const int value)
-    {
-        SIMDValue result = src1;
-        result.i32[lane] = value;
-        return result;
-    }
-
-    static inline int SIMD128GetLaneValue(JavascriptSIMDInt32x4 *jsVal, const int laneValue)
-    {
-        Assert(jsVal);
-        return SIMD128InnerExtractLaneI4(jsVal->GetValue(), laneValue);
-    }
-
-    static inline SIMDValue SIMD128SetLaneValue(JavascriptSIMDInt32x4 *jsVal, const int laneValue, int value)
-    {
-        Assert(jsVal);
-        return SIMD128InnerReplaceLaneI4(jsVal->GetValue(), laneValue, value);
-    }
-
-    //Float32x4 LaneAccess
-    inline float SIMD128InnerExtractLaneF4(const SIMDValue& src1, const int32 lane)
-    {
-        return src1.f32[lane];
-    }
-
-    inline SIMDValue SIMD128InnerReplaceLaneF4(const SIMDValue& src1, const int32 lane, const float value)
-    {
-        SIMDValue result = src1;
-        result.f32[lane] = value;
-        return result;
-    }
-
-    static inline float SIMD128GetLaneValue(JavascriptSIMDFloat32x4 *jsVal, const int laneValue)
-    {
-        Assert(jsVal);
-        return SIMD128InnerExtractLaneF4(jsVal->GetValue(), laneValue);
-    }
-
-    static inline SIMDValue SIMD128SetLaneValue(JavascriptSIMDFloat32x4 *jsVal, const int laneValue, float value)
-    {
-        Assert(jsVal);
-        return SIMD128InnerReplaceLaneF4(jsVal->GetValue(), laneValue, value);
-    }
-
-    //Bool32x4 LaneAccess
-    static inline bool SIMD128GetLaneValue(JavascriptSIMDBool32x4 *jsVal, const int laneValue)
-    {
-        Assert(jsVal);
-        return SIMD128InnerExtractLaneI4(jsVal->GetValue(), laneValue) == -1;
-    }
-    static inline SIMDValue SIMD128SetLaneValue(JavascriptSIMDBool32x4 *jsVal, const int laneValue, bool value)
-    {
-        Assert(jsVal);
-        return SIMD128InnerReplaceLaneI4(jsVal->GetValue(), laneValue, value ? -1 : 0);
-    }
-
-    //Bool16x8 LaneAccess
-    static inline bool SIMD128GetLaneValue(JavascriptSIMDBool16x8 *jsVal, const int laneValue)
-    {
-        Assert(jsVal);
-        return SIMD128InnerExtractLaneI8(jsVal->GetValue(), laneValue) == -1;
-    }
-    static inline SIMDValue SIMD128SetLaneValue(JavascriptSIMDBool16x8 *jsVal, const int laneValue, bool value)
-    {
-        Assert(jsVal);
-        return SIMD128InnerReplaceLaneI8(jsVal->GetValue(), laneValue, value ? -1 : 0);
-    }
-
-    //Bool8x16 LaneAccess
-    static inline bool SIMD128GetLaneValue(JavascriptSIMDBool8x16 *jsVal, const int laneValue)
-    {
-        Assert(jsVal);
-        return SIMD128InnerExtractLaneI16(jsVal->GetValue(), laneValue) == -1;
-    }
-    static inline SIMDValue SIMD128SetLaneValue(JavascriptSIMDBool8x16 *jsVal, const int laneValue, bool value)
-    {
-        Assert(jsVal);
-        return SIMD128InnerReplaceLaneI16(jsVal->GetValue(), laneValue, value ? -1 : 0);
-    }
-
-    //Uint32x4 Lane Access
-    static inline uint SIMD128GetLaneValue(JavascriptSIMDUint32x4 *jsVal, const int laneValue)
-    {
-        Assert(jsVal);
-        return (uint) SIMD128InnerExtractLaneI4(jsVal->GetValue(), laneValue);
-    }
-    static inline SIMDValue SIMD128SetLaneValue(JavascriptSIMDUint32x4 *jsVal, const int laneValue, uint value)
-    {
-        Assert(jsVal);
-        return SIMD128InnerReplaceLaneI4(jsVal->GetValue(), laneValue, value);
-    }
-    //Uint8x16 LaneAccess
-    static inline uint8 SIMD128GetLaneValue(JavascriptSIMDUint8x16 *jsVal, const int laneValue)
-    {
-        Assert(jsVal);
-        return (uint8) SIMD128InnerExtractLaneI16(jsVal->GetValue(), laneValue);
-    }
-    static inline SIMDValue SIMD128SetLaneValue(JavascriptSIMDUint8x16 *jsVal, const int laneValue, uint8 value)
-    {
-        Assert(jsVal);
-        return SIMD128InnerReplaceLaneI16(jsVal->GetValue(), laneValue, value);
-    }
-
-    //Uint16x8 LaneAccess
-    static inline uint16 SIMD128GetLaneValue(JavascriptSIMDUint16x8 *jsVal, const int laneValue)
-    {
-        Assert(jsVal);
-        return (uint16) SIMD128InnerExtractLaneI8(jsVal->GetValue(), laneValue);
-    }
-    static inline SIMDValue SIMD128SetLaneValue(JavascriptSIMDUint16x8 *jsVal, const int laneValue, uint16 value)
-    {
-        Assert(jsVal);
-        return SIMD128InnerReplaceLaneI8(jsVal->GetValue(), laneValue, value);
-    }
-
+    template Var SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDInt32x4  , 4> (Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, uint32 range, ScriptContext* scriptContext);
+    template Var SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDFloat32x4, 4> (Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, uint32 range, ScriptContext* scriptContext);
+    template Var SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDFloat64x2, 2> (Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, uint32 range, ScriptContext* scriptContext);
+    template Var SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDUint32x4 , 4> (Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, uint32 range, ScriptContext* scriptContext);
 
-    template<class SIMDType, int laneCount, typename T>
-    inline T SIMD128ExtractLane(const Var src, const Var lane, ScriptContext* scriptContext)
-    {
-        SIMDType *jsVal = SIMDType::FromVar(src);
-        Assert(jsVal);
-
-        int32 laneValue = SIMDCheckLaneIndex(scriptContext, lane, laneCount);
-        Assert(laneValue >= 0 && laneValue < laneCount);
-
-        return SIMD128GetLaneValue(jsVal, laneValue);
-    }
-
-    template<class SIMDType, int laneCount, typename T>
-    inline SIMDValue SIMD128ReplaceLane(const Var src, const Var lane, const T value, ScriptContext* scriptContext)
-    {
-        SIMDType *jsVal = SIMDType::FromVar(src);
-        Assert(jsVal);
-
-        int32 laneValue = SIMDCheckLaneIndex(scriptContext, lane, laneCount);
-        Assert(laneValue >= 0 && laneValue < laneCount);
-
-        return SIMD128SetLaneValue(jsVal, laneValue, value);
-    }
-
-    template int8  SIMD128ExtractLane<JavascriptSIMDInt8x16, 16, int8>(Var src, Var lane, ScriptContext* scriptContext);
-    template SIMDValue SIMD128ReplaceLane<JavascriptSIMDInt8x16, 16, int8>(Var src, Var lane, int8 value, ScriptContext* scriptContext);
-    template int16  SIMD128ExtractLane<JavascriptSIMDInt16x8, 8, int16>(Var src, Var lane, ScriptContext* scriptContext);
-    template SIMDValue SIMD128ReplaceLane<JavascriptSIMDInt16x8, 8, int16>(Var src, Var lane, int16 value, ScriptContext* scriptContext);
-
-    template int   SIMD128ExtractLane<JavascriptSIMDInt32x4, 4, int>(Var src, Var lane, ScriptContext* scriptContext);
-    template SIMDValue SIMD128ReplaceLane<JavascriptSIMDInt32x4, 4, int>(Var src, Var lane, int value, ScriptContext* scriptContext);
-    template float SIMD128ExtractLane<JavascriptSIMDFloat32x4, 4, float>(Var src, Var lane, ScriptContext* scriptContext);
-    template SIMDValue SIMD128ReplaceLane<JavascriptSIMDFloat32x4, 4, float>(Var src, Var lane, float value, ScriptContext* scriptContext);
-    template bool SIMD128ExtractLane<JavascriptSIMDBool32x4, 4, bool>(Var src, Var lane, ScriptContext* scriptContext);
-    template SIMDValue SIMD128ReplaceLane<JavascriptSIMDBool32x4, 4, bool>(Var src, Var lane, bool value, ScriptContext* scriptContext);
-    template bool SIMD128ExtractLane<JavascriptSIMDBool16x8, 8, bool>(Var src, Var lane, ScriptContext* scriptContext);
-    template SIMDValue SIMD128ReplaceLane<JavascriptSIMDBool16x8, 8, bool>(Var src, Var lane, bool value, ScriptContext* scriptContext);
-    template bool SIMD128ExtractLane<JavascriptSIMDBool8x16, 16, bool>(Var src, Var lane, ScriptContext* scriptContext);
-    template SIMDValue SIMD128ReplaceLane<JavascriptSIMDBool8x16, 16, bool>(Var src, Var lane, bool value, ScriptContext* scriptContext);
-
-    template uint   SIMD128ExtractLane<JavascriptSIMDUint32x4, 4, uint>(Var src, Var lane, ScriptContext* scriptContext);
-    template SIMDValue SIMD128ReplaceLane<JavascriptSIMDUint32x4, 4, uint>(Var src, Var lane, uint value, ScriptContext* scriptContext);
-    template uint8  SIMD128ExtractLane<JavascriptSIMDUint8x16, 16, uint8>(Var src, Var lane, ScriptContext* scriptContext);
-    template SIMDValue SIMD128ReplaceLane<JavascriptSIMDUint8x16, 16, uint8>(Var src, Var lane, uint8 value, ScriptContext* scriptContext);
-    template uint16  SIMD128ExtractLane<JavascriptSIMDUint16x8, 8, uint16>(Var src, Var lane, ScriptContext* scriptContext);
-    template SIMDValue SIMD128ReplaceLane<JavascriptSIMDUint16x8, 8, uint16>(Var src, Var lane, uint16 value, ScriptContext* scriptContext);
-    bool SIMDIsSupportedTypedArray(Var value)
+    bool SIMDUtils::SIMDIsSupportedTypedArray(Var value)
     {
         return JavascriptOperators::GetTypeId(value) >= TypeIds_Int8Array && JavascriptOperators::GetTypeId(value) <= TypeIds_Float64Array;
     }
@@ -437,14 +244,14 @@ namespace Js
     3. Lane index is within array bounds
     */
 
-    SIMDValue* SIMDCheckTypedArrayAccess(Var arg1, Var arg2, TypedArrayBase **tarray, int32 *index, uint32 dataWidth, ScriptContext *scriptContext)
+    SIMDValue* SIMDUtils::SIMDCheckTypedArrayAccess(Var arg1, Var arg2, TypedArrayBase **tarray, int32 *index, uint32 dataWidth, ScriptContext *scriptContext)
     {
         if (!SIMDIsSupportedTypedArray(arg1))
         {
             JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("Simd typed array access"));
         }
 
-        *index = SIMDCheckInt32Number(scriptContext, arg2);
+        *index = SIMDCheckUint32Number(scriptContext, arg2);
 
         // bound check
         *tarray = TypedArrayBase::FromVar(arg1);
@@ -457,7 +264,7 @@ namespace Js
         return (SIMDValue*)((*tarray)->GetByteBuffer() + offset);
     }
 
-    SIMDValue SIMDLdData(SIMDValue *data, uint8 dataWidth)
+    SIMDValue SIMDUtils::SIMDLdData(const SIMDValue *data, uint8 dataWidth)
     {
         SIMDValue result = { 0, 0, 0, 0 };
         // bitwise copy. Always use integer fields to avoid wrong copy of NaNs.
@@ -481,7 +288,7 @@ namespace Js
         return result;
     }
 
-    void SIMDStData(SIMDValue *data, SIMDValue simdValue, uint8 dataWidth)
+    void SIMDUtils::SIMDStData(SIMDValue *data, const SIMDValue simdValue, uint8 dataWidth)
     {
         // bitwise copy. Always use integer fields to avoid wrong copy of NaNs.
         switch (dataWidth)
@@ -503,12 +310,9 @@ namespace Js
         }
     }
 
-
-
-
 #if ENABLE_NATIVE_CODEGEN
     // Maps Simd opcodes which are non-contiguous to a zero-based linear space. Used to index a table using a Simd opcode.
-    uint32 SimdOpcodeAsIndex(Js::OpCode op)
+    uint32 SIMDUtils::SimdOpcodeAsIndex(Js::OpCode op)
     {
         if (op <= Js::OpCode::Simd128_End)
         {

lib/Runtime/Language/SimdUtils.h

@@ -158,101 +158,176 @@ CompileAssert(sizeof(SIMDValue) == 16);
 class ValueType;
 
 namespace Js {
-
-    bool IsSimdType(Var aVar);
-    uint32 inline SIMDGetShiftAmountMask(uint32 eleSizeInBytes){ return (eleSizeInBytes << 3) - 1; }
-    int32 SIMDCheckTypedArrayIndex(ScriptContext* scriptContext, Var index);
-    int32 SIMDCheckLaneIndex(ScriptContext* scriptContext, Var lane, const int32 range = 4);
-
-    template <int laneCount = 4>
-    SIMDValue SIMD128InnerShuffle(SIMDValue src1, SIMDValue src2, int32 lane0, int32 lane1, int32 lane2, int32 lane3);
-    template <int laneCount = 8>
-    SIMDValue SIMD128InnerShuffle(SIMDValue src1, SIMDValue src2, const int32* lanes = nullptr);
-
-    template <class SIMDType, int laneCount = 4>
-    Var SIMD128SlowShuffle(Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, int range, ScriptContext* scriptContext);
-    template <class SIMDType, int laneCount = 8>
-    Var SIMD128SlowShuffle(Var src1, Var src2, Var *lanes, const uint range, ScriptContext* scriptContext);
-
-    //TypeConvert
-    template<class SIMDType1, class SIMDType2>
-    Var SIMDConvertTypeFromBits(SIMDType1 &instance, ScriptContext& requestContext);
-
-    //Lane Access
-    template<class SIMDType, int laneCount, typename T>
-    inline T SIMD128ExtractLane(Var src, Var lane, ScriptContext* scriptContext);
-    template<class SIMDType, int laneCount, typename T>
-    inline SIMDValue SIMD128ReplaceLane(Var src, Var lane, T value, ScriptContext* scriptContext);
-
-    SIMDValue SIMD128InnerReplaceLaneF4(const SIMDValue& src1, const int32 lane, const float value);
-    float SIMD128InnerExtractLaneF4(const SIMDValue& src1, const int32 lane);
-
-    SIMDValue SIMD128InnerReplaceLaneI4(const SIMDValue& src1, const int32 lane, const int value);
-    int SIMD128InnerExtractLaneI4(const SIMDValue& src1, const int32 lane);
-
-    SIMDValue SIMD128InnerReplaceLaneI8(const SIMDValue& src1, const int32 lane, const int16 value);
-    int16 SIMD128InnerExtractLaneI8(const SIMDValue& src1, const int32 lane);
-
-    SIMDValue SIMD128InnerReplaceLaneI16(const SIMDValue& src1, const int32 lane, const int8 value);
-    int8 SIMD128InnerExtractLaneI16(const SIMDValue& src1, const int32 lane);
-
-    int32 SIMDCheckInt32Number(ScriptContext* scriptContext, Var value);
-    bool        SIMDIsSupportedTypedArray(Var value);
-    SIMDValue*  SIMDCheckTypedArrayAccess(Var arg1, Var arg2, TypedArrayBase **tarray, int32 *index, uint32 dataWidth, ScriptContext *scriptContext);
-    SIMDValue SIMDLdData(SIMDValue *data, uint8 dataWidth);
-    void SIMDStData(SIMDValue *data, SIMDValue simdValue, uint8 dataWidth);
-
-    template <class SIMDType>
-    Var SIMD128TypedArrayLoad(Var arg1, Var arg2, uint32 dataWidth, ScriptContext *scriptContext)
-    {
-        Assert(dataWidth >= 4 && dataWidth <= 16);
-
-        TypedArrayBase *tarray = NULL;
-        int32 index = -1;
-        SIMDValue* data = NULL;
-
-        data = SIMDCheckTypedArrayAccess(arg1, arg2, &tarray, &index, dataWidth, scriptContext);
-
-        Assert(tarray != NULL);
-        Assert(index >= 0);
-        Assert(data != NULL);
-
-        SIMDValue result = SIMDLdData(data, (uint8)dataWidth);
-
-        return SIMDType::New(&result, scriptContext);
-
-    }
-
-    template <class SIMDType>
-    void SIMD128TypedArrayStore(Var arg1, Var arg2, Var simdVar, uint32 dataWidth, ScriptContext *scriptContext)
-    {
-        Assert(dataWidth >= 4 && dataWidth <= 16);
-
-        TypedArrayBase *tarray = NULL;
-        int32 index = -1;
-        SIMDValue* data = NULL;
-
-        data = SIMDCheckTypedArrayAccess(arg1, arg2, &tarray, &index, dataWidth, scriptContext);
-
-        Assert(tarray != NULL);
-        Assert(index >= 0);
-        Assert(data != NULL);
-
-        SIMDValue simdValue = SIMDType::FromVar(simdVar)->GetValue();
-        SIMDStData(data, simdValue, (uint8)dataWidth);
-    }
-
-    //SIMD Type conversion
-    SIMDValue FromSimdBits(SIMDValue value);
-
-    template<class SIMDType1, class SIMDType2>
-    Var SIMDConvertTypeFromBits(SIMDType1* instance, ScriptContext* requestContext)
-    {
-        SIMDValue result = FromSimdBits(instance->GetValue());
-        return SIMDType2::New(&result, requestContext);
-    }
-
     enum class OpCode : ushort;
-    uint32 SimdOpcodeAsIndex(Js::OpCode op);
-
+    ///////////////////////////////////////////////////////////////
+    //Class with static helper methods for manipulating SIMD Data.
+    ///////////////////////////////////////////////////////////////
+    class SIMDUtils
+    {
+    private:
+        template<typename SIMDType, typename T>
+        static SIMDValue SIMD128SetLaneValue(const Var aVar, const uint32 laneValue, const T value)
+        {
+            Assert(IsSimdType(aVar));
+            SIMDType *jsVal = SIMDType::FromVar(aVar);
+            SIMDValue simdValue = jsVal->GetValue();
+
+            switch (GetSIMDLaneCount(aVar))
+            {
+            case 4:
+                return (JavascriptSIMDFloat32x4::Is(aVar)) ?
+                       SIMD128InnerReplaceLaneF4(simdValue, laneValue, static_cast<float>(value)):
+                       SIMD128InnerReplaceLaneI4(simdValue, laneValue, static_cast<int32>(value));
+            case 8:
+                return SIMD128InnerReplaceLaneI8(simdValue, laneValue, static_cast<int16>(value));
+            case 16:
+                return SIMD128InnerReplaceLaneI16(simdValue, laneValue, static_cast<int8>(value));
+            default:
+                Assert(UNREACHED);
+            }
+            return simdValue; //Unreached
+        };
+
+        template<typename SIMDType, uint32 laneCount, typename T>
+        static T SIMD128GetLaneValue(const Var aVar, const uint32 laneValue)
+        {
+            Assert(IsSimdType(aVar));
+            SIMDType *jsVal = SIMDType::FromVar(aVar);
+
+            switch (laneCount)
+            {
+            case 4:
+                return (JavascriptSIMDFloat32x4::Is(aVar)) ?
+                       static_cast<T>(SIMD128InnerExtractLaneF4(jsVal->GetValue(), laneValue)):
+                       static_cast<T>(SIMD128InnerExtractLaneI4(jsVal->GetValue(), laneValue));
+            case 8:
+                return static_cast<T>(SIMD128InnerExtractLaneI8(jsVal->GetValue(), laneValue));
+            case 16:
+                return static_cast<T>(SIMD128InnerExtractLaneI16(jsVal->GetValue(), laneValue));
+            default:
+                Assert(UNREACHED);
+            }
+            return 0; //unreached
+        };
+
+    public:
+        static bool IsSimdType(const Var aVar);
+        static uint32 GetSIMDLaneCount(const Var aVar);
+        static inline uint32 SIMDCheckTypedArrayIndex(ScriptContext* scriptContext, const Var index);
+        static uint32 SIMDCheckLaneIndex(ScriptContext* scriptContext, const Var lane, const uint32 range = 4);
+        static uint32 inline SIMDGetShiftAmountMask(uint32 eleSizeInBytes) { return (eleSizeInBytes << 3) - 1; }
+
+        ////////////////////////////////////////////
+        //SIMD Extract Lane / Replace Lane Helpers
+        ////////////////////////////////////////////
+        static inline SIMDValue SIMD128InnerReplaceLaneF4(SIMDValue simdVal, const uint32 lane, const float value)
+        {
+            simdVal.f32[lane] = value;
+            return simdVal;
+        };
+        static inline SIMDValue SIMD128InnerReplaceLaneI4(SIMDValue simdVal, const uint32 lane, const int32 value)
+        {
+            simdVal.i32[lane] = value;
+            return simdVal;
+        };
+        static inline SIMDValue SIMD128InnerReplaceLaneI8(SIMDValue simdVal, const uint32 lane, const int16 value)
+        {
+            simdVal.i16[lane] = value;
+            return simdVal;
+        };
+        static inline SIMDValue SIMD128InnerReplaceLaneI16(SIMDValue simdVal, const uint32 lane, const int8 value)
+        {
+            simdVal.i8[lane] = value;
+            return simdVal;
+        };
+
+        static inline float SIMD128InnerExtractLaneF4(const SIMDValue src1, const uint32 lane) { return src1.f32[lane]; };
+        static inline int32 SIMD128InnerExtractLaneI4(const SIMDValue src1, const uint32 lane) { return src1.i32[lane]; };
+        static inline int16 SIMD128InnerExtractLaneI8(const SIMDValue src1, const uint32 lane) { return src1.i16[lane]; };
+        static inline int8 SIMD128InnerExtractLaneI16(const SIMDValue src1, const uint32 lane) { return src1.i8[lane];  };
+
+        template<class SIMDType, uint32 laneCount, typename T>
+        static inline T SIMD128ExtractLane(const Var src, const Var lane, ScriptContext* scriptContext)
+        {
+            uint32 laneValue = SIMDUtils::SIMDCheckLaneIndex(scriptContext, lane, laneCount);
+            Assert(laneValue >= 0 && laneValue < laneCount);
+            return SIMD128GetLaneValue<SIMDType, laneCount, T>(src, laneValue);
+        }
+
+        template<class SIMDType, uint32 laneCount, typename T>
+        static inline SIMDValue SIMD128ReplaceLane(const Var src, const Var lane, const T value, ScriptContext* scriptContext)
+        {
+            uint32 laneValue = SIMDUtils::SIMDCheckLaneIndex(scriptContext, lane, laneCount);
+            Assert(laneValue >= 0 && laneValue < laneCount);
+            return SIMD128SetLaneValue<SIMDType, T>(src, laneValue, value);
+        }
+
+        ////////////////////////////////////////////
+        // SIMD Shuffle Swizzle helpers
+        ////////////////////////////////////////////
+        template <uint32 laneCount = 4>
+        static SIMDValue SIMD128InnerShuffle(const SIMDValue src1, const SIMDValue src2, uint32 lane0, uint32 lane1, uint32 lane2, uint32 lane3);
+        template <uint32 laneCount = 8>
+        static SIMDValue SIMD128InnerShuffle(const SIMDValue src1, const SIMDValue src2, const uint32* lanes = nullptr);
+
+        template <class SIMDType, uint32 laneCount = 4>
+        static Var SIMD128SlowShuffle(Var src1, Var src2, Var lane0, Var lane1, Var lane2, Var lane3, uint32 range, ScriptContext* scriptContext);
+        template <class SIMDType, uint32 laneCount = 8>
+        static Var SIMD128SlowShuffle(Var src1, Var src2, Var *lanes, const uint32 range, ScriptContext* scriptContext);
+
+        ///////////////////////////////////////////
+        // SIMD Type conversion
+        ///////////////////////////////////////////
+        template<class SIMDType1, class SIMDType2>
+        static inline Var SIMDConvertTypeFromBits(SIMDType1 &instance, ScriptContext& requestContext)
+        {
+            SIMDValue result = FromSimdBits(instance.GetValue());
+            return SIMDType2::New(&result, &requestContext);
+        }
+        static SIMDValue FromSimdBits(const SIMDValue value);
+
+        ///////////////////////////////////////////
+        // SIMD Data load/store
+        ///////////////////////////////////////////
+        static SIMDValue SIMDLdData(const SIMDValue *data, uint8 dataWidth);
+        static void SIMDStData(SIMDValue *data, const SIMDValue simdValue, uint8 dataWidth);
+        static uint32 SIMDCheckUint32Number(ScriptContext* scriptContext, const Var value);
+        static bool SIMDIsSupportedTypedArray(Var value);
+        static SIMDValue*  SIMDCheckTypedArrayAccess(Var arg1, Var arg2, TypedArrayBase **tarray, int32 *index, uint32 dataWidth, ScriptContext *scriptContext);
+
+        template <class SIMDType>
+        static Var SIMD128TypedArrayLoad(Var arg1, Var arg2, uint32 dataWidth, ScriptContext *scriptContext)
+        {
+            Assert(dataWidth >= 4 && dataWidth <= 16);
+            TypedArrayBase *tarray = NULL;
+            int32 index = -1;
+            SIMDValue* data = NULL;
+
+            data = SIMDUtils::SIMDCheckTypedArrayAccess(arg1, arg2, &tarray, &index, dataWidth, scriptContext);
+            Assert(tarray != NULL);
+            Assert(index >= 0);
+            Assert(data != NULL);
+
+            SIMDValue result = SIMDUtils::SIMDLdData(data, (uint8)dataWidth);
+            return SIMDType::New(&result, scriptContext);
+        }
+
+        template <class SIMDType>
+        static void SIMD128TypedArrayStore(Var arg1, Var arg2, Var simdVar, uint32 dataWidth, ScriptContext *scriptContext)
+        {
+            Assert(dataWidth >= 4 && dataWidth <= 16);
+            TypedArrayBase *tarray = NULL;
+            int32 index = -1;
+            SIMDValue* data = NULL;
+
+            data = SIMDUtils::SIMDCheckTypedArrayAccess(arg1, arg2, &tarray, &index, dataWidth, scriptContext);
+            Assert(tarray != NULL);
+            Assert(index >= 0);
+            Assert(data != NULL);
+
+            SIMDValue simdValue = SIMDType::FromVar(simdVar)->GetValue();
+            SIMDUtils::SIMDStData(data, simdValue, (uint8)dataWidth);
+        }
+        static uint32 SimdOpcodeAsIndex(Js::OpCode op);
+    };
 }

lib/Runtime/Library/JavascriptSimdObject.cpp

@@ -251,7 +251,7 @@ namespace Js
 
     Var JavascriptSIMDObject::GetValue() const
     {
-        Assert(IsSimdType(value));
+        Assert(SIMDUtils::IsSimdType(value));
         return value;
     }
 }

lib/Runtime/Library/SimdBool16x8Lib.cpp

@@ -83,7 +83,7 @@ namespace Js
         {
             // if value arg is missing, then it is undefined.
             Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
-            bool result = SIMD128ExtractLane<JavascriptSIMDBool16x8, 8, bool>(args[1], laneVar, scriptContext);
+            bool result = (SIMDUtils::SIMD128ExtractLane<JavascriptSIMDBool16x8, 8, int16>(args[1], laneVar, scriptContext)) ? true : false;
             return JavascriptBoolean::ToVar(result, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdBool8x16TypeMismatch, _u("ExtractLane"));
@@ -106,8 +106,8 @@ namespace Js
             Var laneVar = args.Info.Count >= 4 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
             Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
             bool value = JavascriptConversion::ToBool(argVal, scriptContext);
-
-            SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDBool16x8, 8, bool>(args[1], laneVar, value, scriptContext);
+            int16 intValue = (value) ? -1 : 0;
+            SIMDValue result = SIMDUtils::SIMD128ReplaceLane<JavascriptSIMDBool16x8, 8, int16>(args[1], laneVar, intValue, scriptContext);
 
             return JavascriptSIMDBool16x8::New(&result, scriptContext);
         }

lib/Runtime/Library/SimdBool32x4Lib.cpp

@@ -77,7 +77,7 @@ namespace Js
         {
             // if value arg is missing, then it is undefined.
             Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
-            bool result = SIMD128ExtractLane<JavascriptSIMDBool32x4, 4, bool>(args[1], laneVar, scriptContext);
+            bool result = (SIMDUtils::SIMD128ExtractLane<JavascriptSIMDBool32x4, 4, int32>(args[1], laneVar, scriptContext)) ? true : false;
             return JavascriptBoolean::ToVar(result, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdBool32x4TypeMismatch, _u("ExtractLane"));
@@ -99,8 +99,8 @@ namespace Js
             Var laneVar = args.Info.Count >= 4 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
             Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
             bool value = JavascriptConversion::ToBool(argVal, scriptContext);
-
-            SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDBool32x4, 4, bool>(args[1], laneVar, value, scriptContext);
+            int32 intValue = (value) ? -1 : 0;
+            SIMDValue result = SIMDUtils::SIMD128ReplaceLane<JavascriptSIMDBool32x4, 4, int32>(args[1], laneVar, intValue, scriptContext);
 
             return JavascriptSIMDBool32x4::New(&result, scriptContext);
         }

lib/Runtime/Library/SimdBool8x16Lib.cpp

@@ -83,7 +83,7 @@ namespace Js
         {
             // if value arg is missing, then it is undefined.
             Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
-            bool result = SIMD128ExtractLane<JavascriptSIMDBool8x16, 16, bool>(args[1], laneVar, scriptContext);
+            bool result = (SIMDUtils::SIMD128ExtractLane<JavascriptSIMDBool8x16, 16, int8>(args[1], laneVar, scriptContext)) ? true : false;
             return JavascriptBoolean::ToVar(result, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdBool8x16TypeMismatch, _u("ExtractLane"));
@@ -106,8 +106,8 @@ namespace Js
             Var laneVar = args.Info.Count >= 4 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
             Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
             bool value = JavascriptConversion::ToBool(argVal, scriptContext);
-
-            SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDBool8x16, 16, bool>(args[1], laneVar, value, scriptContext);
+            int8 intValue = (value) ? -1 : 0;
+            SIMDValue result = SIMDUtils::SIMD128ReplaceLane<JavascriptSIMDBool8x16, 16, int8>(args[1], laneVar, intValue, scriptContext);
 
             return JavascriptSIMDBool8x16::New(&result, scriptContext);
         }

lib/Runtime/Library/SimdFloat32x4Lib.cpp

@@ -92,7 +92,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDFloat64x2::Is(args[1]))
         {
             JavascriptSIMDFloat64x2 *instance = JavascriptSIMDFloat64x2::FromVar(args[1]);
-            return SIMDConvertTypeFromBits<JavascriptSIMDFloat64x2, JavascriptSIMDFloat32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDFloat64x2, JavascriptSIMDFloat32x4>(*instance, *scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("fromFloat64x2Bits"));
@@ -148,7 +148,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDInt32x4::Is(args[1]))
         {
             JavascriptSIMDInt32x4 *instance = JavascriptSIMDInt32x4::FromVar(args[1]);
-            return SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDFloat32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDFloat32x4>(*instance, *scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("fromInt32x4Bits"));
@@ -166,7 +166,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDInt16x8::Is(args[1]))
         {
             JavascriptSIMDInt16x8 *instance = JavascriptSIMDInt16x8::FromVar(args[1]);
-            return SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDFloat32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDFloat32x4>(*instance, *scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("fromInt16x8Bits"));
@@ -184,7 +184,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDInt8x16::Is(args[1]))
         {
             JavascriptSIMDInt8x16 *instance = JavascriptSIMDInt8x16::FromVar(args[1]);
-            return SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDFloat32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDFloat32x4>(*instance, *scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("fromInt8x16Bits"));
@@ -202,7 +202,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDUint32x4::Is(args[1]))
         {
             JavascriptSIMDUint32x4 *instance = JavascriptSIMDUint32x4::FromVar(args[1]);
-            return SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDFloat32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDFloat32x4>(*instance, *scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("fromUint32x4Bits"));
@@ -220,7 +220,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDUint16x8::Is(args[1]))
         {
             JavascriptSIMDUint16x8 *instance = JavascriptSIMDUint16x8::FromVar(args[1]);
-            return SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDFloat32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDFloat32x4>(*instance, *scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("fromUint16x8Bits"));
@@ -238,7 +238,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDUint8x16::Is(args[1]))
         {
             JavascriptSIMDUint8x16 *instance = JavascriptSIMDUint8x16::FromVar(args[1]);
-            return SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDFloat32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDFloat32x4>(*instance, *scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("fromUint8x16Bits"));
@@ -260,7 +260,7 @@ namespace Js
         {
             // if value arg is missing, then it is undefined.
             Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
-            float result = SIMD128ExtractLane<JavascriptSIMDFloat32x4, 4, float>(args[1], laneVar, scriptContext);
+            float result = SIMDUtils::SIMD128ExtractLane<JavascriptSIMDFloat32x4, 4, float>(args[1], laneVar, scriptContext);
 
             return JavascriptNumber::ToVarWithCheck(result, scriptContext);
         }
@@ -286,7 +286,7 @@ namespace Js
             Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
             float value = JavascriptConversion::ToFloat(argVal, scriptContext);
 
-            SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDFloat32x4, 4, float>(args[1], laneVar, value, scriptContext);
+            SIMDValue result = SIMDUtils::SIMD128ReplaceLane<JavascriptSIMDFloat32x4, 4, float>(args[1], laneVar, value, scriptContext);
 
             return JavascriptSIMDFloat32x4::New(&result, scriptContext);
         }
@@ -974,7 +974,7 @@ namespace Js
             Var lane2 = args[4];
             Var lane3 = args[5];
 
-            return SIMD128SlowShuffle<JavascriptSIMDFloat32x4>(args[1], args[1], lane0, lane1, lane2, lane3, 4, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDFloat32x4>(args[1], args[1], lane0, lane1, lane2, lane3, 4, scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("swizzle"));
@@ -1006,7 +1006,7 @@ namespace Js
             Var lane2 = args[5];
             Var lane3 = args[6];
 
-            return SIMD128SlowShuffle<JavascriptSIMDFloat32x4>(args[1], args[2], lane0, lane1, lane2, lane3, 8, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDFloat32x4>(args[1], args[2], lane0, lane1, lane2, lane3, 8, scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("shuffle"));
@@ -1093,7 +1093,7 @@ namespace Js
         Assert(!(callInfo.Flags & CallFlags_New));
 
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDFloat32x4>(args[1], args[2], 4 * FLOAT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDFloat32x4>(args[1], args[2], 4 * FLOAT32_SIZE, scriptContext);
     }
 
     Var SIMDFloat32x4Lib::EntryLoad1(RecyclableObject* function, CallInfo callInfo, ...)
@@ -1106,7 +1106,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDFloat32x4>(args[1], args[2], 1 * FLOAT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDFloat32x4>(args[1], args[2], 1 * FLOAT32_SIZE, scriptContext);
     }
 
     Var SIMDFloat32x4Lib::EntryLoad2(RecyclableObject* function, CallInfo callInfo, ...)
@@ -1119,7 +1119,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDFloat32x4>(args[1], args[2], 2 * FLOAT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDFloat32x4>(args[1], args[2], 2 * FLOAT32_SIZE, scriptContext);
     }
 
     Var SIMDFloat32x4Lib::EntryLoad3(RecyclableObject* function, CallInfo callInfo, ...)
@@ -1132,7 +1132,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDFloat32x4>(args[1], args[2], 3 * FLOAT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDFloat32x4>(args[1], args[2], 3 * FLOAT32_SIZE, scriptContext);
     }
 
     Var SIMDFloat32x4Lib::EntryStore(RecyclableObject* function, CallInfo callInfo, ...)
@@ -1147,7 +1147,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDFloat32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDFloat32x4>(args[1], args[2], args[3], 4 * FLOAT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDFloat32x4>(args[1], args[2], args[3], 4 * FLOAT32_SIZE, scriptContext);
             return JavascriptSIMDFloat32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Float32x4.store"));
@@ -1165,7 +1165,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDFloat32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDFloat32x4>(args[1], args[2], args[3], 1 * FLOAT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDFloat32x4>(args[1], args[2], args[3], 1 * FLOAT32_SIZE, scriptContext);
             return JavascriptSIMDFloat32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Float32x4.store"));
@@ -1183,7 +1183,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDFloat32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDFloat32x4>(args[1], args[2], args[3], 2 * FLOAT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDFloat32x4>(args[1], args[2], args[3], 2 * FLOAT32_SIZE, scriptContext);
             return JavascriptSIMDFloat32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Float32x4.store"));
@@ -1201,7 +1201,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDFloat32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDFloat32x4>(args[1], args[2], args[3], 3 * FLOAT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDFloat32x4>(args[1], args[2], args[3], 3 * FLOAT32_SIZE, scriptContext);
             return JavascriptSIMDFloat32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Float32x4.store"));

lib/Runtime/Library/SimdFloat64x2Lib.cpp

@@ -93,7 +93,7 @@ namespace Js
             JavascriptSIMDFloat32x4 *instance = JavascriptSIMDFloat32x4::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDFloat64x2>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDFloat64x2>(*instance, *scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("fromFloat32x4Bits"));
@@ -133,7 +133,7 @@ namespace Js
             JavascriptSIMDInt32x4 *instance = JavascriptSIMDInt32x4::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDFloat64x2>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDFloat64x2>(*instance, *scriptContext);
         }
 
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("fromInt32x4Bits"));
@@ -790,7 +790,7 @@ namespace Js
             Var lane0 = args[2];
             Var lane1 = args[3];
 
-            return SIMD128SlowShuffle<JavascriptSIMDFloat64x2, 2>(args[1], args[1], lane0, lane1, NULL, NULL, 2, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDFloat64x2, 2>(args[1], args[1], lane0, lane1, NULL, NULL, 2, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat64x2TypeMismatch, _u("swizzle"));
     }
@@ -818,7 +818,7 @@ namespace Js
             Var lane0 = args[3];
             Var lane1 = args[4];
 
-            return SIMD128SlowShuffle<JavascriptSIMDFloat64x2, 2>(args[1], args[2], lane0, lane1, NULL, NULL, 4, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDFloat64x2, 2>(args[1], args[2], lane0, lane1, NULL, NULL, 4, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat64x2TypeMismatch, _u("shuffle"));
     }
@@ -843,7 +843,7 @@ namespace Js
             JavascriptSIMDInt32x4 *mask = JavascriptSIMDInt32x4::FromVar(args[1]);
             Assert(mask);
 
-            JavascriptSIMDFloat64x2 *fmask = (JavascriptSIMDFloat64x2*)SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDFloat64x2>(mask, scriptContext);
+            JavascriptSIMDFloat64x2 *fmask = (JavascriptSIMDFloat64x2*)SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDFloat64x2>(*mask, *scriptContext);
             JavascriptSIMDFloat64x2 *tvalue = JavascriptSIMDFloat64x2::FromVar(args[2]);
             JavascriptSIMDFloat64x2 *fvalue = JavascriptSIMDFloat64x2::FromVar(args[3]);
             Assert(fmask && tvalue && fvalue);
@@ -873,7 +873,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDFloat64x2>(args[1], args[2], 2 * FLOAT64_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDFloat64x2>(args[1], args[2], 2 * FLOAT64_SIZE, scriptContext);
     }
 
     Var SIMDFloat64x2Lib::EntryLoad1(RecyclableObject* function, CallInfo callInfo, ...)
@@ -886,7 +886,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDFloat64x2>(args[1], args[2], 1 * FLOAT64_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDFloat64x2>(args[1], args[2], 1 * FLOAT64_SIZE, scriptContext);
     }
 
     Var SIMDFloat64x2Lib::EntryStore(RecyclableObject* function, CallInfo callInfo, ...)
@@ -901,7 +901,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDFloat64x2::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDFloat64x2>(args[1], args[2], args[3], 2 * FLOAT64_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDFloat64x2>(args[1], args[2], args[3], 2 * FLOAT64_SIZE, scriptContext);
             return NULL;
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Float64x2.store"));
@@ -920,7 +920,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDFloat64x2::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDFloat64x2>(args[1], args[2], args[3], 1 * FLOAT64_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDFloat64x2>(args[1], args[2], args[3], 1 * FLOAT64_SIZE, scriptContext);
             return NULL;
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Float64x2.store"));

lib/Runtime/Library/SimdInt16x8Lib.cpp

@@ -74,7 +74,7 @@ namespace Js
             JavascriptSIMDFloat32x4 *instance = JavascriptSIMDFloat32x4::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDInt16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDInt16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt16x8TypeMismatch, _u("fromFloat32x4Bits"));
     }
@@ -93,7 +93,7 @@ namespace Js
             JavascriptSIMDInt32x4 *instance = JavascriptSIMDInt32x4::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDInt16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDInt16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt16x8TypeMismatch, _u("fromInt32x4Bits"));
     }
@@ -112,7 +112,7 @@ namespace Js
             JavascriptSIMDInt8x16 *instance = JavascriptSIMDInt8x16::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDInt16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDInt16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt16x8TypeMismatch, _u("fromInt8x16Bits"));
     }
@@ -130,7 +130,7 @@ namespace Js
             JavascriptSIMDUint32x4 *instance = JavascriptSIMDUint32x4::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDInt16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDInt16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt16x8TypeMismatch, _u("fromUint32x4Bits"));
     }
@@ -149,7 +149,7 @@ namespace Js
             JavascriptSIMDUint16x8 *instance = JavascriptSIMDUint16x8::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDInt16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDInt16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt16x8TypeMismatch, _u("fromUint16x8Bits"));
     }
@@ -168,7 +168,7 @@ namespace Js
             JavascriptSIMDUint8x16 *instance = JavascriptSIMDUint8x16::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDInt16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDInt16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt16x8TypeMismatch, _u("fromUint8x16Bits"));
     }
@@ -600,7 +600,7 @@ namespace Js
         {
             // if value arg is missing, then it is undefined.
             Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
-            int16 result = SIMD128ExtractLane<JavascriptSIMDInt16x8, 8, int16>(args[1], laneVar, scriptContext);
+            int16 result = SIMDUtils::SIMD128ExtractLane<JavascriptSIMDInt16x8, 8, int16>(args[1], laneVar, scriptContext);
 
             return JavascriptNumber::ToVarNoCheck(result, scriptContext);
         }
@@ -626,7 +626,7 @@ namespace Js
             Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
             int16 value = JavascriptConversion::ToInt16(argVal, scriptContext);
 
-            SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDInt16x8, 8, int16>(args[1], laneVar, value, scriptContext);
+            SIMDValue result = SIMDUtils::SIMD128ReplaceLane<JavascriptSIMDInt16x8, 8, int16>(args[1], laneVar, value, scriptContext);
 
             return JavascriptSIMDInt16x8::New(&result, scriptContext);
         }
@@ -704,7 +704,7 @@ namespace Js
         Assert(!(callInfo.Flags & CallFlags_New));
 
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDInt16x8>(args[1], args[2], 8 * INT16_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDInt16x8>(args[1], args[2], 8 * INT16_SIZE, scriptContext);
     }
 
     Var SIMDInt16x8Lib::EntryStore(RecyclableObject* function, CallInfo callInfo, ...)
@@ -719,7 +719,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDInt16x8::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDInt16x8>(args[1], args[2], args[3], 8 * INT16_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDInt16x8>(args[1], args[2], args[3], 8 * INT16_SIZE, scriptContext);
             return JavascriptSIMDInt16x8::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Int16x8.store"));
@@ -749,7 +749,7 @@ namespace Js
             {
                 lanes[i] = args[i + 2];
             }
-            return SIMD128SlowShuffle<JavascriptSIMDInt16x8>(args[1], args[1], lanes, 8, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDInt16x8>(args[1], args[1], lanes, 8, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt16x8TypeMismatch, _u("swizzle"));
     }
@@ -781,7 +781,7 @@ namespace Js
                 lanes[i] = args[i + 3];
             }
 
-            return SIMD128SlowShuffle<JavascriptSIMDInt16x8>(args[1], args[2], lanes, 16, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDInt16x8>(args[1], args[2], lanes, 16, scriptContext);
 
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt16x8TypeMismatch, _u("shuffle"));

lib/Runtime/Library/SimdInt32x4Lib.cpp

@@ -92,7 +92,7 @@ namespace Js
             JavascriptSIMDFloat64x2 *instance = JavascriptSIMDFloat64x2::FromVar(args[1]);
             Assert(instance);
 
-            return  SIMDConvertTypeFromBits<JavascriptSIMDFloat64x2, JavascriptSIMDInt32x4>(instance, scriptContext);
+            return  SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDFloat64x2, JavascriptSIMDInt32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromFloat64x2Bits"));
     }
@@ -137,7 +137,7 @@ namespace Js
             JavascriptSIMDFloat32x4 *instance = JavascriptSIMDFloat32x4::FromVar(args[1]);
             Assert(instance);
 
-            return  SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDInt32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDInt32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromFloat32x4Bits"));
     }
@@ -156,7 +156,7 @@ namespace Js
             JavascriptSIMDUint32x4 *instance = JavascriptSIMDUint32x4::FromVar(args[1]);
             Assert(instance);
 
-            return  SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDInt32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDInt32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromUint32x4Bits"));
     }
@@ -175,7 +175,7 @@ namespace Js
             JavascriptSIMDUint8x16 *instance = JavascriptSIMDUint8x16::FromVar(args[1]);
             Assert(instance);
 
-            return  SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDInt32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDInt32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromUint8x16Bits"));
     }
@@ -194,7 +194,7 @@ namespace Js
             JavascriptSIMDUint16x8 *instance = JavascriptSIMDUint16x8::FromVar(args[1]);
             Assert(instance);
 
-            return  SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDInt32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDInt32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromUint16x8Bits"));
     }
@@ -213,7 +213,7 @@ namespace Js
             JavascriptSIMDInt8x16 *instance = JavascriptSIMDInt8x16::FromVar(args[1]);
             Assert(instance);
 
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDInt32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDInt32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromInt8x16Bits"));
     }
@@ -232,7 +232,7 @@ namespace Js
             JavascriptSIMDInt16x8 *instance = JavascriptSIMDInt16x8::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDInt32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDInt32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromInt16x8Bits"));
     }
@@ -253,7 +253,7 @@ namespace Js
         {
             // if value arg is missing, then it is undefined.
             Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
-            int result = SIMD128ExtractLane<JavascriptSIMDInt32x4, 4, int>(args[1], laneVar, scriptContext);
+            int result = SIMDUtils::SIMD128ExtractLane<JavascriptSIMDInt32x4, 4, int>(args[1], laneVar, scriptContext);
 
             return JavascriptNumber::ToVarNoCheck(result, scriptContext);
         }
@@ -279,7 +279,7 @@ namespace Js
             Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
             int value = JavascriptConversion::ToInt32(argVal, scriptContext);
 
-            SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDInt32x4, 4, int>(args[1], laneVar, value, scriptContext);
+            SIMDValue result = SIMDUtils::SIMD128ReplaceLane<JavascriptSIMDInt32x4, 4, int>(args[1], laneVar, value, scriptContext);
 
             return JavascriptSIMDInt32x4::New(&result, scriptContext);
         }
@@ -808,7 +808,7 @@ namespace Js
             Var lane2 = args[4];
             Var lane3 = args[5];
 
-            return SIMD128SlowShuffle<JavascriptSIMDInt32x4>(args[1], args[1], lane0, lane1, lane2, lane3, 4, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDInt32x4>(args[1], args[1], lane0, lane1, lane2, lane3, 4, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("swizzle"));
     }
@@ -839,7 +839,7 @@ namespace Js
             Var lane2 = args[5];
             Var lane3 = args[6];
 
-            return SIMD128SlowShuffle<JavascriptSIMDInt32x4>(args[1], args[2], lane0, lane1, lane2, lane3, 8, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDInt32x4>(args[1], args[2], lane0, lane1, lane2, lane3, 8, scriptContext);
 
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("shuffle"));
@@ -945,7 +945,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDInt32x4>(args[1], args[2], 4 * INT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDInt32x4>(args[1], args[2], 4 * INT32_SIZE, scriptContext);
     }
 
     Var SIMDInt32x4Lib::EntryLoad1(RecyclableObject* function, CallInfo callInfo, ...)
@@ -958,7 +958,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDInt32x4>(args[1], args[2], 1 * INT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDInt32x4>(args[1], args[2], 1 * INT32_SIZE, scriptContext);
     }
 
     Var SIMDInt32x4Lib::EntryLoad2(RecyclableObject* function, CallInfo callInfo, ...)
@@ -971,7 +971,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDInt32x4>(args[1], args[2], 2 * INT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDInt32x4>(args[1], args[2], 2 * INT32_SIZE, scriptContext);
     }
 
     Var SIMDInt32x4Lib::EntryLoad3(RecyclableObject* function, CallInfo callInfo, ...)
@@ -984,7 +984,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDInt32x4>(args[1], args[2], 3 * INT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDInt32x4>(args[1], args[2], 3 * INT32_SIZE, scriptContext);
     }
 
     Var SIMDInt32x4Lib::EntryStore(RecyclableObject* function, CallInfo callInfo, ...)
@@ -999,7 +999,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDInt32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDInt32x4>(args[1], args[2], args[3], 4 * INT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDInt32x4>(args[1], args[2], args[3], 4 * INT32_SIZE, scriptContext);
             return JavascriptSIMDInt32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Int32x4.store"));
@@ -1017,7 +1017,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDInt32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDInt32x4>(args[1], args[2], args[3], 1 * INT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDInt32x4>(args[1], args[2], args[3], 1 * INT32_SIZE, scriptContext);
             return JavascriptSIMDInt32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Int32x4.store"));
@@ -1035,7 +1035,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDInt32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDInt32x4>(args[1], args[2], args[3], 2 * INT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDInt32x4>(args[1], args[2], args[3], 2 * INT32_SIZE, scriptContext);
             return JavascriptSIMDInt32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Int32x4.store"));
@@ -1053,7 +1053,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDInt32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDInt32x4>(args[1], args[2], args[3], 3 * INT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDInt32x4>(args[1], args[2], args[3], 3 * INT32_SIZE, scriptContext);
             return JavascriptSIMDInt32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Int32x4.store"));

lib/Runtime/Library/SimdInt8x16Lib.cpp

@@ -105,7 +105,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDFloat32x4::Is(args[1]))
         {
             JavascriptSIMDFloat32x4 *instance = JavascriptSIMDFloat32x4::FromVar(args[1]);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDInt8x16>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDInt8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt8x16TypeMismatch, _u("fromFloat32x4Bits"));
     }
@@ -122,7 +122,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDInt32x4::Is(args[1]))
         {
             JavascriptSIMDInt32x4 *instance = JavascriptSIMDInt32x4::FromVar(args[1]);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDInt8x16>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDInt8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt8x16TypeMismatch, _u("fromInt32x4Bits"));
     }
@@ -139,7 +139,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDInt16x8::Is(args[1]))
         {
             JavascriptSIMDInt16x8 *instance = JavascriptSIMDInt16x8::FromVar(args[1]);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDInt8x16>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDInt8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt8x16TypeMismatch, _u("fromInt16x8Bits"));
     }
@@ -156,7 +156,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDUint32x4::Is(args[1]))
         {
             JavascriptSIMDUint32x4 *instance = JavascriptSIMDUint32x4::FromVar(args[1]);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDInt8x16>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDInt8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt8x16TypeMismatch, _u("fromUint32x4Bits"));
     }
@@ -173,7 +173,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDUint16x8::Is(args[1]))
         {
             JavascriptSIMDUint16x8 *instance = JavascriptSIMDUint16x8::FromVar(args[1]);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDInt8x16>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDInt8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt8x16TypeMismatch, _u("fromUint16x8Bits"));
     }
@@ -191,7 +191,7 @@ namespace Js
         if (args.Info.Count >= 2 && JavascriptSIMDUint8x16::Is(args[1]))
         {
             JavascriptSIMDUint8x16 *instance = JavascriptSIMDUint8x16::FromVar(args[1]);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDInt8x16>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDInt8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt8x16TypeMismatch, _u("fromUint8x16Bits"));
     }
@@ -793,7 +793,7 @@ namespace Js
         Assert(!(callInfo.Flags & CallFlags_New));
 
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDInt8x16>(args[1], args[2], 16 * INT8_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDInt8x16>(args[1], args[2], 16 * INT8_SIZE, scriptContext);
     }
 
     Var SIMDInt8x16Lib::EntryStore(RecyclableObject* function, CallInfo callInfo, ...)
@@ -808,7 +808,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDInt8x16::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDInt8x16>(args[1], args[2], args[3], 16 * INT8_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDInt8x16>(args[1], args[2], args[3], 16 * INT8_SIZE, scriptContext);
             return JavascriptSIMDInt8x16::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Int8x16.store"));
@@ -842,7 +842,7 @@ namespace Js
                 lanes[i] = args[i + 2];
             }
 
-            return SIMD128SlowShuffle<JavascriptSIMDInt8x16, 16>(args[1], args[1], lanes, 16, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDInt8x16, 16>(args[1], args[1], lanes, 16, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt8x16TypeMismatch, _u("swizzle"));
     }
@@ -873,7 +873,7 @@ namespace Js
             {
                 lanes[i] = args[i + 3];
             }
-            return SIMD128SlowShuffle<JavascriptSIMDInt8x16, 16>(args[1], args[2], lanes, 32, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDInt8x16, 16>(args[1], args[2], lanes, 32, scriptContext);
 
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt8x16TypeMismatch, _u("shuffle"));
@@ -895,7 +895,7 @@ namespace Js
         {
             // if value arg is missing, then it is undefined.
             Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
-            int8 result = SIMD128ExtractLane<JavascriptSIMDInt8x16, 16, int8>(args[1], laneVar, scriptContext);
+            int8 result = SIMDUtils::SIMD128ExtractLane<JavascriptSIMDInt8x16, 16, int8>(args[1], laneVar, scriptContext);
 
             return JavascriptNumber::ToVarNoCheck(result, scriptContext);
         }
@@ -921,7 +921,7 @@ namespace Js
             Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
             int8 value = JavascriptConversion::ToInt8(argVal, scriptContext);
 
-            SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDInt8x16, 16, int8>(args[1], laneVar, value, scriptContext);
+            SIMDValue result = SIMDUtils::SIMD128ReplaceLane<JavascriptSIMDInt8x16, 16, int8>(args[1], laneVar, value, scriptContext);
 
             return JavascriptSIMDInt8x16::New(&result, scriptContext);
         }

lib/Runtime/Library/SimdUint16x8Lib.cpp

@@ -75,7 +75,7 @@ namespace Js
         {
             JavascriptSIMDFloat32x4 *instance = JavascriptSIMDFloat32x4::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDUint16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDUint16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("fromFloat32x4Bits"));
     }
@@ -93,7 +93,7 @@ namespace Js
         {
             JavascriptSIMDInt32x4 *instance = JavascriptSIMDInt32x4::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDUint16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDUint16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("fromInt32x4Bits"));
     }
@@ -112,7 +112,7 @@ namespace Js
         {
             JavascriptSIMDInt16x8 *instance = JavascriptSIMDInt16x8::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDUint16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDUint16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("fromInt16x8Bits"));
     }
@@ -130,7 +130,7 @@ namespace Js
         {
             JavascriptSIMDInt8x16 *instance = JavascriptSIMDInt8x16::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDUint16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDUint16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("fromInt8x16Bits"));
     }
@@ -148,7 +148,7 @@ namespace Js
         {
             JavascriptSIMDUint32x4 *instance = JavascriptSIMDUint32x4::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDUint16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDUint16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("fromUint32x4Bits"));
     }
@@ -166,7 +166,7 @@ namespace Js
         {
             JavascriptSIMDUint8x16 *instance = JavascriptSIMDUint8x16::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDUint16x8>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDUint16x8>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("fromUint8x16Bits"));
     }
@@ -238,7 +238,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDUint16x8>(args[1], args[2], 8 * INT16_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDUint16x8>(args[1], args[2], 8 * INT16_SIZE, scriptContext);
     }
 
     Var SIMDUint16x8Lib::EntryStore(RecyclableObject* function, CallInfo callInfo, ...)
@@ -253,7 +253,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDUint16x8::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDUint16x8>(args[1], args[2], args[3], 8 * INT16_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDUint16x8>(args[1], args[2], args[3], 8 * INT16_SIZE, scriptContext);
             return JavascriptSIMDUint16x8::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Uint16x8.store"));
@@ -752,7 +752,7 @@ namespace Js
             {
                 lanes[i] = args[i + 2];
             }
-            return SIMD128SlowShuffle<JavascriptSIMDUint16x8>(args[1], args[1], lanes, 8, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDUint16x8>(args[1], args[1], lanes, 8, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("swizzle"));
     }
@@ -783,7 +783,7 @@ namespace Js
             {
                 lanes[i] = args[i + 3];
             }
-            return SIMD128SlowShuffle<JavascriptSIMDUint16x8>(args[1], args[2], lanes, 16, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDUint16x8>(args[1], args[2], lanes, 16, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("shuffle"));
     }
@@ -804,7 +804,7 @@ namespace Js
         {
             // if value arg is missing, then it is undefined.
             Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
-            uint16 result = SIMD128ExtractLane<JavascriptSIMDUint16x8, 8, uint16>(args[1], laneVar, scriptContext);
+            uint16 result = SIMDUtils::SIMD128ExtractLane<JavascriptSIMDUint16x8, 8, uint16>(args[1], laneVar, scriptContext);
 
             return JavascriptNumber::ToVarNoCheck(result, scriptContext);
         }
@@ -830,7 +830,7 @@ namespace Js
             Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
             uint16 value = JavascriptConversion::ToInt16(argVal, scriptContext);
 
-            SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDUint16x8, 8, uint16>(args[1], laneVar, value, scriptContext);
+            SIMDValue result = SIMDUtils::SIMD128ReplaceLane<JavascriptSIMDUint16x8, 8, uint16>(args[1], laneVar, value, scriptContext);
 
             return JavascriptSIMDUint16x8::New(&result, scriptContext);
         }

lib/Runtime/Library/SimdUint32x4Lib.cpp

@@ -105,7 +105,7 @@ namespace Js
         {
             JavascriptSIMDFloat32x4 *instance = JavascriptSIMDFloat32x4::FromVar(args[1]);
             Assert(instance);
-            return SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDUint32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDUint32x4>(*instance, *scriptContext);
 
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdFloat32x4TypeMismatch, _u("fromFloat32x4Bits"));
@@ -125,7 +125,7 @@ namespace Js
             JavascriptSIMDInt32x4 *instance = JavascriptSIMDInt32x4::FromVar(args[1]);
             Assert(instance);
 
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDUint32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDUint32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromInt32x4Bits"));
     }
@@ -144,7 +144,7 @@ namespace Js
             JavascriptSIMDInt16x8 *instance = JavascriptSIMDInt16x8::FromVar(args[1]);
             Assert(instance);
 
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDUint32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDUint32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromInt16x8Bits"));
     }
@@ -163,7 +163,7 @@ namespace Js
             JavascriptSIMDInt8x16 *instance = JavascriptSIMDInt8x16::FromVar(args[1]);
             Assert(instance);
 
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDUint32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDUint32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromInt8x16Bits"));
     }
@@ -182,7 +182,7 @@ namespace Js
             JavascriptSIMDUint16x8 *instance = JavascriptSIMDUint16x8::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDUint32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDUint32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromUint16x8Bits"));
     }
@@ -201,7 +201,7 @@ namespace Js
             JavascriptSIMDUint8x16 *instance = JavascriptSIMDUint8x16::FromVar(args[1]);
             Assert(instance);
 
-            return SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDUint32x4>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDUint32x4>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromUint8x16Bits"));
     }
@@ -222,7 +222,7 @@ namespace Js
         {
             // if value arg is missing, then it is undefined.
             Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
-            uint result = SIMD128ExtractLane<JavascriptSIMDUint32x4, 4, uint>(args[1], laneVar, scriptContext);
+            uint result = SIMDUtils::SIMD128ExtractLane<JavascriptSIMDUint32x4, 4, uint>(args[1], laneVar, scriptContext);
 
             return JavascriptNumber::ToVarNoCheck((double)result, scriptContext);
         }
@@ -248,7 +248,7 @@ namespace Js
             Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
             uint value = JavascriptConversion::ToUInt32(argVal, scriptContext);
 
-            SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDUint32x4, 4, uint>(args[1], laneVar, value, scriptContext);
+            SIMDValue result = SIMDUtils::SIMD128ReplaceLane<JavascriptSIMDUint32x4, 4, uint32>(args[1], laneVar, value, scriptContext);
 
             return JavascriptSIMDUint32x4::New(&result, scriptContext);
         }
@@ -754,7 +754,7 @@ namespace Js
             Var lane2 = args[4];
             Var lane3 = args[5];
 
-            return SIMD128SlowShuffle<JavascriptSIMDUint32x4>(args[1], args[1], lane0, lane1, lane2, lane3, 4, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDUint32x4>(args[1], args[1], lane0, lane1, lane2, lane3, 4, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint32x4TypeMismatch, _u("swizzle"));
     }
@@ -785,7 +785,7 @@ namespace Js
             Var lane2 = args[5];
             Var lane3 = args[6];
 
-            return SIMD128SlowShuffle<JavascriptSIMDUint32x4>(args[1], args[2], lane0, lane1, lane2, lane3, 8, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDUint32x4>(args[1], args[2], lane0, lane1, lane2, lane3, 8, scriptContext);
 
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint32x4TypeMismatch, _u("shuffle"));
@@ -891,7 +891,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDUint32x4>(args[1], args[2], 4 * INT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDUint32x4>(args[1], args[2], 4 * INT32_SIZE, scriptContext);
     }
 
     Var SIMDUint32x4Lib::EntryLoad1(RecyclableObject* function, CallInfo callInfo, ...)
@@ -904,7 +904,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDUint32x4>(args[1], args[2], 1 * INT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDUint32x4>(args[1], args[2], 1 * INT32_SIZE, scriptContext);
     }
 
     Var SIMDUint32x4Lib::EntryLoad2(RecyclableObject* function, CallInfo callInfo, ...)
@@ -917,7 +917,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDUint32x4>(args[1], args[2], 2 * INT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDUint32x4>(args[1], args[2], 2 * INT32_SIZE, scriptContext);
     }
 
     Var SIMDUint32x4Lib::EntryLoad3(RecyclableObject* function, CallInfo callInfo, ...)
@@ -930,7 +930,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDUint32x4>(args[1], args[2], 3 * INT32_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDUint32x4>(args[1], args[2], 3 * INT32_SIZE, scriptContext);
     }
 
     Var SIMDUint32x4Lib::EntryStore(RecyclableObject* function, CallInfo callInfo, ...)
@@ -945,7 +945,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDUint32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDUint32x4>(args[1], args[2], args[3], 4 * INT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDUint32x4>(args[1], args[2], args[3], 4 * INT32_SIZE, scriptContext);
             return JavascriptSIMDUint32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.UInt32x4.store"));
@@ -963,7 +963,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDUint32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDUint32x4>(args[1], args[2], args[3], 1 * INT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDUint32x4>(args[1], args[2], args[3], 1 * INT32_SIZE, scriptContext);
             return JavascriptSIMDUint32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.UInt32x4.store"));
@@ -981,7 +981,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDUint32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDUint32x4>(args[1], args[2], args[3], 2 * INT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDUint32x4>(args[1], args[2], args[3], 2 * INT32_SIZE, scriptContext);
             return JavascriptSIMDUint32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.UInt32x4.store"));
@@ -999,7 +999,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDUint32x4::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDUint32x4>(args[1], args[2], args[3], 3 * INT32_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDUint32x4>(args[1], args[2], args[3], 3 * INT32_SIZE, scriptContext);
             return JavascriptSIMDUint32x4::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.UInt32x4.store"));

lib/Runtime/Library/SimdUint8x16Lib.cpp

@@ -76,7 +76,7 @@ namespace Js
         {
             JavascriptSIMDFloat32x4 *instance = JavascriptSIMDFloat32x4::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDUint8x16>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDFloat32x4, JavascriptSIMDUint8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint8x16TypeMismatch, _u("fromFloat32x4Bits"));
     }
@@ -94,7 +94,7 @@ namespace Js
         {
             JavascriptSIMDInt32x4 *instance = JavascriptSIMDInt32x4::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDUint8x16>(instance, scriptContext);
+            return  SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt32x4, JavascriptSIMDUint8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint8x16TypeMismatch, _u("fromInt32x4Bits"));
     }
@@ -112,7 +112,7 @@ namespace Js
         {
             JavascriptSIMDInt16x8 *instance = JavascriptSIMDInt16x8::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDUint8x16>(instance, scriptContext);
+            return SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt16x8, JavascriptSIMDUint8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint8x16TypeMismatch, _u("fromInt16x8Bits"));
     }
@@ -130,7 +130,7 @@ namespace Js
         {
             JavascriptSIMDInt8x16 *instance = JavascriptSIMDInt8x16::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDUint8x16>(instance, scriptContext);
+            return  SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDInt8x16, JavascriptSIMDUint8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint8x16TypeMismatch, _u("fromInt8x16Bits"));
     }
@@ -148,7 +148,7 @@ namespace Js
         {
             JavascriptSIMDUint32x4 *instance = JavascriptSIMDUint32x4::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDUint8x16>(instance, scriptContext);
+            return  SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint32x4, JavascriptSIMDUint8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint8x16TypeMismatch, _u("fromUint32x4Bits"));
     }
@@ -166,7 +166,7 @@ namespace Js
         {
             JavascriptSIMDUint16x8 *instance = JavascriptSIMDUint16x8::FromVar(args[1]);
             Assert(instance);
-            return  SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDUint8x16>(instance, scriptContext);
+            return  SIMDUtils::SIMDConvertTypeFromBits<JavascriptSIMDUint16x8, JavascriptSIMDUint8x16>(*instance, *scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint8x16TypeMismatch, _u("fromUint16x8Bits"));
     }
@@ -238,7 +238,7 @@ namespace Js
         AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
         Assert(!(callInfo.Flags & CallFlags_New));
 
-        return SIMD128TypedArrayLoad<JavascriptSIMDUint8x16>(args[1], args[2], 16 * INT8_SIZE, scriptContext);
+        return SIMDUtils::SIMD128TypedArrayLoad<JavascriptSIMDUint8x16>(args[1], args[2], 16 * INT8_SIZE, scriptContext);
     }
 
     Var SIMDUint8x16Lib::EntryStore(RecyclableObject* function, CallInfo callInfo, ...)
@@ -253,7 +253,7 @@ namespace Js
 
         if (args.Info.Count >= 4 && JavascriptSIMDUint8x16::Is(args[3]))
         {
-            SIMD128TypedArrayStore<JavascriptSIMDUint8x16>(args[1], args[2], args[3], 16 * INT8_SIZE, scriptContext);
+            SIMDUtils::SIMD128TypedArrayStore<JavascriptSIMDUint8x16>(args[1], args[2], args[3], 16 * INT8_SIZE, scriptContext);
             return JavascriptSIMDUint8x16::FromVar(args[3]);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Uint8x16.store"));
@@ -752,7 +752,7 @@ namespace Js
             {
                 lanes[i] = args[i + 2];
             }
-            return SIMD128SlowShuffle<JavascriptSIMDUint8x16, 16>(args[1], args[1], lanes, 16, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDUint8x16, 16>(args[1], args[1], lanes, 16, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint8x16TypeMismatch, _u("swizzle"));
     }
@@ -783,7 +783,7 @@ namespace Js
             {
                 lanes[i] = args[i + 3];
             }
-            return SIMD128SlowShuffle<JavascriptSIMDUint8x16, 16>(args[1], args[2], lanes, 32, scriptContext);
+            return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDUint8x16, 16>(args[1], args[2], lanes, 32, scriptContext);
         }
         JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint8x16TypeMismatch, _u("shuffle"));
     }
@@ -804,7 +804,7 @@ namespace Js
         {
             // if value arg is missing, then it is undefined.
             Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
-            uint8 result = SIMD128ExtractLane<JavascriptSIMDUint8x16, 16, uint8>(args[1], laneVar, scriptContext);
+            uint8 result = SIMDUtils::SIMD128ExtractLane<JavascriptSIMDUint8x16, 16, uint8>(args[1], laneVar, scriptContext);
 
             return JavascriptNumber::ToVarNoCheck(result, scriptContext);
         }
@@ -830,7 +830,7 @@ namespace Js
             Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
             uint8 value = JavascriptConversion::ToInt8(argVal, scriptContext);
 
-            SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDUint8x16, 16, uint8>(args[1], laneVar, value, scriptContext);
+            SIMDValue result = SIMDUtils::SIMD128ReplaceLane<JavascriptSIMDUint8x16, 16, uint8>(args[1], laneVar, value, scriptContext);
 
             return JavascriptSIMDUint8x16::New(&result, scriptContext);
         }