From 496e7fb6163547be36cbc4da115128af14c7378a Mon Sep 17 00:00:00 2001 From: Matt Gardner Date: Mon, 26 Feb 2018 15:41:43 -0800 Subject: [PATCH 1/2] Array profile data usage optimzation This commit changes usage of array profile data in an attempt to better handle certain cases (such as inlined common functions) by using the most specialized (int>float>var) array type profiled when merging profile data, unless the instruction has previous bailed out on NotNativeArray, in which case it will use the least specialized type to avoid infinite bailouts. This also fixes an infinite bailout in Ares-6 ML benchmark which was introduced by #3169 --- lib/Backend/BailOut.cpp | 5 +++ lib/Backend/GlobOpt.cpp | 43 ++++++++++++------- lib/Backend/IRBuilder.cpp | 6 ++- lib/Backend/JITTimeProfileInfo.cpp | 1 + lib/Backend/Lower.cpp | 8 +++- lib/JITIDL/JITTypes.h | 2 + lib/Runtime/Language/DynamicProfileInfo.h | 32 +++++++++++++- .../Language/InterpreterStackFrame.cpp | 16 +++++-- lib/Runtime/Language/InterpreterStackFrame.h | 1 + lib/Runtime/Language/ProfilingHelpers.cpp | 18 ++++++-- lib/Runtime/Language/ProfilingHelpers.h | 4 +- 11 files changed, 107 insertions(+), 29 deletions(-) diff --git a/lib/Backend/BailOut.cpp b/lib/Backend/BailOut.cpp index 02d28476619..1e19d92912b 100644 --- a/lib/Backend/BailOut.cpp +++ b/lib/Backend/BailOut.cpp @@ -1464,6 +1464,11 @@ BailOutRecord::BailOutHelper(Js::JavascriptCallStackLayout * layout, Js::ScriptF { newInstance->OrFlags(Js::InterpreterStackFrameFlags_ProcessingBailOutOnArrayAccessHelperCall); } + else if (bailOutKind == IR::BailOutOnNotNativeArray) + { + newInstance->OrFlags(Js::InterpreterStackFrameFlags_ProcessingBailOutOnArraySpecialization); + } + if (isInlinee) { newInstance->OrFlags(Js::InterpreterStackFrameFlags_FromBailOutInInlinee); diff --git a/lib/Backend/GlobOpt.cpp b/lib/Backend/GlobOpt.cpp index ecf11d878cf..e77bb092e0d 100644 --- a/lib/Backend/GlobOpt.cpp +++ b/lib/Backend/GlobOpt.cpp @@ -3406,20 +3406,22 @@ GlobOpt::OptSrc(IR::Opnd *opnd, IR::Instr * *pInstr, Value **indirIndexValRef, I { ValueType valueType(val->GetValueInfo()->Type()); - // This block uses local profiling data to optimize the case of a native array being passed to a function that fills it with other types. When the function is inlined - // into different call paths which use different types this can cause a perf hit by performing unnecessary array conversions, so only perform this optimization when - // the function is not inlined. - if (valueType.IsLikelyNativeArray() && !valueType.IsObject() && instr->IsProfiledInstr() && !instr->m_func->IsInlined()) + // This block uses per-instruction profile information on array types to optimize using the best available profile + // information and to prevent infinite bailouts by ensuring array type information is updated on bailouts. + if (valueType.IsLikelyArray() && !valueType.IsObject() && instr->IsProfiledInstr()) { // See if we have profile data for the array type IR::ProfiledInstr *const profiledInstr = instr->AsProfiledInstr(); ValueType profiledArrayType; + + bool useAggressiveSpecialization = true; switch(instr->m_opcode) { case Js::OpCode::LdElemI_A: if(instr->GetSrc1()->IsIndirOpnd() && opnd == instr->GetSrc1()->AsIndirOpnd()->GetBaseOpnd()) { profiledArrayType = profiledInstr->u.ldElemInfo->GetArrayType(); + useAggressiveSpecialization = !profiledInstr->u.ldElemInfo->DisableAggressiveSpecialization(); } break; @@ -3429,6 +3431,7 @@ GlobOpt::OptSrc(IR::Opnd *opnd, IR::Instr * *pInstr, Value **indirIndexValRef, I if(instr->GetDst()->IsIndirOpnd() && opnd == instr->GetDst()->AsIndirOpnd()->GetBaseOpnd()) { profiledArrayType = profiledInstr->u.stElemInfo->GetArrayType(); + useAggressiveSpecialization = !profiledInstr->u.stElemInfo->DisableAggressiveSpecialization(); } break; @@ -3436,16 +3439,28 @@ GlobOpt::OptSrc(IR::Opnd *opnd, IR::Instr * *pInstr, Value **indirIndexValRef, I if(instr->GetSrc1()->IsRegOpnd() && opnd == instr->GetSrc1()) { profiledArrayType = profiledInstr->u.LdLenInfo().GetArrayType(); + useAggressiveSpecialization = !profiledInstr->u.LdLenInfo().DisableAggressiveSpecialization(); } break; } - if(profiledArrayType.IsLikelyObject() && - profiledArrayType.GetObjectType() == valueType.GetObjectType() && - (profiledArrayType.HasVarElements() || (valueType.HasIntElements() && profiledArrayType.HasFloatElements()))) + + if (profiledArrayType.IsLikelyObject() && profiledArrayType.GetObjectType() == valueType.GetObjectType()) { - // Merge array type we pulled from profile with type propagated by dataflow. - valueType = valueType.Merge(profiledArrayType).SetHasNoMissingValues(valueType.HasNoMissingValues()); - ChangeValueType(this->currentBlock, CurrentBlockData()->FindValue(opnd->AsRegOpnd()->m_sym), valueType, false); + // Ideally we want to use the most specialized type seen by this path, but when that causes bailouts use the least specialized type instead. + if (useAggressiveSpecialization && !valueType.IsLikelyNativeIntArray() && + (profiledArrayType.HasIntElements() || (valueType.HasVarElements() && profiledArrayType.HasFloatElements()))) + { + // use the more specialized type profiled by the instruction. + valueType = profiledArrayType.SetHasNoMissingValues(valueType.HasNoMissingValues()); + ChangeValueType(this->currentBlock, CurrentBlockData()->FindValue(opnd->AsRegOpnd()->m_sym), valueType, false); + } + else if (!useAggressiveSpecialization && valueType.IsLikelyNativeArray() && + (profiledArrayType.HasVarElements() || (valueType.HasIntElements() && profiledArrayType.HasFloatElements()))) + { + // Merge array type we pulled from profile with type propagated by dataflow. + valueType = valueType.Merge(profiledArrayType).SetHasNoMissingValues(valueType.HasNoMissingValues()); + ChangeValueType(this->currentBlock, CurrentBlockData()->FindValue(opnd->AsRegOpnd()->m_sym), valueType, false); + } } } @@ -13391,11 +13406,9 @@ GlobOpt::OptArraySrc(IR::Instr * *const instrRef) if (!baseValueInLoopLandingPad->GetValueInfo()->CanMergeToSpecificObjectType()) { ValueType landingPadValueType = baseValueInLoopLandingPad->GetValueInfo()->Type(); - Assert(landingPadValueType.IsSimilar(baseValueType) || - ( - landingPadValueType.IsLikelyNativeArray() && - landingPadValueType.Merge(baseValueType).IsSimilar(baseValueType) - ) + Assert(landingPadValueType.IsSimilar(baseValueType) + || (landingPadValueType.IsLikelyNativeArray() && landingPadValueType.Merge(baseValueType).IsSimilar(baseValueType)) + || (baseValueType.IsLikelyNativeArray() && baseValueType.Merge(landingPadValueType).IsSimilar(landingPadValueType)) ); } #endif diff --git a/lib/Backend/IRBuilder.cpp b/lib/Backend/IRBuilder.cpp index ab83ad9ab23..7671b8d8c52 100644 --- a/lib/Backend/IRBuilder.cpp +++ b/lib/Backend/IRBuilder.cpp @@ -4482,9 +4482,10 @@ IRBuilder::BuildProfiledElementCP(Js::OpCode newOpcode, uint32 offset, Js::RegSl ValueType arrayType = ValueType::Uninitialized; + const Js::LdLenInfo * ldLenInfo = nullptr; if (m_func->HasProfileInfo()) { - const Js::LdLenInfo * ldLenInfo = m_func->GetReadOnlyProfileInfo()->GetLdLenInfo(profileId); + ldLenInfo = m_func->GetReadOnlyProfileInfo()->GetLdLenInfo(profileId); arrayType = (ldLenInfo->GetArrayType()); if (arrayType.IsLikelyNativeArray() && ( @@ -4522,7 +4523,8 @@ IRBuilder::BuildProfiledElementCP(Js::OpCode newOpcode, uint32 offset, Js::RegSl IR::ProfiledInstr * profiledInstr = IR::ProfiledInstr::New(newOpcode, dstOpnd, fieldSymOpnd, m_func); instr = profiledInstr; profiledInstr->u.FldInfo() = *(m_func->GetReadOnlyProfileInfo()->GetFldInfo(inlineCacheIndex)); - profiledInstr->u.LdLenInfo().GetArrayType() = arrayType; + profiledInstr->u.LdLenInfo() = *ldLenInfo; + profiledInstr->u.LdLenInfo().arrayType = arrayType; wasNotProfiled = !profiledInstr->u.FldInfo().WasLdFldProfiled(); dstOpnd->SetValueType(instr->AsProfiledInstr()->u.FldInfo().valueType); #if ENABLE_DEBUG_CONFIG_OPTIONS diff --git a/lib/Backend/JITTimeProfileInfo.cpp b/lib/Backend/JITTimeProfileInfo.cpp index f8da4005056..fa29543cd61 100644 --- a/lib/Backend/JITTimeProfileInfo.cpp +++ b/lib/Backend/JITTimeProfileInfo.cpp @@ -25,6 +25,7 @@ JITTimeProfileInfo::InitializeJITProfileData( return; } + CompileAssert(sizeof(LdLenIDL) == sizeof(Js::LdLenInfo)); CompileAssert(sizeof(LdElemIDL) == sizeof(Js::LdElemInfo)); CompileAssert(sizeof(StElemIDL) == sizeof(Js::StElemInfo)); diff --git a/lib/Backend/Lower.cpp b/lib/Backend/Lower.cpp index d4acd264a4b..e990b60b3bd 100644 --- a/lib/Backend/Lower.cpp +++ b/lib/Backend/Lower.cpp @@ -8694,11 +8694,13 @@ void Lowerer::LowerProfiledLdElemI(IR::JitProfilingInstr *const instr) const Var varIndex, FunctionBody *const functionBody, const ProfileId profileId, - bool didArrayAccessHelperCall) + bool didArrayAccessHelperCall, + bool bailedOutOnArraySpecialization) */ Func *const func = instr->m_func; + m_lowererMD.LoadHelperArgument(instr, IR::IntConstOpnd::New(false, TyInt8, func)); m_lowererMD.LoadHelperArgument(instr, IR::IntConstOpnd::New(false, TyInt8, func)); m_lowererMD.LoadHelperArgument(instr, IR::Opnd::CreateProfileIdOpnd(instr->profileId, func)); m_lowererMD.LoadHelperArgument(instr, CreateFunctionBodyOpnd(func)); @@ -8729,7 +8731,8 @@ void Lowerer::LowerProfiledStElemI(IR::JitProfilingInstr *const instr, const Js: FunctionBody *const functionBody, const ProfileId profileId, const PropertyOperationFlags flags, - bool didArrayAccessHelperCall) + bool didArrayAccessHelperCall, + bool bailedOutOnArraySpecialization) */ Func *const func = instr->m_func; @@ -8743,6 +8746,7 @@ void Lowerer::LowerProfiledStElemI(IR::JitProfilingInstr *const instr, const Js: { helper = IR::HelperProfiledStElem; m_lowererMD.LoadHelperArgument(instr, IR::IntConstOpnd::New(false, TyInt8, func)); + m_lowererMD.LoadHelperArgument(instr, IR::IntConstOpnd::New(false, TyInt8, func)); m_lowererMD.LoadHelperArgument(instr, IR::IntConstOpnd::New(flags, TyInt32, func, true)); } m_lowererMD.LoadHelperArgument(instr, IR::Opnd::CreateProfileIdOpnd(instr->profileId, func)); diff --git a/lib/JITIDL/JITTypes.h b/lib/JITIDL/JITTypes.h index 84eaf85fb8c..55ac2f0cc24 100644 --- a/lib/JITIDL/JITTypes.h +++ b/lib/JITIDL/JITTypes.h @@ -243,6 +243,8 @@ typedef struct ArrayCallSiteIDL typedef struct LdLenIDL { unsigned short arrayType; + byte bits; + IDL_PAD1(0) } LdLenIDL; typedef struct LdElemIDL diff --git a/lib/Runtime/Language/DynamicProfileInfo.h b/lib/Runtime/Language/DynamicProfileInfo.h index 2e3a3b8056e..4e20bee08eb 100644 --- a/lib/Runtime/Language/DynamicProfileInfo.h +++ b/lib/Runtime/Language/DynamicProfileInfo.h @@ -179,10 +179,23 @@ namespace Js struct LdLenInfo { - typedef struct { ValueType::TSize f1; } TSize; + typedef struct { ValueType::TSize f1; byte f2; } TSize; ValueType arrayType; + union + { + struct + { + bool disableAggressiveSpecialization : 1; + }; + byte bits; + }; + + LdLenInfo() : bits(0) + { + } + void Merge(const LdLenInfo & other) { arrayType = arrayType.Merge(other.arrayType); @@ -192,6 +205,11 @@ namespace Js { return arrayType; } + + bool DisableAggressiveSpecialization() const + { + return disableAggressiveSpecialization; + } }; CompileAssert(sizeof(LdLenInfo::TSize) == sizeof(LdLenInfo)); @@ -206,6 +224,7 @@ namespace Js { bool wasProfiled : 1; bool neededHelperCall : 1; + bool disableAggressiveSpecialization : 1; }; byte bits; }; @@ -241,6 +260,11 @@ namespace Js { return neededHelperCall; } + + bool DisableAggressiveSpecialization() const + { + return disableAggressiveSpecialization; + } }; struct StElemInfo @@ -257,6 +281,7 @@ namespace Js bool neededHelperCall : 1; bool storedOutsideHeadSegmentBounds : 1; bool storedOutsideArrayBounds : 1; + bool disableAggressiveSpecialization : 1; }; byte bits; }; @@ -306,6 +331,11 @@ namespace Js { return storedOutsideArrayBounds; } + + bool DisableAggressiveSpecialization() const + { + return disableAggressiveSpecialization; + } }; struct ArrayCallSiteInfo diff --git a/lib/Runtime/Language/InterpreterStackFrame.cpp b/lib/Runtime/Language/InterpreterStackFrame.cpp index 6a67e681c45..150de81e91f 100644 --- a/lib/Runtime/Language/InterpreterStackFrame.cpp +++ b/lib/Runtime/Language/InterpreterStackFrame.cpp @@ -4977,9 +4977,10 @@ namespace Js GetReg(playout->Element), m_functionBody, playout->profileId, - this->TestFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArrayAccessHelperCall))); + this->TestFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArrayAccessHelperCall), + this->TestFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArraySpecialization))); - this->ClearFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArrayAccessHelperCall); + this->ClearFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArrayAccessHelperCall | InterpreterStackFrameFlags_ProcessingBailOutOnArraySpecialization); threadContext->CheckAndResetImplicitCallAccessorFlag(); threadContext->AddImplicitCallFlags(savedImplicitCallFlags); @@ -5077,9 +5078,10 @@ namespace Js m_functionBody, playout->profileId, flags, - this->TestFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArrayAccessHelperCall)); + this->TestFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArrayAccessHelperCall), + this->TestFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArraySpecialization)); - this->ClearFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArrayAccessHelperCall); + this->ClearFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArrayAccessHelperCall | InterpreterStackFrameFlags_ProcessingBailOutOnArraySpecialization); threadContext->CheckAndResetImplicitCallAccessorFlag(); threadContext->AddImplicitCallFlags(savedImplicitCallFlags); @@ -8412,6 +8414,12 @@ const byte * InterpreterStackFrame::OP_ProfiledLoopBodyStart(uint loopId) ldLenInfo.arrayType = ValueType::Uninitialized.Merge(instance); profileData->RecordLengthLoad(functionBody, playout->profileId, ldLenInfo); + if (this->TestFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArraySpecialization)) + { + ldLenInfo.disableAggressiveSpecialization = true; + this->ClearFlags(InterpreterStackFrameFlags_ProcessingBailOutOnArraySpecialization); + } + ThreadContext* threadContext = this->GetScriptContext()->GetThreadContext(); ImplicitCallFlags savedImplicitCallFlags = threadContext->GetImplicitCallFlags(); threadContext->ClearImplicitCallFlags(); diff --git a/lib/Runtime/Language/InterpreterStackFrame.h b/lib/Runtime/Language/InterpreterStackFrame.h index 47d6e51ef15..b57720c5027 100644 --- a/lib/Runtime/Language/InterpreterStackFrame.h +++ b/lib/Runtime/Language/InterpreterStackFrame.h @@ -28,6 +28,7 @@ namespace Js InterpreterStackFrameFlags_ProcessingBailOutOnArrayAccessHelperCall = 0x10, InterpreterStackFrameFlags_ProcessingBailOutFromEHCode = 0x20, InterpreterStackFrameFlags_FromBailOutInInlinee = 0x40, + InterpreterStackFrameFlags_ProcessingBailOutOnArraySpecialization = 0x80, InterpreterStackFrameFlags_All = 0xFFFF, }; diff --git a/lib/Runtime/Language/ProfilingHelpers.cpp b/lib/Runtime/Language/ProfilingHelpers.cpp index 46e991408ce..902fb637786 100644 --- a/lib/Runtime/Language/ProfilingHelpers.cpp +++ b/lib/Runtime/Language/ProfilingHelpers.cpp @@ -12,7 +12,8 @@ namespace Js const Var varIndex, FunctionBody *const functionBody, const ProfileId profileId, - bool didArrayAccessHelperCall) + bool didArrayAccessHelperCall, + bool bailedOutOnArraySpecialization) { Assert(base); Assert(varIndex); @@ -21,6 +22,11 @@ namespace Js LdElemInfo ldElemInfo; + if (bailedOutOnArraySpecialization) + { + ldElemInfo.disableAggressiveSpecialization = true; + } + // Only enable fast path if the javascript array is not cross site #if ENABLE_COPYONACCESS_ARRAY JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray(base); @@ -197,7 +203,7 @@ namespace Js FunctionBody *const functionBody, const ProfileId profileId) { - ProfiledStElem(base, varIndex, value, functionBody, profileId, PropertyOperation_None, false); + ProfiledStElem(base, varIndex, value, functionBody, profileId, PropertyOperation_None, false, false); } void ProfilingHelpers::ProfiledStElem( @@ -207,7 +213,8 @@ namespace Js FunctionBody *const functionBody, const ProfileId profileId, const PropertyOperationFlags flags, - bool didArrayAccessHelperCall) + bool didArrayAccessHelperCall, + bool bailedOutOnArraySpecialization) { Assert(base); Assert(varIndex); @@ -217,6 +224,11 @@ namespace Js StElemInfo stElemInfo; + if (bailedOutOnArraySpecialization) + { + stElemInfo.disableAggressiveSpecialization = true; + } + // Only enable fast path if the javascript array is not cross site const bool isJsArray = !TaggedNumber::Is(base) && VirtualTableInfo::HasVirtualTable(base); ScriptContext *const scriptContext = functionBody->GetScriptContext(); diff --git a/lib/Runtime/Language/ProfilingHelpers.h b/lib/Runtime/Language/ProfilingHelpers.h index 18d3e729ba1..e57cad3afb4 100644 --- a/lib/Runtime/Language/ProfilingHelpers.h +++ b/lib/Runtime/Language/ProfilingHelpers.h @@ -10,12 +10,12 @@ namespace Js class ProfilingHelpers { public: - static Var ProfiledLdElem(const Var base, const Var varIndex, FunctionBody *const functionBody, const ProfileId profileId, bool didArrayAccessHelperCall); + static Var ProfiledLdElem(const Var base, const Var varIndex, FunctionBody *const functionBody, const ProfileId profileId, bool didArrayAccessHelperCall, bool bailedOutOnArraySpecialization); static Var ProfiledLdElem_FastPath(JavascriptArray *const array, const Var varIndex, ScriptContext *const scriptContext, LdElemInfo *const ldElemInfo = nullptr); public: static void ProfiledStElem_DefaultFlags(const Var base, const Var varIndex, const Var value, FunctionBody *const functionBody, const ProfileId profileId); - static void ProfiledStElem(const Var base, const Var varIndex, const Var value, FunctionBody *const functionBody, const ProfileId profileId, const PropertyOperationFlags flags, bool didArrayAccessHelperCall); + static void ProfiledStElem(const Var base, const Var varIndex, const Var value, FunctionBody *const functionBody, const ProfileId profileId, const PropertyOperationFlags flags, bool didArrayAccessHelperCall, bool bailedOutOnArraySpecialization); static void ProfiledStElem_FastPath(JavascriptArray *const array, const Var varIndex, const Var value, ScriptContext *const scriptContext, const PropertyOperationFlags flags, StElemInfo *const stElemInfo = nullptr); public: From 395a8797811aad2422825db10b739072904b22c2 Mon Sep 17 00:00:00 2001 From: Matt Gardner Date: Wed, 28 Feb 2018 10:16:12 -0800 Subject: [PATCH 2/2] give less ambigious name to DisableAgressiveSpecialization --- lib/Backend/GlobOpt.cpp | 6 +++--- lib/Runtime/Language/DynamicProfileInfo.h | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/lib/Backend/GlobOpt.cpp b/lib/Backend/GlobOpt.cpp index e77bb092e0d..d97291f47eb 100644 --- a/lib/Backend/GlobOpt.cpp +++ b/lib/Backend/GlobOpt.cpp @@ -3421,7 +3421,7 @@ GlobOpt::OptSrc(IR::Opnd *opnd, IR::Instr * *pInstr, Value **indirIndexValRef, I if(instr->GetSrc1()->IsIndirOpnd() && opnd == instr->GetSrc1()->AsIndirOpnd()->GetBaseOpnd()) { profiledArrayType = profiledInstr->u.ldElemInfo->GetArrayType(); - useAggressiveSpecialization = !profiledInstr->u.ldElemInfo->DisableAggressiveSpecialization(); + useAggressiveSpecialization = !profiledInstr->u.ldElemInfo->IsAggressiveSpecializationDisabled(); } break; @@ -3431,7 +3431,7 @@ GlobOpt::OptSrc(IR::Opnd *opnd, IR::Instr * *pInstr, Value **indirIndexValRef, I if(instr->GetDst()->IsIndirOpnd() && opnd == instr->GetDst()->AsIndirOpnd()->GetBaseOpnd()) { profiledArrayType = profiledInstr->u.stElemInfo->GetArrayType(); - useAggressiveSpecialization = !profiledInstr->u.stElemInfo->DisableAggressiveSpecialization(); + useAggressiveSpecialization = !profiledInstr->u.stElemInfo->IsAggressiveSpecializationDisabled(); } break; @@ -3439,7 +3439,7 @@ GlobOpt::OptSrc(IR::Opnd *opnd, IR::Instr * *pInstr, Value **indirIndexValRef, I if(instr->GetSrc1()->IsRegOpnd() && opnd == instr->GetSrc1()) { profiledArrayType = profiledInstr->u.LdLenInfo().GetArrayType(); - useAggressiveSpecialization = !profiledInstr->u.LdLenInfo().DisableAggressiveSpecialization(); + useAggressiveSpecialization = !profiledInstr->u.LdLenInfo().IsAggressiveSpecializationDisabled(); } break; } diff --git a/lib/Runtime/Language/DynamicProfileInfo.h b/lib/Runtime/Language/DynamicProfileInfo.h index 4e20bee08eb..7a1d8930fb0 100644 --- a/lib/Runtime/Language/DynamicProfileInfo.h +++ b/lib/Runtime/Language/DynamicProfileInfo.h @@ -206,7 +206,7 @@ namespace Js return arrayType; } - bool DisableAggressiveSpecialization() const + bool IsAggressiveSpecializationDisabled() const { return disableAggressiveSpecialization; } @@ -261,7 +261,7 @@ namespace Js return neededHelperCall; } - bool DisableAggressiveSpecialization() const + bool IsAggressiveSpecializationDisabled() const { return disableAggressiveSpecialization; } @@ -332,7 +332,7 @@ namespace Js return storedOutsideArrayBounds; } - bool DisableAggressiveSpecialization() const + bool IsAggressiveSpecializationDisabled() const { return disableAggressiveSpecialization; }