void ThreadContextTTD::LoadInvertedRootMap(JsUtil::BaseDictionary<Js::RecyclableObject*, TTD_LOG_PTR_ID, HeapAllocator>& objToLogIdMap) const { for(auto iter = this->m_ttdRootTagToObjectMap.GetIterator(); iter.IsValid(); iter.MoveNext()) { objToLogIdMap.AddNew(iter.CurrentValue(), iter.CurrentKey()); } }
RuntimeContextInfo::~RuntimeContextInfo() { for(auto iter = this->m_coreObjToPathMap.GetIterator(); iter.IsValid(); iter.MoveNext()) { TT_HEAP_DELETE(UtilSupport::TTAutoString, iter.CurrentValue()); } for(auto iter = this->m_coreBodyToPathMap.GetIterator(); iter.IsValid(); iter.MoveNext()) { TT_HEAP_DELETE(UtilSupport::TTAutoString, iter.CurrentValue()); } for(auto iter = this->m_coreDbgScopeToPathMap.GetIterator(); iter.IsValid(); iter.MoveNext()) { TT_HEAP_DELETE(UtilSupport::TTAutoString, iter.CurrentValue()); } }
TTDCompareMap::~TTDCompareMap() { TT_HEAP_FREE_ARRAY(char16, this->PathBuffer, 256); TT_HEAP_FREE_ARRAY(TTD::fPtr_AssertSnapEquivAddtlInfo, this->SnapObjCmpVTable, (int32)NSSnapObjects::SnapObjectType::Limit); //delete all the compare paths for(auto iter = this->H1PtrToPathMap.GetIterator(); iter.IsValid(); iter.MoveNext()) { TT_HEAP_DELETE(TTDComparePath, iter.CurrentValue()); } }
Js::FunctionBody* ScriptContextTTD::FindRootBodyByTopLevelCtr(uint32 bodyCtrId) const { for(auto iter = this->m_ttdTopLevelScriptLoad.GetIterator(); iter.IsValid(); iter.MoveNext()) { if(iter.CurrentValue().TopLevelBodyCtr == bodyCtrId) { return TTD_COERCE_PTR_ID_TO_FUNCTIONBODY(iter.CurrentValue().ContextSpecificBodyPtrId); } } for(auto iter = this->m_ttdTopLevelNewFunction.GetIterator(); iter.IsValid(); iter.MoveNext()) { if(iter.CurrentValue().TopLevelBodyCtr == bodyCtrId) { return TTD_COERCE_PTR_ID_TO_FUNCTIONBODY(iter.CurrentValue().ContextSpecificBodyPtrId); } } for(auto iter = this->m_ttdTopLevelEval.GetIterator(); iter.IsValid(); iter.MoveNext()) { if(iter.CurrentValue().TopLevelBodyCtr == bodyCtrId) { return TTD_COERCE_PTR_ID_TO_FUNCTIONBODY(iter.CurrentValue().ContextSpecificBodyPtrId); } } return nullptr; }
void ScriptContextTTD::GetLoadedSources(const JsUtil::BaseHashSet<Js::FunctionBody*, HeapAllocator>* onlyLiveTopLevelBodies, JsUtil::List<TTD::TopLevelFunctionInContextRelation, HeapAllocator>& topLevelScriptLoad, JsUtil::List<TTD::TopLevelFunctionInContextRelation, HeapAllocator>& topLevelNewFunction, JsUtil::List<TTD::TopLevelFunctionInContextRelation, HeapAllocator>& topLevelEval) { TTDAssert(topLevelScriptLoad.Count() == 0 && topLevelNewFunction.Count() == 0 && topLevelEval.Count() == 0, "Should be empty when you call this."); for(auto iter = this->m_ttdTopLevelScriptLoad.GetIterator(); iter.IsValid(); iter.MoveNext()) { Js::FunctionBody* body = TTD_COERCE_PTR_ID_TO_FUNCTIONBODY(iter.CurrentValue().ContextSpecificBodyPtrId); if(onlyLiveTopLevelBodies == nullptr || onlyLiveTopLevelBodies->Contains(body)) { topLevelScriptLoad.Add(iter.CurrentValue()); } } for(auto iter = this->m_ttdTopLevelNewFunction.GetIterator(); iter.IsValid(); iter.MoveNext()) { Js::FunctionBody* body = TTD_COERCE_PTR_ID_TO_FUNCTIONBODY(iter.CurrentValue().ContextSpecificBodyPtrId); if(onlyLiveTopLevelBodies == nullptr || onlyLiveTopLevelBodies->Contains(body)) { topLevelNewFunction.Add(iter.CurrentValue()); } } for(auto iter = this->m_ttdTopLevelEval.GetIterator(); iter.IsValid(); iter.MoveNext()) { Js::FunctionBody* body = TTD_COERCE_PTR_ID_TO_FUNCTIONBODY(iter.CurrentValue().ContextSpecificBodyPtrId); if(onlyLiveTopLevelBodies == nullptr || onlyLiveTopLevelBodies->Contains(body)) { topLevelEval.Add(iter.CurrentValue()); } } }
bool IntBounds::SubCannotOverflowBasedOnRelativeBounds(const int n) const { Assert(n != 0); if(n >= 0) { const int minBoundOffset = n; for(auto it = relativeLowerBounds.GetIterator(); it.IsValid(); it.MoveNext()) { // If (a > b), then (a - 1) cannot overflow const ValueRelativeOffset &bound = it.CurrentValue(); if(bound.Offset() >= minBoundOffset) return true; } return false; } return n != IntConstMin && AddCannotOverflowBasedOnRelativeBounds(-n); }
void LevelMenuEntry::Render( IRender *pRender, int x, int y ) { if ( !m_rightOn.IsValid() ) { m_rightOff = pRender->LoadImage( "Data/Sprites2/ui/selectlevel_btn_normal.png" ); m_rightOn = pRender->LoadImage( "Data/Sprites2/ui/selectlevel_btn_selected.png" ); m_arrowLeft = pRender->LoadImage( "Data/Sprites2/ui/arrow_left_selected.png" ); m_arrowRight = pRender->LoadImage( "Data/Sprites2/ui/arrow_right_selected.png" ); m_arrowLeftPressed = pRender->LoadImage( "Data/Sprites2/ui/arrow_left_normal.png" ); m_arrowRightPressed = pRender->LoadImage( "Data/Sprites2/ui/arrow_right_normal.png" ); } m_screenX = x + m_x + m_w - 577 - 68; if ( !m_selected ) pRender->DrawImage( m_rightOff, x + m_x + m_w - 577 - 68, y + m_y ); else { pRender->DrawImage( m_rightOn, x + m_x + m_w - 577 - 68, y + m_y ); if ( m_needArrows ) { if ( m_pressedLeft ) pRender->DrawImage( m_arrowLeftPressed, x + m_x + m_w - 577 - 68 + 20, y + m_y + 10 ); else pRender->DrawImage( m_arrowLeft, x + m_x + m_w - 577 - 68 + 20, y + m_y + 10 ); if ( m_pressedRight ) pRender->DrawImage( m_arrowRightPressed, x + m_x + m_w - 68 - 125, y + m_y + 10 ); else pRender->DrawImage( m_arrowRight, x + m_x + m_w - 68 - 125, y + m_y + 10 ); } } Color off( 73, 198, 135 ); Color on( 136, 247, 27 ); const char *value = CurrentValue(); pRender->DrawAlignedText( x + m_x + m_w - 577/2 - 101, y + m_y + 13, m_selected ? on : off, 25, TEXT_ALIGN_CENTER, "%s", value ); }
ThreadContextTTD::~ThreadContextTTD() { for(auto iter = this->m_ttdContextToExternalRefMap.GetIterator(); iter.IsValid(); iter.MoveNext()) { this->m_threadCtx->GetRecycler()->RootRelease(iter.CurrentValue()); } this->m_ttdContextToExternalRefMap.Clear(); this->m_activeContext = nullptr; this->m_contextList.Clear(); this->m_ttdRootTagToObjectMap.Clear(); this->m_ttdMayBeLongLivedRoot.Clear(); if(this->m_ttdRecordRootWeakMap != nullptr) { this->m_ttdRecordRootWeakMap.Unroot(this->m_threadCtx->GetRecycler()); } if(this->m_ttdReplayRootPinSet != nullptr) { this->m_ttdReplayRootPinSet.Unroot(this->m_threadCtx->GetRecycler()); } }
uint32 ScriptContextTTD::FindTopLevelCtrForBody(Js::FunctionBody* body) const { Js::FunctionBody* rootBody = body; while(this->ResolveParentBody(rootBody) != nullptr) { rootBody = this->ResolveParentBody(rootBody); } TTD_PTR_ID trgtid = TTD_CONVERT_FUNCTIONBODY_TO_PTR_ID(rootBody); for(auto iter = this->m_ttdTopLevelScriptLoad.GetIterator(); iter.IsValid(); iter.MoveNext()) { if(iter.CurrentValue().ContextSpecificBodyPtrId == trgtid) { return iter.CurrentValue().TopLevelBodyCtr; } } for(auto iter = this->m_ttdTopLevelNewFunction.GetIterator(); iter.IsValid(); iter.MoveNext()) { if(iter.CurrentValue().ContextSpecificBodyPtrId == trgtid) { return iter.CurrentValue().TopLevelBodyCtr; } } for(auto iter = this->m_ttdTopLevelEval.GetIterator(); iter.IsValid(); iter.MoveNext()) { if(iter.CurrentValue().ContextSpecificBodyPtrId == trgtid) { return iter.CurrentValue().TopLevelBodyCtr; } } TTDAssert(false, "We are missing a top-level function reference."); return 0; }
double Model_Stock::CurrentValue(const Data& r) { return CurrentValue(&r); }
void IntBounds::MergeBoundSets( const Value *const bounds0Value, const IntBounds *const bounds0, const Value *const bounds1Value, const IntBounds *const bounds1, IntBounds *const mergedBounds) { Assert(bounds0Value); bounds0->Verify(); Assert(bounds1Value); bounds1->Verify(); Assert(bounds0 != bounds1); Assert(mergedBounds); Assert(mergedBounds != bounds0); Assert(mergedBounds != bounds1); RelativeIntBoundSet *mergedBoundSet; const RelativeIntBoundSet *boundSet0, *boundSet1; if(Lower) { mergedBoundSet = &mergedBounds->relativeLowerBounds; boundSet0 = &bounds0->relativeLowerBounds; boundSet1 = &bounds1->relativeLowerBounds; } else { mergedBoundSet = &mergedBounds->relativeUpperBounds; boundSet0 = &bounds0->relativeUpperBounds; boundSet1 = &bounds1->relativeUpperBounds; } // Iterate over the smaller set and look up in the larger set for compatible bounds that can be merged const RelativeIntBoundSet *iterateOver, *lookUpIn; if(boundSet0->Count() <= boundSet1->Count()) { iterateOver = boundSet0; lookUpIn = boundSet1; } else { iterateOver = boundSet1; lookUpIn = boundSet0; } for(auto it = iterateOver->GetIterator(); it.IsValid(); it.MoveNext()) { const ValueRelativeOffset &iterateOver_bound(it.CurrentValue()); const ValueNumber baseValueNumber = iterateOver_bound.BaseValueNumber(); const ValueRelativeOffset *lookUpIn_bound; if(!lookUpIn->TryGetReference(baseValueNumber, &lookUpIn_bound)) continue; ValueRelativeOffset mergedBound(iterateOver_bound); mergedBound.Merge<Lower, false>(*lookUpIn_bound); mergedBoundSet->Add(mergedBound); } // A value is implicitly bounded by itself, so preserve and merge bounds where one value is bounded by the other const ValueNumber bounds0ValueNumber = bounds0Value->GetValueNumber(), bounds1ValueNumber = bounds1Value->GetValueNumber(); if(bounds0ValueNumber == bounds1ValueNumber) return; const ValueRelativeOffset *bound; if(boundSet0->TryGetReference(bounds1ValueNumber, &bound)) { ValueRelativeOffset mergedBound(bounds1Value, true); mergedBound.Merge<Lower, false>(*bound); mergedBoundSet->Add(mergedBound); } if(boundSet1->TryGetReference(bounds0ValueNumber, &bound)) { ValueRelativeOffset mergedBound(bounds0Value, true); mergedBound.Merge<Lower, false>(*bound); mergedBoundSet->Add(mergedBound); } }
void IntBounds::SetBound( const ValueNumber myValueNumber, const Value *const baseValue, const int offset, const bool wasEstablishedExplicitly) { Assert(baseValue); Assert(baseValue->GetValueNumber() != myValueNumber); // Aggressively merge the constant lower or upper bound of the base value, adjusted by the offset ValueInfo const * const baseValueInfo = baseValue->GetValueInfo(); int constantBoundBase; const bool success = Lower ? baseValueInfo->TryGetIntConstantLowerBound(&constantBoundBase, true) : baseValueInfo->TryGetIntConstantUpperBound(&constantBoundBase, true); Assert(success); const bool isBoundConstant = baseValueInfo->HasIntConstantValue(); SetBound<Lower>(constantBoundBase, offset, wasEstablishedExplicitly && isBoundConstant); if(isBoundConstant) return; // If the base value has relative bounds, pull in the lower or upper bounds adjusted by the offset RelativeIntBoundSet &boundSet = Lower ? relativeLowerBounds : relativeUpperBounds; const RelativeIntBoundSet &oppositeBoundSet = Lower ? relativeUpperBounds : relativeLowerBounds; if(baseValueInfo->IsIntBounded()) { const IntBounds *const baseValueBounds = baseValueInfo->AsIntBounded()->Bounds(); const RelativeIntBoundSet &baseValueBoundSet = Lower ? baseValueBounds->relativeLowerBounds : baseValueBounds->relativeUpperBounds; for(auto it = baseValueBoundSet.GetIterator(); it.IsValid(); it.MoveNext()) { ValueRelativeOffset bound(it.CurrentValue()); if(bound.BaseValueNumber() == myValueNumber || !bound.Add(offset)) continue; const ValueRelativeOffset *existingOppositeBound; if(oppositeBoundSet.TryGetReference(bound.BaseValueNumber(), &existingOppositeBound) && (Lower ? bound.Offset() > existingOppositeBound->Offset() : bound.Offset() < existingOppositeBound->Offset())) { // This bound contradicts the existing opposite bound on the same base value number: // - Setting a lower bound (base + offset) when (base + offset2) is an upper bound and (offset > offset2) // - Setting an upper bound (base + offset) when (base + offset2) is a lower bound and (offset < offset2) continue; } ValueRelativeOffset *existingBound; if(boundSet.TryGetReference(bound.BaseValueNumber(), &existingBound)) existingBound->Merge<Lower, true>(bound); else boundSet.Add(bound); } } // Set the base value as a relative bound const ValueRelativeOffset bound(baseValue, offset, wasEstablishedExplicitly); const ValueRelativeOffset *existingOppositeBound; if(oppositeBoundSet.TryGetReference(bound.BaseValueNumber(), &existingOppositeBound) && (Lower ? offset > existingOppositeBound->Offset() : offset < existingOppositeBound->Offset())) { // This bound contradicts the existing opposite bound on the same base value number: // - Setting a lower bound (base + offset) when (base + offset2) is an upper bound and (offset > offset2) // - Setting an upper bound (base + offset) when (base + offset2) is a lower bound and (offset < offset2) return; } ValueRelativeOffset *existingBound; if(boundSet.TryGetReference(bound.BaseValueNumber(), &existingBound)) existingBound->Merge<Lower, true>(bound); else boundSet.Add(bound); }