Merge branch 'master' into wasm.simd.cleanup

penzn · web-flow · commit c16c5cfa3fa3 · 2019-01-31T09:15:14.000-08:00
diff --git a/lib/Backend/IR.cpp b/lib/Backend/IR.cpp
@@ -3464,6 +3464,11 @@ IR::Instr* Instr::GetBytecodeArgOutCapture()
         this->m_opcode == Js::OpCode::ArgOut_A_InlineBuiltIn);
     Assert(this->m_dst->GetStackSym()->m_isArgCaptured);
     IR::Instr* instr = this->GetSrc1()->GetStackSym()->m_instrDef;
+    while (instr->m_opcode != Js::OpCode::BytecodeArgOutCapture)
+    {
+        Assert(instr->GetSrc1() && instr->GetSrc1()->GetStackSym() && instr->GetSrc1()->GetStackSym()->IsSingleDef());
+        instr = instr->GetSrc1()->GetStackSym()->m_instrDef;
+    }
     Assert(instr->m_opcode == Js::OpCode::BytecodeArgOutCapture);
     return instr;
 }
diff --git a/lib/Backend/IRBuilder.cpp b/lib/Backend/IRBuilder.cpp
@@ -4857,6 +4857,7 @@ IRBuilder::BuildElementC2(Js::OpCode newOpcode, uint32 offset, Js::RegSlot insta
             regOpnd = this->BuildDstOpnd(regSlot);
 
             instr = IR::ProfiledInstr::New(newOpcode, regOpnd, fieldSymOpnd, value2Opnd, m_func);
+            instr->AsProfiledInstr()->u.FldInfo() = *(m_func->GetReadOnlyProfileInfo()->GetFldInfo(propertyIdIndex));
             this->AddInstr(instr, offset);
         }
         break;
@@ -4878,7 +4879,7 @@ IRBuilder::BuildElementC2(Js::OpCode newOpcode, uint32 offset, Js::RegSlot insta
         value2Opnd = this->BuildSrcOpnd(value2Slot);
 
         instr = IR::ProfiledInstr::New(newOpcode, fieldSymOpnd, regOpnd, value2Opnd, m_func);
-
+        instr->AsProfiledInstr()->u.FldInfo() = *(m_func->GetReadOnlyProfileInfo()->GetFldInfo(propertyIdIndex));
         this->AddInstr(instr, offset);
         break;
     }
diff --git a/lib/Backend/IRBuilderAsmJs.cpp b/lib/Backend/IRBuilderAsmJs.cpp
@@ -337,7 +337,7 @@ IRBuilderAsmJs::BuildSrcOpnd(Js::RegSlot srcRegSlot, IRType type)
 {
     StackSym * symSrc = m_func->m_symTable->FindStackSym(BuildSrcStackSymID(srcRegSlot, type));
     AssertMsg(symSrc, "Tried to use an undefined stack slot?");
-        IR::RegOpnd * regOpnd = IR::RegOpnd::New(symSrc, type, m_func);
+    IR::RegOpnd * regOpnd = IR::RegOpnd::New(symSrc, type, m_func);
 
     return regOpnd;
 }
@@ -5901,7 +5901,6 @@ IRBuilderAsmJs::BuildInt1Uint8x16_1Int1(Js::OpCodeAsmJs newOpcode, uint32 offset
 
 void IRBuilderAsmJs::BuildUint8x16_2Int16(Js::OpCodeAsmJs newOpcode, uint32 offset, BUILD_SIMD_ARGS_REG18)
 {
-    IR::RegOpnd * dstOpnd = BuildDstOpnd(dstRegSlot, TySimd128U16);
     IR::RegOpnd * src1Opnd = BuildSrcOpnd(src1RegSlot, TySimd128U16);
 
     IR::RegOpnd * src2Opnd = BuildIntConstOpnd(src2RegSlot);
@@ -5921,6 +5920,8 @@ void IRBuilderAsmJs::BuildUint8x16_2Int16(Js::OpCodeAsmJs newOpcode, uint32 offs
     IR::RegOpnd * src16Opnd = BuildIntConstOpnd(src16RegSlot);
     IR::RegOpnd * src17Opnd = BuildIntConstOpnd(src17RegSlot);
 
+    IR::RegOpnd * dstOpnd = BuildDstOpnd(dstRegSlot, TySimd128U16);
+
     IR::Instr * instr = nullptr;
     dstOpnd->SetValueType(ValueType::Simd);
     src1Opnd->SetValueType(ValueType::Simd);
@@ -5959,9 +5960,9 @@ IRBuilderAsmJs::BuildAsmShuffle(Js::OpCodeAsmJs newOpcode, uint32 offset)
     Assert(OpCodeAttrAsmJs::HasMultiSizeLayout(newOpcode) && newOpcode == Js::OpCodeAsmJs::Simd128_Shuffle_V8X16);
     auto layout = m_jnReader.GetLayout<Js::OpLayoutT_AsmShuffle<SizePolicy>>();
 
-    IR::RegOpnd * dstOpnd = BuildDstOpnd(GetRegSlotFromSimd128Reg(layout->R0), TySimd128U16);
     IR::RegOpnd * src1Opnd = BuildSrcOpnd(GetRegSlotFromSimd128Reg(layout->R1), TySimd128U16);
     IR::RegOpnd * src2Opnd = BuildSrcOpnd(GetRegSlotFromSimd128Reg(layout->R2), TySimd128U16);
+    IR::RegOpnd * dstOpnd = BuildDstOpnd(GetRegSlotFromSimd128Reg(layout->R0), TySimd128U16);
     dstOpnd->SetValueType(ValueType::Simd);
     src1Opnd->SetValueType(ValueType::Simd);
     src2Opnd->SetValueType(ValueType::Simd);
@@ -5980,7 +5981,6 @@ IRBuilderAsmJs::BuildAsmShuffle(Js::OpCodeAsmJs newOpcode, uint32 offset)
 
 void IRBuilderAsmJs::BuildUint8x16_3Int16(Js::OpCodeAsmJs newOpcode, uint32 offset, BUILD_SIMD_ARGS_REG19)
 {
-    IR::RegOpnd * dstOpnd = BuildDstOpnd(dstRegSlot, TySimd128U16);
     IR::RegOpnd * src1Opnd = BuildSrcOpnd(src1RegSlot, TySimd128U16);
     IR::RegOpnd * src2Opnd = BuildSrcOpnd(src2RegSlot, TySimd128U16);
 
@@ -6001,6 +6001,8 @@ void IRBuilderAsmJs::BuildUint8x16_3Int16(Js::OpCodeAsmJs newOpcode, uint32 offs
     IR::RegOpnd * src17Opnd = BuildIntConstOpnd(src17RegSlot);
     IR::RegOpnd * src18Opnd = BuildIntConstOpnd(src18RegSlot);
 
+    IR::RegOpnd * dstOpnd = BuildDstOpnd(dstRegSlot, TySimd128U16);
+
     IR::Instr * instr = nullptr;
     dstOpnd->SetValueType(ValueType::Simd);
     src1Opnd->SetValueType(ValueType::Simd);
diff --git a/lib/Common/Common/NumberUtilities.cpp b/lib/Common/Common/NumberUtilities.cpp
@@ -17,6 +17,7 @@ using namespace Js;
     // Redeclare static constants
     const UINT64 NumberConstantsBase::k_Nan;
     const UINT32 NumberConstantsBase::k_Nan32;
+    const UINT64 NumberConstantsBase::k_NegativeNan;
     const INT64 NumberUtilitiesBase::Pos_InvalidInt64;
     const INT64 NumberUtilitiesBase::Neg_InvalidInt64;
     const uint64 NumberConstants::k_PosInf;
@@ -59,6 +60,7 @@ using namespace Js;
     const double NumberConstants::MAX_VALUE = *(double*)(&NumberConstants::k_PosMax);
     const double NumberConstants::MIN_VALUE = *(double*)(&NumberConstants::k_PosMin);
     const double NumberConstants::NaN = *(double*)(&NumberConstants::k_Nan);
+    const double NumberConstants::NegativeNaN = *(double*)(&NumberConstants::k_NegativeNan);
     const double NumberConstants::NEGATIVE_INFINITY= *(double*)(&NumberConstants::k_NegInf);
     const double NumberConstants::POSITIVE_INFINITY= *(double*)(&NumberConstants::k_PosInf );
     const double NumberConstants::NEG_ZERO= *(double*)(&NumberConstants::k_NegZero );
diff --git a/lib/Common/Common/NumberUtilities.h b/lib/Common/Common/NumberUtilities.h
@@ -64,6 +64,7 @@ namespace Js
         static const double     MAX_VALUE;
         static const double     MIN_VALUE;
         static const double     NaN;
+        static const double     NegativeNaN;
         static const double     NEGATIVE_INFINITY;
         static const double     POSITIVE_INFINITY;
         static const double     NEG_ZERO;
@@ -99,6 +100,7 @@ namespace Js
 
         static bool IsFinite(double value);
         static bool IsNan(double value);
+        static bool IsNegative(double value);
         static bool IsFloat32NegZero(float value);
         static bool IsSpecial(double value, uint64 nSpecial);
         static uint64 ToSpecial(double value);
diff --git a/lib/Common/Common/NumberUtilities.inl b/lib/Common/Common/NumberUtilities.inl
@@ -137,8 +137,8 @@ namespace Js
     NUMBER_UTIL_INLINE bool NumberUtilities::IsNan(double value)
     {
 #if defined(TARGET_64)
-        // NaN is a range of values; all bits on the exponent are 1's and some nonzero significant.
-        // no distinction on signed NaN's
+        // NaN is a range of values; all bits on the exponent are 1's 
+        // and some nonzero significant. No distinction on signed NaN's.
         uint64 nCompare = ToSpecial(value);
         bool isNan = (0 == (~nCompare & 0x7FF0000000000000ull) &&
             0 != (nCompare & 0x000FFFFFFFFFFFFFull));
@@ -149,6 +149,12 @@ namespace Js
 #endif
     }
 
+    NUMBER_UTIL_INLINE bool NumberUtilities::IsNegative(double value)
+    {
+        uint64 nCompare = ToSpecial(value);
+        return nCompare & 0x8000000000000000ull;
+    }
+
     NUMBER_UTIL_INLINE bool NumberUtilities::IsSpecial(double value, uint64 nSpecial)
     {
         // Perform a bitwise comparison using uint64 instead of a double comparison, since that
diff --git a/lib/Common/Common/NumberUtilitiesBase.h b/lib/Common/Common/NumberUtilitiesBase.h
@@ -12,8 +12,9 @@ namespace Js
     class NumberConstantsBase
     {
     public:
-        static const UINT64 k_Nan = 0xFFF8000000000000ull;
+        static const UINT64 k_Nan = 0x7FF8000000000000ull;
         static const UINT32 k_Nan32 = 0x7FC00000ul;
+        static const UINT64 k_NegativeNan = 0xFFF8000000000000ull;
     };
 
     class NumberUtilitiesBase
diff --git a/lib/Runtime/Base/EtwTrace.cpp b/lib/Runtime/Base/EtwTrace.cpp
@@ -382,7 +382,7 @@ size_t EtwTrace::GetSimpleJitFunctionName(
     const size_t suffixCharLength = _countof(_u("Simple")) - 1;
 
     const char16 *const functionName = GetFunctionName(body);
-    const size_t functionNameCharLength = wcslen(functionName);
+    const size_t functionNameCharLength = body->GetDisplayNameLength();
     const size_t requiredCharCapacity = functionNameCharLength + suffixCharLength + 1;
     if(requiredCharCapacity > nameCharCapacity || name == NULL)
     {
diff --git a/lib/Runtime/Language/DynamicProfileInfo.cpp b/lib/Runtime/Language/DynamicProfileInfo.cpp
@@ -1172,8 +1172,13 @@ namespace Js
         if (functionBody->GetCallSiteToCallApplyCallSiteArray())
         {
             Js::ProfileId callApplyCallSiteId = functionBody->GetCallSiteToCallApplyCallSiteArray()[callSiteId];
+            if (callApplyCallSiteId == Js::Constants::NoProfileId)
+            {
+                return nullptr;
+            } 
+            
             Assert(callApplyCallSiteId < functionBody->GetProfiledCallApplyCallSiteCount());
-
+            
             if (callApplyTargetInfo[callApplyCallSiteId].isPolymorphic)
             {
                 return nullptr;
diff --git a/lib/Runtime/Language/InterpreterStackFrame.cpp b/lib/Runtime/Language/InterpreterStackFrame.cpp
@@ -3909,11 +3909,14 @@ namespace Js
                 if (callSiteToCallApplyCallSiteMap)
                 {
                     Js::ProfileId callApplyCallSiteId = callSiteToCallApplyCallSiteMap[profileId];
-                    Assert(callApplyCallSiteId < functionBody->GetProfiledCallApplyCallSiteCount());
-                    if (callApplyCallSiteId != Js::Constants::NoProfileId)
+                    if (callApplyCallSiteId < functionBody->GetProfiledCallApplyCallSiteCount())
                     {
                         dynamicProfileInfo->RecordCallApplyTargetInfo(functionBody, callApplyCallSiteId, targetFunction->GetFunctionInfo(), targetFunction);
                     }
+                    else
+                    {
+                        Assert(callApplyCallSiteId == Js::Constants::NoProfileId);
+                    }
                 }
             }
         }
diff --git a/lib/Runtime/Language/JavascriptConversion.inl b/lib/Runtime/Language/JavascriptConversion.inl
@@ -297,10 +297,11 @@ namespace Js {
 #if FLOATVAR
            if (typeId == TypeIds_Number)
            {
-               // NaN could have sign bit set, but that isn't observable so canonicalize to positive NaN
                double numberValue = JavascriptNumber::GetValue(value);
                return JavascriptNumber::IsNan(numberValue)
-                   ? JavascriptNumber::ToVar(JavascriptNumber::NaN)
+                   ? JavascriptNumber::IsNegative(numberValue)
+                        ? JavascriptNumber::ToVar(JavascriptNumber::NegativeNaN)
+                        : JavascriptNumber::ToVar(JavascriptNumber::NaN)
                    : value;
            }
 #else
diff --git a/lib/Runtime/Library/JavascriptExternalFunction.cpp b/lib/Runtime/Library/JavascriptExternalFunction.cpp
@@ -58,7 +58,7 @@ namespace Js
 
     bool __cdecl JavascriptExternalFunction::DeferredLengthInitializer(DynamicObject * instance, DeferredTypeHandlerBase * typeHandler, DeferredInitializeMode mode)
     {
-        Js::JavascriptLibrary::InitializeFunction<true, true, true>(instance, typeHandler, mode);
+        Js::JavascriptLibrary::InitializeFunction<true, true, true, true>(instance, typeHandler, mode);
 
         JavascriptExternalFunction* object = static_cast<JavascriptExternalFunction*>(instance);
 
diff --git a/lib/Runtime/Library/JavascriptFunction.cpp b/lib/Runtime/Library/JavascriptFunction.cpp
@@ -866,7 +866,11 @@ using namespace Js;
         }
         else
         {
-            resultObject = JavascriptOperators::NewScObjectNoCtor(v, scriptContext);
+            BEGIN_SAFE_REENTRANT_CALL(scriptContext->GetThreadContext())
+            {
+                resultObject = JavascriptOperators::NewScObjectNoCtor(v, scriptContext);
+            }
+            END_SAFE_REENTRANT_CALL
         }
 
         // JavascriptOperators::NewScObjectNoCtor should have thrown if 'v' is not a constructor
diff --git a/lib/Runtime/Library/JavascriptLibrary.cpp b/lib/Runtime/Library/JavascriptLibrary.cpp
@@ -594,7 +594,7 @@ namespace Js
             Js::DeferredTypeHandler<Js::JavascriptExternalFunction::DeferredConstructorInitializer>::GetDefaultInstance(), true, true);
 
         boundFunctionType = DynamicType::New(scriptContext, TypeIds_Function, functionPrototype, BoundFunction::NewInstance,
-            GetDeferredFunctionTypeHandler(), true, true);
+            GetDeferredFunctionWithLengthUnsetTypeHandler(), true, true);
         crossSiteDeferredFunctionType = CreateDeferredFunctionTypeNoProfileThunk(
             scriptContext->CurrentCrossSiteThunk, true /*isShared*/);
         crossSiteDeferredPrototypeFunctionType = CreateDeferredPrototypeFunctionTypeNoProfileThunk(
@@ -784,7 +784,7 @@ namespace Js
         JavascriptArray::EnsureCalculationOfAllocationBuckets<Js::JavascriptArray>();
     }
 
-    template<bool addPrototype, bool addName, bool useLengthType>
+    template<bool addPrototype, bool addName, bool useLengthType, bool addLength>
     bool JavascriptLibrary::InitializeFunction(DynamicObject *instance, DeferredTypeHandlerBase * typeHandler, DeferredInitializeMode mode)
     {
         JavascriptFunction * function = VarTo<JavascriptFunction>(instance);
@@ -833,7 +833,8 @@ namespace Js
         {
             ParseableFunctionInfo * funcInfo = scriptFunction->GetFunctionProxy()->EnsureDeserialized();
 
-            if (useLengthType)
+            CompileAssert(!addLength || useLengthType);
+            if (addLength)
             {
                 function->SetPropertyWithAttributes(PropertyIds::length, TaggedInt::ToVarUnchecked(funcInfo->GetReportedInParamsCount() - 1), PropertyConfigurable, nullptr, PropertyOperation_None, SideEffects_None);
             }
@@ -914,10 +915,10 @@ namespace Js
         }
     };
 
-    template<bool isNameAvailable, bool isPrototypeAvailable, bool isLengthAvailable>
+    template<bool isNameAvailable, bool isPrototypeAvailable, bool isLengthAvailable, bool addLength>
     DynamicTypeHandler * JavascriptLibrary::GetDeferredFunctionTypeHandlerBase()
     {
-        return DeferredTypeHandler<InitializeFunction<isPrototypeAvailable, isNameAvailable, isLengthAvailable>, InitializeFunctionDeferredTypeHandlerFilter<isNameAvailable, isPrototypeAvailable, isLengthAvailable>>::GetDefaultInstance();
+        return DeferredTypeHandler<InitializeFunction<isPrototypeAvailable, isNameAvailable, isLengthAvailable, addLength>, InitializeFunctionDeferredTypeHandlerFilter<isNameAvailable, isPrototypeAvailable, isLengthAvailable>>::GetDefaultInstance();
     }
 
     template<bool isNameAvailable, bool isPrototypeAvailable>
@@ -993,6 +994,11 @@ namespace Js
         return GetDeferredFunctionTypeHandlerBase</*isNameAvailable*/ true, /*isPrototypeAvailable*/ false, /* isLengthAvailable */ true>();
     }
 
+    DynamicTypeHandler * JavascriptLibrary::GetDeferredFunctionWithLengthUnsetTypeHandler()
+    {
+        return GetDeferredFunctionTypeHandlerBase</*isNameAvailable*/ true, /*isPrototypeAvailable*/ false, /* isLengthAvailable */ true, /* addLength */ false>();
+    }
+
     DynamicTypeHandler * JavascriptLibrary::ScriptFunctionTypeHandler(bool noPrototypeProperty, bool isAnonymousFunction)
     {
         DynamicTypeHandler * scriptFunctionTypeHandler = nullptr;
diff --git a/lib/Runtime/Library/JavascriptLibrary.h b/lib/Runtime/Library/JavascriptLibrary.h
@@ -902,11 +902,12 @@ namespace Js
 
         DynamicTypeHandler * GetDeferredFunctionTypeHandler();
         DynamicTypeHandler * GetDeferredFunctionWithLengthTypeHandler();
+        DynamicTypeHandler* GetDeferredFunctionWithLengthUnsetTypeHandler();
         DynamicTypeHandler * GetDeferredPrototypeFunctionWithNameAndLengthTypeHandler();
         DynamicTypeHandler * ScriptFunctionTypeHandler(bool noPrototypeProperty, bool isAnonymousFunction);
         DynamicTypeHandler * GetDeferredAnonymousFunctionWithLengthTypeHandler();
         DynamicTypeHandler * GetDeferredAnonymousFunctionTypeHandler();
-        template<bool isNameAvailable, bool isPrototypeAvailable = true, bool isLengthAvailable = false>
+        template<bool isNameAvailable, bool isPrototypeAvailable = true, bool isLengthAvailable = false, bool addLength = isLengthAvailable>
         static DynamicTypeHandler * GetDeferredFunctionTypeHandlerBase();
         template<bool isNameAvailable, bool isPrototypeAvailable = true>
         static DynamicTypeHandler * GetDeferredGeneratorFunctionTypeHandlerBase();
@@ -1236,7 +1237,7 @@ namespace Js
 #endif
 
     public:
-        template<bool addPrototype, bool addName, bool useLengthType>
+        template<bool addPrototype, bool addName, bool useLengthType, bool addLength>
         static bool __cdecl InitializeFunction(DynamicObject* function, DeferredTypeHandlerBase * typeHandler, DeferredInitializeMode mode);
         virtual void Finalize(bool isShutdown) override;
 
diff --git a/lib/Runtime/Library/JavascriptNumber.cpp b/lib/Runtime/Library/JavascriptNumber.cpp
@@ -23,7 +23,7 @@ namespace Js
 #if FLOATVAR
         if (IsNan(value))
         {
-            value = JavascriptNumber::NaN;
+            value = IsNegative(value) ? JavascriptNumber::NegativeNaN : JavascriptNumber::NaN;
         }
 #endif
         return JavascriptNumber::NewInlined(value, scriptContext);
diff --git a/lib/Runtime/Library/JavascriptNumber.h b/lib/Runtime/Library/JavascriptNumber.h
@@ -55,6 +55,7 @@ namespace Js
         static bool TryToVarFastWithCheck(double value, Var* result);
 
         inline static BOOL IsNan(double value) { return NumberUtilities::IsNan(value); }
+        inline static BOOL IsNegative(double value) { return NumberUtilities::IsNegative(value); }
         static bool IsZero(double value);
         static BOOL IsNegZero(double value);
         static bool IsPosInf(double value);
diff --git a/lib/Runtime/Library/JavascriptNumber.inl b/lib/Runtime/Library/JavascriptNumber.inl
@@ -14,7 +14,7 @@ namespace Js
 #endif
     )
     {
-        AssertMsg(!IsNan(value) || ToSpecial(value) == k_Nan || ToSpecial(value) == 0x7FF8000000000000ull, "We should only produce a NaN with this value");
+        AssertMsg(!IsNan(value) || ToSpecial(value) == k_NegativeNan || ToSpecial(value) == 0x7FF8000000000000ull, "We should only produce a NaN with this value");
         SetSpecial(ToSpecial(value) ^ FloatTag_Value);
     }
 #else
@@ -96,7 +96,7 @@ namespace Js
 #if FLOATVAR
         if (IsNan(value))
         {
-            value = JavascriptNumber::NaN;
+            value = IsNegative(value) ? JavascriptNumber::NegativeNaN : JavascriptNumber::NaN;
         }
 
         *result = JavascriptNumber::ToVar(value);
@@ -128,7 +128,7 @@ namespace Js
     {
         if (IsNan(value))
         {
-            value = JavascriptNumber::NaN;
+            value = IsNegative(value) ? JavascriptNumber::NegativeNaN : JavascriptNumber::NaN;
         }
         return ToVar(value);
     }
@@ -148,7 +148,7 @@ namespace Js
     inline Var JavascriptNumber::ToVar(double value)
     {
         uint64 val = *(uint64*)&value;
-        AssertMsg(!IsNan(value) || ToSpecial(value) == k_Nan || ToSpecial(value) == 0x7FF8000000000000ull, "We should only produce a NaN with this value");
+        AssertMsg(!IsNan(value) || ToSpecial(value) == k_NegativeNan || ToSpecial(value) == 0x7FF8000000000000ull, "We should only produce a NaN with this value");
         return reinterpret_cast<Var>(val ^ FloatTag_Value);
     }
 
diff --git a/lib/Runtime/Library/JavascriptProxy.cpp b/lib/Runtime/Library/JavascriptProxy.cpp
@@ -2143,7 +2143,11 @@ namespace Js
                 // args.Values[0] will be null in the case where NewTarget is initially provided by proxy.
                 if (!isCtorSuperCall || !args.Values[0])
                 {
-                    newThisObject = JavascriptOperators::NewScObjectNoCtor(targetObj, scriptContext);
+                    BEGIN_SAFE_REENTRANT_CALL(scriptContext->GetThreadContext())
+                    {
+                        newThisObject = JavascriptOperators::NewScObjectNoCtor(targetObj, scriptContext);
+                    }
+                    END_SAFE_REENTRANT_CALL
                     args.Values[0] = newThisObject;
                 }
                 else
diff --git a/lib/WasmReader/WasmByteCodeGenerator.cpp b/lib/WasmReader/WasmByteCodeGenerator.cpp
@@ -1554,7 +1554,8 @@ EmitInfo WasmBytecodeGenerator::EmitV8X16Shuffle()
     EmitInfo arg2Info = PopEvalStack(WasmTypes::V128);
     EmitInfo arg1Info = PopEvalStack(WasmTypes::V128);
 
-    // FIXME Release arg2Info and arg1Info
+    ReleaseLocation(&arg2Info);
+    ReleaseLocation(&arg1Info);
 
     Js::RegSlot resultReg = GetRegisterSpace(WasmTypes::V128)->AcquireTmpRegister();
     EmitInfo resultInfo(resultReg, WasmTypes::V128);
diff --git a/lib/wabt/wabt.vcxproj b/lib/wabt/wabt.vcxproj
@@ -102,7 +102,7 @@
     <ClInclude Include="src\circular-array.h" />
     <ClInclude Include="src\color.h" />
     <ClInclude Include="src\common.h" />
-    <ClInclude Include="src\error-formater.h" />
+    <ClInclude Include="src\error-formatter.h" />
     <ClInclude Include="src\error.h" />
     <ClInclude Include="src\expr-visitor.h" />
     <ClInclude Include="src\feature.def" />
@@ -140,4 +140,4 @@
   </ItemGroup>
   <Import Project="$(BuildConfigPropsPath)Chakra.Build.targets" Condition="exists('$(BuildConfigPropsPath)Chakra.Build.targets')" />
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-</Project>
+</Project>
diff --git a/test/Bugs/randombug.baseline b/test/Bugs/randombug.baseline
diff --git a/test/DebuggerCommon/ES6_intl_simple_attach.js.dbg.baseline b/test/DebuggerCommon/ES6_intl_simple_attach.js.dbg.baseline
diff --git a/test/Intl/rlexe.xml b/test/Intl/rlexe.xml
diff --git a/test/Number/NegativeNaN.baseline b/test/Number/NegativeNaN.baseline
diff --git a/test/Number/NegativeNaN.js b/test/Number/NegativeNaN.js
diff --git a/test/Number/rlexe.xml b/test/Number/rlexe.xml
diff --git a/test/inlining/callTarget.js b/test/inlining/callTarget.js
diff --git a/test/runcitests.cmd b/test/runcitests.cmd
diff --git a/test/typedarray/nan.baseline b/test/typedarray/nan.baseline
diff --git a/test/typedarray/nan.x64.baseline b/test/typedarray/nan.x64.baseline

Original file line number	Diff line number	Diff line change
`@@ -4857,6 +4857,7 @@ IRBuilder::BuildElementC2(Js::OpCode newOpcode, uint32 offset, Js::RegSlot insta`
`4857`	`4857`	`regOpnd = this->BuildDstOpnd(regSlot);`
`4858`	`4858`
`4859`	`4859`	`instr = IR::ProfiledInstr::New(newOpcode, regOpnd, fieldSymOpnd, value2Opnd, m_func);`
	`4860`	`+ instr->AsProfiledInstr()->u.FldInfo() = *(m_func->GetReadOnlyProfileInfo()->GetFldInfo(propertyIdIndex));`
`4860`	`4861`	`this->AddInstr(instr, offset);`
`4861`	`4862`	`}`
`4862`	`4863`	`break;`
`@@ -4878,7 +4879,7 @@ IRBuilder::BuildElementC2(Js::OpCode newOpcode, uint32 offset, Js::RegSlot insta`
`4878`	`4879`	`value2Opnd = this->BuildSrcOpnd(value2Slot);`
`4879`	`4880`
`4880`	`4881`	`instr = IR::ProfiledInstr::New(newOpcode, fieldSymOpnd, regOpnd, value2Opnd, m_func);`
`4881`		`-`
	`4882`	`+ instr->AsProfiledInstr()->u.FldInfo() = *(m_func->GetReadOnlyProfileInfo()->GetFldInfo(propertyIdIndex));`
`4882`	`4883`	`this->AddInstr(instr, offset);`
`4883`	`4884`	`break;`
`4884`	`4885`	`}`
Original file line number	Diff line number	Diff line change
`@@ -382,7 +382,7 @@ size_t EtwTrace::GetSimpleJitFunctionName(`
`382`	`382`	`const size_t suffixCharLength = _countof(_u("Simple")) - 1;`
`383`	`383`
`384`	`384`	`const char16 *const functionName = GetFunctionName(body);`
`385`		`- const size_t functionNameCharLength = wcslen(functionName);`
	`385`	`+ const size_t functionNameCharLength = body->GetDisplayNameLength();`
`386`	`386`	`const size_t requiredCharCapacity = functionNameCharLength + suffixCharLength + 1;`
`387`	`387`	`if(requiredCharCapacity > nameCharCapacity \|\| name == NULL)`
`388`	`388`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3909,11 +3909,14 @@ namespace Js`
`3909`	`3909`	`if (callSiteToCallApplyCallSiteMap)`
`3910`	`3910`	`{`
`3911`	`3911`	`Js::ProfileId callApplyCallSiteId = callSiteToCallApplyCallSiteMap[profileId];`
`3912`		`- Assert(callApplyCallSiteId < functionBody->GetProfiledCallApplyCallSiteCount());`
`3913`		`- if (callApplyCallSiteId != Js::Constants::NoProfileId)`
	`3912`	`+ if (callApplyCallSiteId < functionBody->GetProfiledCallApplyCallSiteCount())`
`3914`	`3913`	`{`
`3915`	`3914`	`dynamicProfileInfo->RecordCallApplyTargetInfo(functionBody, callApplyCallSiteId, targetFunction->GetFunctionInfo(), targetFunction);`
`3916`	`3915`	`}`
	`3916`	`+ else`
	`3917`	`+ {`
	`3918`	`+ Assert(callApplyCallSiteId == Js::Constants::NoProfileId);`
	`3919`	`+ }`
`3917`	`3920`	`}`
`3918`	`3921`	`}`
`3919`	`3922`	`}`