//-------------------------------------------------------------------------------------------------------

// Copyright (C) Microsoft. All rights reserved.

// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.

//-------------------------------------------------------------------------------------------------------

class JitArenaAllocator;

template <>

void

BVSparse<JitArenaAllocator>::QueueInFreeList(BVSparseNode *curNode)

{

AllocatorDeleteInline(JitArenaAllocator, this->alloc, curNode);

}

#include "BackEnd.h"

#define INLINEEMETAARG_COUNT 3

BackwardPass::BackwardPass(Func * func, GlobOpt * globOpt, Js::Phase tag)

: func(func), globOpt(globOpt), tag(tag), currentPrePassLoop(nullptr), tempAlloc(nullptr),

preOpBailOutInstrToProcess(nullptr),

considerSymAsRealUseInNoImplicitCallUses(nullptr),

isCollectionPass(false), currentRegion(nullptr)

{

// Those are the only two phase dead store will be used currently

Assert(tag == Js::BackwardPhase || tag == Js::DeadStorePhase);

this->implicitCallBailouts = 0;

this->fieldOpts = 0;

#if DBG_DUMP

this->numDeadStore = 0;

this->numMarkTempNumber = 0;

this->numMarkTempNumberTransfered = 0;

this->numMarkTempObject = 0;

#endif

}

bool

BackwardPass::DoSetDead() const

{

// Note: Dead bit on the Opnd records flow-based liveness.

// This is distinct from isLastUse, which records lexical last-ness.

return this->tag == Js::BackwardPhase && !this->IsPrePass();

}

bool

BackwardPass::DoByteCodeUpwardExposedUsed() const

{

return (this->tag == Js::DeadStorePhase && this->func->hasBailout) ||

(this->func->HasTry() && this->func->DoOptimizeTryCatch() && this->tag == Js::BackwardPhase);

}

bool

BackwardPass::DoFieldHoistCandidates() const

{

return DoFieldHoistCandidates(this->currentBlock->loop);

}

bool

BackwardPass::DoFieldHoistCandidates(Loop * loop) const

{

// We only need to do one pass to generate this data

return this->tag == Js::BackwardPhase

&& !this->IsPrePass() && loop && GlobOpt::DoFieldHoisting(loop);

}

bool

BackwardPass::DoMarkTempNumbers() const

{

#if FLOATVAR

return false;

#else

// only mark temp number on the dead store phase

return (tag == Js::DeadStorePhase) && !PHASE_OFF(Js::MarkTempPhase, this->func) &&

!PHASE_OFF(Js::MarkTempNumberPhase, this->func) && func->DoFastPaths() && (!this->func->HasTry());

#endif

}

bool

BackwardPass::DoMarkTempObjects() const

{

// only mark temp object on the backward store phase

return (tag == Js::BackwardPhase) && !PHASE_OFF(Js::MarkTempPhase, this->func) &&

!PHASE_OFF(Js::MarkTempObjectPhase, this->func) && func->DoGlobOpt() && func->GetHasTempObjectProducingInstr() &&

!func->IsJitInDebugMode() &&

func->DoGlobOptsForGeneratorFunc();

// Why MarkTempObject is disabled under debugger:

// We add 'identified so far dead non-temp locals' to byteCodeUpwardExposedUsed in ProcessBailOutInfo,

// this may cause MarkTempObject to convert some temps back to non-temp when it sees a 'transfered exposed use'

// from a temp to non-temp. That's in general not a supported conversion (while non-temp -> temp is fine).

}

bool

BackwardPass::DoMarkTempNumbersOnTempObjects() const

{

return !PHASE_OFF(Js::MarkTempNumberOnTempObjectPhase, this->func) && DoMarkTempNumbers() && this->func->GetHasMarkTempObjects();

}

#if DBG

bool

BackwardPass::DoMarkTempObjectVerify() const

{

// only mark temp object on the backward store phase

return (tag == Js::DeadStorePhase) && !PHASE_OFF(Js::MarkTempPhase, this->func) &&

!PHASE_OFF(Js::MarkTempObjectPhase, this->func) && func->DoGlobOpt() && func->GetHasTempObjectProducingInstr();

}

#endif

// static

bool

BackwardPass::DoDeadStore(Func* func)

{

return

!PHASE_OFF(Js::DeadStorePhase, func) &&

(!func->HasTry() || func->DoOptimizeTryCatch());

}

bool

BackwardPass::DoDeadStore() const

{

return

this->tag == Js::DeadStorePhase &&

DoDeadStore(this->func);

}

bool

BackwardPass::DoDeadStoreSlots() const

{

// only dead store fields if glob opt is on to generate the trackable fields bitvector

return (tag == Js::DeadStorePhase && this->func->DoGlobOpt()

&& (!this->func->HasTry()));

}

// Whether dead store is enabled for given func and sym.

// static

bool

BackwardPass::DoDeadStore(Func* func, StackSym* sym)

{

// Dead store is disabled under debugger for non-temp local vars.

return

DoDeadStore(func) &&

!(func->IsJitInDebugMode() && sym->HasByteCodeRegSlot() && func->IsNonTempLocalVar(sym->GetByteCodeRegSlot())) &&

func->DoGlobOptsForGeneratorFunc();

}

bool

BackwardPass::DoTrackNegativeZero() const

{

return

!PHASE_OFF(Js::TrackIntUsagePhase, func) &&

!PHASE_OFF(Js::TrackNegativeZeroPhase, func) &&

func->DoGlobOpt() &&

!IsPrePass() &&

!func->IsJitInDebugMode() &&

func->DoGlobOptsForGeneratorFunc();

}

bool

BackwardPass::DoTrackBitOpsOrNumber() const

{

#if _WIN64

return

!PHASE_OFF1(Js::TypedArrayVirtualPhase) &&

tag == Js::BackwardPhase &&

func->DoGlobOpt() &&

!IsPrePass() &&

!func->IsJitInDebugMode() &&

func->DoGlobOptsForGeneratorFunc();

#else

return false;

#endif

}

bool

BackwardPass::DoTrackIntOverflow() const

{

return

!PHASE_OFF(Js::TrackIntUsagePhase, func) &&

!PHASE_OFF(Js::TrackIntOverflowPhase, func) &&

tag == Js::BackwardPhase &&

!IsPrePass() &&

globOpt->DoLossyIntTypeSpec() &&

!func->IsJitInDebugMode() &&

func->DoGlobOptsForGeneratorFunc();

}

bool

BackwardPass::DoTrackCompoundedIntOverflow() const

{

return

!PHASE_OFF(Js::TrackCompoundedIntOverflowPhase, func) &&

DoTrackIntOverflow() &&

!func->GetProfileInfo()->IsTrackCompoundedIntOverflowDisabled();

}

bool

BackwardPass::DoTrackNon32BitOverflow() const

{

// enabled only for IA

#if defined(_M_IX86) || defined(_M_X64)

return true;

#else

return false;

#endif

}

void

BackwardPass::CleanupBackwardPassInfoInFlowGraph()

{

if (!this->func->m_fg->hasBackwardPassInfo)

{

// No information to clean up

return;

}

// The backward pass temp arena has already been deleted, we can just reset the data

FOREACH_BLOCK_IN_FUNC_DEAD_OR_ALIVE(block, this->func)

{

block->upwardExposedUses = nullptr;

block->upwardExposedFields = nullptr;

block->typesNeedingKnownObjectLayout = nullptr;

block->fieldHoistCandidates = nullptr;

block->slotDeadStoreCandidates = nullptr;

block->byteCodeUpwardExposedUsed = nullptr;

#if DBG

block->byteCodeRestoreSyms = nullptr;

#endif

block->tempNumberTracker = nullptr;

block->tempObjectTracker = nullptr;

#if DBG

block->tempObjectVerifyTracker = nullptr;

#endif

block->stackSymToFinalType = nullptr;

block->stackSymToGuardedProperties = nullptr;

block->stackSymToWriteGuardsMap = nullptr;

block->cloneStrCandidates = nullptr;

block->noImplicitCallUses = nullptr;

block->noImplicitCallNoMissingValuesUses = nullptr;

block->noImplicitCallNativeArrayUses = nullptr;

block->noImplicitCallJsArrayHeadSegmentSymUses = nullptr;

block->noImplicitCallArrayLengthSymUses = nullptr;

if (block->loop != nullptr)

{

block->loop->hasDeadStoreCollectionPass = false;

block->loop->hasDeadStorePrepass = false;

}

}

NEXT_BLOCK_IN_FUNC_DEAD_OR_ALIVE;

}

void

BackwardPass::Optimize()

{

if (tag == Js::BackwardPhase && PHASE_OFF(tag, this->func))

{

return;

}

NoRecoverMemoryJitArenaAllocator localAlloc(tag == Js::BackwardPhase? L"BE-Backward" : L"BE-DeadStore",

this->func->m_alloc->GetPageAllocator(), Js::Throw::OutOfMemory);

this->tempAlloc = &localAlloc;

#if DBG_DUMP

if (this->IsTraceEnabled())

{

this->func->DumpHeader();

}

#endif

this->CleanupBackwardPassInfoInFlowGraph();

// Info about whether a sym is used in a way in which -0 differs from +0, or whether the sym is used in a way in which an

// int32 overflow when generating the value of the sym matters, in the current block. The info is transferred to

// instructions that define the sym in the current block as they are encountered. The info in these bit vectors is discarded

// after optimizing each block, so the only info that remains for GlobOpt is that which is transferred to instructions.

BVSparse<JitArenaAllocator> localNegativeZeroDoesNotMatterBySymId(tempAlloc);

negativeZeroDoesNotMatterBySymId = &localNegativeZeroDoesNotMatterBySymId;

BVSparse<JitArenaAllocator> localSymUsedOnlyForBitOpsBySymId(tempAlloc);

symUsedOnlyForBitOpsBySymId = &localSymUsedOnlyForBitOpsBySymId;

BVSparse<JitArenaAllocator> localSymUsedOnlyForNumberBySymId(tempAlloc);

symUsedOnlyForNumberBySymId = &localSymUsedOnlyForNumberBySymId;

BVSparse<JitArenaAllocator> localIntOverflowDoesNotMatterBySymId(tempAlloc);

intOverflowDoesNotMatterBySymId = &localIntOverflowDoesNotMatterBySymId;

BVSparse<JitArenaAllocator> localIntOverflowDoesNotMatterInRangeBySymId(tempAlloc);

intOverflowDoesNotMatterInRangeBySymId = &localIntOverflowDoesNotMatterInRangeBySymId;

BVSparse<JitArenaAllocator> localCandidateSymsRequiredToBeInt(tempAlloc);

candidateSymsRequiredToBeInt = &localCandidateSymsRequiredToBeInt;

BVSparse<JitArenaAllocator> localCandidateSymsRequiredToBeLossyInt(tempAlloc);

candidateSymsRequiredToBeLossyInt = &localCandidateSymsRequiredToBeLossyInt;

intOverflowCurrentlyMattersInRange = true;

FloatSymEquivalenceMap localFloatSymEquivalenceMap(tempAlloc);

floatSymEquivalenceMap = &localFloatSymEquivalenceMap;

NumberTempRepresentativePropertySymMap localNumberTempRepresentativePropertySym(tempAlloc);

numberTempRepresentativePropertySym = &localNumberTempRepresentativePropertySym;

FOREACH_BLOCK_BACKWARD_IN_FUNC_DEAD_OR_ALIVE(block, this->func)

{

this->OptBlock(block);

}

NEXT_BLOCK_BACKWARD_IN_FUNC_DEAD_OR_ALIVE;

if (this->tag == Js::DeadStorePhase && !PHASE_OFF(Js::MemOpPhase, this->func))

{

this->RemoveEmptyLoops();

}

this->func->m_fg->hasBackwardPassInfo = true;

if(DoTrackCompoundedIntOverflow())

{

// Tracking int overflow makes use of a scratch field in stack syms, which needs to be cleared

func->m_symTable->ClearStackSymScratch();

}

#if DBG_DUMP

if (PHASE_STATS(this->tag, this->func))

{

this->func->DumpHeader();

Output::Print(this->tag == Js::BackwardPhase? L"Backward Phase Stats:\n" : L"Deadstore Phase Stats:\n");

if (this->DoDeadStore())

{

Output::Print(L" Deadstore : %3d\n", this->numDeadStore);

}

if (this->DoMarkTempNumbers())

{

Output::Print(L" Temp Number : %3d\n", this->numMarkTempNumber);

Output::Print(L" Transfered Temp Number: %3d\n", this->numMarkTempNumberTransfered);

}

if (this->DoMarkTempObjects())

{

Output::Print(L" Temp Object : %3d\n", this->numMarkTempObject);

}

}

#endif

}

void

BackwardPass::MergeSuccBlocksInfo(BasicBlock * block)

{

// Can't reuse the bv in the current block, because its successor can be itself.

TempNumberTracker * tempNumberTracker = nullptr;

TempObjectTracker * tempObjectTracker = nullptr;

#if DBG

TempObjectVerifyTracker * tempObjectVerifyTracker = nullptr;

#endif

HashTable<AddPropertyCacheBucket> * stackSymToFinalType = nullptr;

HashTable<ObjTypeGuardBucket> * stackSymToGuardedProperties = nullptr;

HashTable<ObjWriteGuardBucket> * stackSymToWriteGuardsMap = nullptr;

BVSparse<JitArenaAllocator> * cloneStrCandidates = nullptr;

BVSparse<JitArenaAllocator> * noImplicitCallUses = nullptr;

BVSparse<JitArenaAllocator> * noImplicitCallNoMissingValuesUses = nullptr;

BVSparse<JitArenaAllocator> * noImplicitCallNativeArrayUses = nullptr;

BVSparse<JitArenaAllocator> * noImplicitCallJsArrayHeadSegmentSymUses = nullptr;

BVSparse<JitArenaAllocator> * noImplicitCallArrayLengthSymUses = nullptr;

BVSparse<JitArenaAllocator> * upwardExposedUses = nullptr;

BVSparse<JitArenaAllocator> * upwardExposedFields = nullptr;

BVSparse<JitArenaAllocator> * typesNeedingKnownObjectLayout = nullptr;

BVSparse<JitArenaAllocator> * fieldHoistCandidates = nullptr;

BVSparse<JitArenaAllocator> * slotDeadStoreCandidates = nullptr;

BVSparse<JitArenaAllocator> * byteCodeUpwardExposedUsed = nullptr;

#if DBG

uint byteCodeLocalsCount = func->GetJnFunction()->GetLocalsCount();

StackSym ** byteCodeRestoreSyms = nullptr;

#endif

Assert(!block->isDead || block->GetSuccList()->Empty());

if (this->DoByteCodeUpwardExposedUsed())

{

byteCodeUpwardExposedUsed = JitAnew(this->tempAlloc, BVSparse<JitArenaAllocator>, this->tempAlloc);

#if DBG

byteCodeRestoreSyms = JitAnewArrayZ(this->tempAlloc, StackSym *, byteCodeLocalsCount);

#endif

}

#if DBG

if (!IsCollectionPass() && this->DoMarkTempObjectVerify())

{

tempObjectVerifyTracker = JitAnew(this->tempAlloc, TempObjectVerifyTracker, this->tempAlloc, block->loop != nullptr);

}

#endif

if (!block->isDead)

{

bool keepUpwardExposed = (this->tag == Js::BackwardPhase);

JitArenaAllocator *upwardExposedArena = nullptr;

if(!IsCollectionPass())

{

upwardExposedArena = keepUpwardExposed ? this->globOpt->alloc : this->tempAlloc;

upwardExposedUses = JitAnew(upwardExposedArena, BVSparse<JitArenaAllocator>, upwardExposedArena);

upwardExposedFields = JitAnew(upwardExposedArena, BVSparse<JitArenaAllocator>, upwardExposedArena);

if (this->tag == Js::DeadStorePhase)

{

typesNeedingKnownObjectLayout = JitAnew(this->tempAlloc, BVSparse<JitArenaAllocator>, this->tempAlloc);

}

if (this->DoFieldHoistCandidates())

{

fieldHoistCandidates = JitAnew(this->tempAlloc, BVSparse<JitArenaAllocator>, this->tempAlloc);

}

if (this->DoDeadStoreSlots())

{

slotDeadStoreCandidates = JitAnew(this->tempAlloc, BVSparse<JitArenaAllocator>, this->tempAlloc);

}

if (this->DoMarkTempNumbers())

{

tempNumberTracker = JitAnew(this->tempAlloc, TempNumberTracker, this->tempAlloc, block->loop != nullptr);

}

if (this->DoMarkTempObjects())

{

tempObjectTracker = JitAnew(this->tempAlloc, TempObjectTracker, this->tempAlloc, block->loop != nullptr);

}

noImplicitCallUses = JitAnew(this->tempAlloc, BVSparse<JitArenaAllocator>, this->tempAlloc);

noImplicitCallNoMissingValuesUses = JitAnew(this->tempAlloc, BVSparse<JitArenaAllocator>, this->tempAlloc);

noImplicitCallNativeArrayUses = JitAnew(this->tempAlloc, BVSparse<JitArenaAllocator>, this->tempAlloc);

noImplicitCallJsArrayHeadSegmentSymUses = JitAnew(this->tempAlloc, BVSparse<JitArenaAllocator>, this->tempAlloc);

noImplicitCallArrayLengthSymUses = JitAnew(this->tempAlloc, BVSparse<JitArenaAllocator>, this->tempAlloc);

if (this->tag == Js::BackwardPhase)

{

cloneStrCandidates = JitAnew(this->globOpt->alloc, BVSparse<JitArenaAllocator>, this->globOpt->alloc);

}

}

bool firstSucc = true;

FOREACH_SUCCESSOR_BLOCK(blockSucc, block)

{

#if defined(DBG_DUMP) || defined(ENABLE_DEBUG_CONFIG_OPTIONS)

wchar_t debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

#endif

// save the byteCodeUpwardExposedUsed from deleting for the block right after the memop loop

if (this->tag == Js::DeadStorePhase && !this->IsPrePass() && globOpt->DoMemOp(block->loop) && blockSucc->loop != block->loop)

{

Assert(block->loop->memOpInfo->inductionVariablesUsedAfterLoop == nullptr);

block->loop->memOpInfo->inductionVariablesUsedAfterLoop = JitAnew(this->tempAlloc, BVSparse<JitArenaAllocator>, this->tempAlloc);

block->loop->memOpInfo->inductionVariablesUsedAfterLoop->Or(blockSucc->byteCodeUpwardExposedUsed);

block->loop->memOpInfo->inductionVariablesUsedAfterLoop->Or(blockSucc->upwardExposedUses);

}

bool deleteData = false;

if (!blockSucc->isLoopHeader && blockSucc->backwardPassCurrentLoop == this->currentPrePassLoop)

{

Assert(blockSucc->GetDataUseCount() != 0);

deleteData = (blockSucc->DecrementDataUseCount() == 0);

}

Assert((byteCodeUpwardExposedUsed == nullptr) == !this->DoByteCodeUpwardExposedUsed());

if (byteCodeUpwardExposedUsed && blockSucc->byteCodeUpwardExposedUsed)

{

byteCodeUpwardExposedUsed->Or(blockSucc->byteCodeUpwardExposedUsed);

if (this->tag == Js::DeadStorePhase)

{

#if DBG

for (uint i = 0; i < byteCodeLocalsCount; i++)

{

if (byteCodeRestoreSyms[i] == nullptr)

{

byteCodeRestoreSyms[i] = blockSucc->byteCodeRestoreSyms[i];

}

else

{

Assert(blockSucc->byteCodeRestoreSyms[i] == nullptr

|| byteCodeRestoreSyms[i] == blockSucc->byteCodeRestoreSyms[i]);

}

}

#endif

if (deleteData)

{

// byteCodeUpwardExposedUsed is required to populate the writeThroughSymbolsSet for the try region. So, don't delete it in the backwards pass.

JitAdelete(this->tempAlloc, blockSucc->byteCodeUpwardExposedUsed);

blockSucc->byteCodeUpwardExposedUsed = nullptr;

}

}

#if DBG

if (deleteData)

{

JitAdeleteArray(this->tempAlloc, byteCodeLocalsCount, blockSucc->byteCodeRestoreSyms);

blockSucc->byteCodeRestoreSyms = nullptr;

}

#endif

}

else

{

Assert(blockSucc->byteCodeUpwardExposedUsed == nullptr);

Assert(blockSucc->byteCodeRestoreSyms == nullptr);

}

if(IsCollectionPass())

{

continue;

}

Assert((blockSucc->upwardExposedUses != nullptr)

|| (blockSucc->isLoopHeader && (this->IsPrePass() || blockSucc->loop->IsDescendentOrSelf(block->loop))));

Assert((blockSucc->upwardExposedFields != nullptr)

|| (blockSucc->isLoopHeader && (this->IsPrePass() || blockSucc->loop->IsDescendentOrSelf(block->loop))));

Assert((blockSucc->typesNeedingKnownObjectLayout != nullptr)

|| (blockSucc->isLoopHeader && (this->IsPrePass() || blockSucc->loop->IsDescendentOrSelf(block->loop)))

|| this->tag != Js::DeadStorePhase);

Assert((blockSucc->fieldHoistCandidates != nullptr)

|| blockSucc->isLoopHeader

|| !this->DoFieldHoistCandidates(blockSucc->loop));

Assert((blockSucc->slotDeadStoreCandidates != nullptr)

|| (blockSucc->isLoopHeader && (this->IsPrePass() || blockSucc->loop->IsDescendentOrSelf(block->loop)))

|| !this->DoDeadStoreSlots());

Assert((blockSucc->tempNumberTracker != nullptr)

|| (blockSucc->isLoopHeader && (this->IsPrePass() || blockSucc->loop->IsDescendentOrSelf(block->loop)))

|| !this->DoMarkTempNumbers());

Assert((blockSucc->tempObjectTracker != nullptr)

|| (blockSucc->isLoopHeader && (this->IsPrePass() || blockSucc->loop->IsDescendentOrSelf(block->loop)))

|| !this->DoMarkTempObjects());

Assert((blockSucc->tempObjectVerifyTracker != nullptr)

|| (blockSucc->isLoopHeader && (this->IsPrePass() || blockSucc->loop->IsDescendentOrSelf(block->loop)))

|| !this->DoMarkTempObjectVerify());

if (blockSucc->upwardExposedUses != nullptr)

{

upwardExposedUses->Or(blockSucc->upwardExposedUses);

if (deleteData && (!keepUpwardExposed

|| (this->IsPrePass() && blockSucc->backwardPassCurrentLoop == this->currentPrePassLoop)))

{

JitAdelete(upwardExposedArena, blockSucc->upwardExposedUses);

blockSucc->upwardExposedUses = nullptr;

}

}

if (blockSucc->upwardExposedFields != nullptr)

{

upwardExposedFields->Or(blockSucc->upwardExposedFields);

if (deleteData && (!keepUpwardExposed

|| (this->IsPrePass() && blockSucc->backwardPassCurrentLoop == this->currentPrePassLoop)))

{

JitAdelete(upwardExposedArena, blockSucc->upwardExposedFields);

blockSucc->upwardExposedFields = nullptr;

}

}

if (blockSucc->typesNeedingKnownObjectLayout != nullptr)

{

typesNeedingKnownObjectLayout->Or(blockSucc->typesNeedingKnownObjectLayout);

if (deleteData)

{

JitAdelete(this->tempAlloc, blockSucc->typesNeedingKnownObjectLayout);

blockSucc->typesNeedingKnownObjectLayout = nullptr;

}

}

if (fieldHoistCandidates && blockSucc->fieldHoistCandidates != nullptr)

{

fieldHoistCandidates->Or(blockSucc->fieldHoistCandidates);

if (deleteData)

{

JitAdelete(this->tempAlloc, blockSucc->fieldHoistCandidates);

blockSucc->fieldHoistCandidates = nullptr;

}

}

if (blockSucc->slotDeadStoreCandidates != nullptr)

{

slotDeadStoreCandidates->And(blockSucc->slotDeadStoreCandidates);

if (deleteData)

{

JitAdelete(this->tempAlloc, blockSucc->slotDeadStoreCandidates);

blockSucc->slotDeadStoreCandidates = nullptr;

}

}

if (blockSucc->tempNumberTracker != nullptr)

{

Assert((blockSucc->loop != nullptr) == blockSucc->tempNumberTracker->HasTempTransferDependencies());

tempNumberTracker->MergeData(blockSucc->tempNumberTracker, deleteData);

if (deleteData)

{

blockSucc->tempNumberTracker = nullptr;

}

}

if (blockSucc->tempObjectTracker != nullptr)

{

Assert((blockSucc->loop != nullptr) == blockSucc->tempObjectTracker->HasTempTransferDependencies());

tempObjectTracker->MergeData(blockSucc->tempObjectTracker, deleteData);

if (deleteData)

{

blockSucc->tempObjectTracker = nullptr;

}

}

#if DBG

if (blockSucc->tempObjectVerifyTracker != nullptr)

{

Assert((blockSucc->loop != nullptr) == blockSucc->tempObjectVerifyTracker->HasTempTransferDependencies());

tempObjectVerifyTracker->MergeData(blockSucc->tempObjectVerifyTracker, deleteData);

if (deleteData)

{

blockSucc->tempObjectVerifyTracker = nullptr;

}

}

#endif

PHASE_PRINT_TRACE(Js::ObjTypeSpecStorePhase, this->func,

L"ObjTypeSpecStore: func %s, edge %d => %d: ",

this->func->GetJnFunction()->GetDebugNumberSet(debugStringBuffer),

block->GetBlockNum(), blockSucc->GetBlockNum());

auto fixupFrom = [block, blockSucc, this](Bucket<AddPropertyCacheBucket> &bucket)

{

AddPropertyCacheBucket *fromData = &bucket.element;

if (fromData->GetInitialType() == nullptr ||

fromData->GetFinalType() == fromData->GetInitialType())

{

return;

}

this->InsertTypeTransitionsAtPriorSuccessors(block, blockSucc, bucket.value, fromData);

};

auto fixupTo = [blockSucc, this](Bucket<AddPropertyCacheBucket> &bucket)

{

AddPropertyCacheBucket *toData = &bucket.element;

if (toData->GetInitialType() == nullptr ||

toData->GetFinalType() == toData->GetInitialType())

{

return;

}

this->InsertTypeTransitionAtBlock(blockSucc, bucket.value, toData);

};

if (blockSucc->stackSymToFinalType != nullptr)

{

#if DBG_DUMP

if (PHASE_TRACE(Js::ObjTypeSpecStorePhase, this->func))

{

blockSucc->stackSymToFinalType->Dump();

}

#endif

if (firstSucc)

{

stackSymToFinalType = blockSucc->stackSymToFinalType->Copy();

}

else if (stackSymToFinalType != nullptr)

{

if (this->IsPrePass())

{

stackSymToFinalType->And(blockSucc->stackSymToFinalType);

}

else

{

// Insert any type transitions that can't be merged past this point.

stackSymToFinalType->AndWithFixup(blockSucc->stackSymToFinalType, fixupFrom, fixupTo);

}

}

else if (!this->IsPrePass())

{

FOREACH_HASHTABLE_ENTRY(AddPropertyCacheBucket, bucket, blockSucc->stackSymToFinalType)

{

fixupTo(bucket);

}

NEXT_HASHTABLE_ENTRY;

}

if (deleteData)

{

blockSucc->stackSymToFinalType->Delete();

blockSucc->stackSymToFinalType = nullptr;

}

}

else

{

PHASE_PRINT_TRACE(Js::ObjTypeSpecStorePhase, this->func, L"null\n");

if (stackSymToFinalType)

{

if (!this->IsPrePass())

{

FOREACH_HASHTABLE_ENTRY(AddPropertyCacheBucket, bucket, stackSymToFinalType)

{

fixupFrom(bucket);

}

NEXT_HASHTABLE_ENTRY;

}

stackSymToFinalType->Delete();

stackSymToFinalType = nullptr;

}

}

if (tag == Js::BackwardPhase)

{

if (blockSucc->cloneStrCandidates != nullptr)

{

Assert(cloneStrCandidates != nullptr);

cloneStrCandidates->Or(blockSucc->cloneStrCandidates);

if (deleteData)

{

JitAdelete(this->globOpt->alloc, blockSucc->cloneStrCandidates);

blockSucc->cloneStrCandidates = nullptr;

}

}

#if DBG_DUMP

if (PHASE_VERBOSE_TRACE(Js::TraceObjTypeSpecWriteGuardsPhase, this->func))

{

wchar_t debugStringBuffer2[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

Js::FunctionBody* topFunctionBody = this->func->GetTopFunc()->GetJnFunction();

Js::FunctionBody* functionBody = this->func->GetJnFunction();

Output::Print(L"ObjTypeSpec: top function %s (%s), function %s (%s), write guard symbols on edge %d => %d: ",

topFunctionBody->GetDisplayName(), topFunctionBody->GetDebugNumberSet(debugStringBuffer), functionBody->GetDisplayName(),

functionBody->GetDebugNumberSet(debugStringBuffer2), block->GetBlockNum(), blockSucc->GetBlockNum());

}

#endif

if (blockSucc->stackSymToWriteGuardsMap != nullptr)

{

#if DBG_DUMP

if (PHASE_VERBOSE_TRACE(Js::TraceObjTypeSpecWriteGuardsPhase, this->func))

{

Output::Print(L"\n");

blockSucc->stackSymToWriteGuardsMap->Dump();

}

#endif

if (stackSymToWriteGuardsMap == nullptr)

{

stackSymToWriteGuardsMap = blockSucc->stackSymToWriteGuardsMap->Copy();

}

else

{

stackSymToWriteGuardsMap->Or(

blockSucc->stackSymToWriteGuardsMap, &BackwardPass::MergeWriteGuards);

}

if (deleteData)

{

blockSucc->stackSymToWriteGuardsMap->Delete();

blockSucc->stackSymToWriteGuardsMap = nullptr;

}

}

else

{

#if DBG_DUMP

if (PHASE_VERBOSE_TRACE(Js::TraceObjTypeSpecWriteGuardsPhase, this->func))

{

Output::Print(L"null\n");

}

#endif

}

}

else

{

#if DBG_DUMP

if (PHASE_VERBOSE_TRACE(Js::TraceObjTypeSpecTypeGuardsPhase, this->func))

{

Js::FunctionBody* topFunctionBody = this->func->GetTopFunc()->GetJnFunction();

Js::FunctionBody* functionBody = this->func->GetJnFunction();

wchar_t debugStringBuffer2[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

Output::Print(L"ObjTypeSpec: top function %s (%s), function %s (%s), guarded property operations on edge %d => %d: \n",

topFunctionBody->GetDisplayName(), topFunctionBody->GetDebugNumberSet(debugStringBuffer), functionBody->GetDisplayName(), functionBody->GetDebugNumberSet(debugStringBuffer2),

block->GetBlockNum(), blockSucc->GetBlockNum());

}

#endif

if (blockSucc->stackSymToGuardedProperties != nullptr)

{

#if DBG_DUMP

if (PHASE_VERBOSE_TRACE(Js::TraceObjTypeSpecTypeGuardsPhase, this->func))

{

blockSucc->stackSymToGuardedProperties->Dump();

Output::Print(L"\n");

}

#endif

if (stackSymToGuardedProperties == nullptr)

{

stackSymToGuardedProperties = blockSucc->stackSymToGuardedProperties->Copy();

}

else

{

stackSymToGuardedProperties->Or(

blockSucc->stackSymToGuardedProperties, &BackwardPass::MergeGuardedProperties);

}

if (deleteData)

{

blockSucc->stackSymToGuardedProperties->Delete();

blockSucc->stackSymToGuardedProperties = nullptr;

}

}

else

{

#if DBG_DUMP

if (PHASE_VERBOSE_TRACE(Js::TraceObjTypeSpecTypeGuardsPhase, this->func))

{

Output::Print(L"null\n");

}

#endif

}

}

if (blockSucc->noImplicitCallUses != nullptr)

{

noImplicitCallUses->Or(blockSucc->noImplicitCallUses);

if (deleteData)

{

JitAdelete(this->tempAlloc, blockSucc->noImplicitCallUses);

blockSucc->noImplicitCallUses = nullptr;

}

}

if (blockSucc->noImplicitCallNoMissingValuesUses != nullptr)

{

noImplicitCallNoMissingValuesUses->Or(blockSucc->noImplicitCallNoMissingValuesUses);

if (deleteData)

{

JitAdelete(this->tempAlloc, blockSucc->noImplicitCallNoMissingValuesUses);

blockSucc->noImplicitCallNoMissingValuesUses = nullptr;

}

}

if (blockSucc->noImplicitCallNativeArrayUses != nullptr)

{

noImplicitCallNativeArrayUses->Or(blockSucc->noImplicitCallNativeArrayUses);

if (deleteData)

{

JitAdelete(this->tempAlloc, blockSucc->noImplicitCallNativeArrayUses);

blockSucc->noImplicitCallNativeArrayUses = nullptr;

}

}

if (blockSucc->noImplicitCallJsArrayHeadSegmentSymUses != nullptr)

{

noImplicitCallJsArrayHeadSegmentSymUses->Or(blockSucc->noImplicitCallJsArrayHeadSegmentSymUses);

if (deleteData)

{

JitAdelete(this->tempAlloc, blockSucc->noImplicitCallJsArrayHeadSegmentSymUses);

blockSucc->noImplicitCallJsArrayHeadSegmentSymUses = nullptr;

}

}

if (blockSucc->noImplicitCallArrayLengthSymUses != nullptr)

{

noImplicitCallArrayLengthSymUses->Or(blockSucc->noImplicitCallArrayLengthSymUses);

if (deleteData)

{

JitAdelete(this->tempAlloc, blockSucc->noImplicitCallArrayLengthSymUses);

blockSucc->noImplicitCallArrayLengthSymUses = nullptr;

}

}

firstSucc = false;

}

NEXT_SUCCESSOR_BLOCK;

#if DBG_DUMP

wchar_t debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

if (PHASE_TRACE(Js::ObjTypeSpecStorePhase, this->func))

{

Output::Print(L"ObjTypeSpecStore: func %s, block %d: ",

this->func->GetJnFunction()->GetDebugNumberSet(debugStringBuffer),

block->GetBlockNum());

if (stackSymToFinalType)

{

stackSymToFinalType->Dump();

}

else

{

Output::Print(L"null\n");

}

}

if (PHASE_TRACE(Js::TraceObjTypeSpecTypeGuardsPhase, this->func))

{

Output::Print(L"ObjTypeSpec: func %s, block %d, guarded properties:\n",

this->func->GetJnFunction()->GetDebugNumberSet(debugStringBuffer), block->GetBlockNum());

if (stackSymToGuardedProperties)

{

stackSymToGuardedProperties->Dump();

Output::Print(L"\n");

}

else

{

Output::Print(L"null\n");

}

}

if (PHASE_TRACE(Js::TraceObjTypeSpecWriteGuardsPhase, this->func))

{

Output::Print(L"ObjTypeSpec: func %s, block %d, write guards: ",

this->func->GetJnFunction()->GetDebugNumberSet(debugStringBuffer), block->GetBlockNum());

if (stackSymToWriteGuardsMap)

{

Output::Print(L"\n");

stackSymToWriteGuardsMap->Dump();

Output::Print(L"\n");

}

else

{

Output::Print(L"null\n");

}

}

#endif

}

#if DBG

if (tempObjectVerifyTracker)

{

FOREACH_DEAD_SUCCESSOR_BLOCK(deadBlockSucc, block)

{

Assert(deadBlockSucc->tempObjectVerifyTracker || deadBlockSucc->isLoopHeader);

if (deadBlockSucc->tempObjectVerifyTracker != nullptr)

{

Assert((deadBlockSucc->loop != nullptr) == deadBlockSucc->tempObjectVerifyTracker->HasTempTransferDependencies());

// Dead block don't effect non temp use, we only need to carry the removed use bit vector forward

// and put all the upward exposed use to the set that we might found out to be mark temp

// after globopt

tempObjectVerifyTracker->MergeDeadData(deadBlockSucc);

}

if (!byteCodeUpwardExposedUsed)

{

if (!deadBlockSucc->isLoopHeader && deadBlockSucc->backwardPassCurrentLoop == this->currentPrePassLoop)

{

Assert(deadBlockSucc->GetDataUseCount() != 0);

if (deadBlockSucc->DecrementDataUseCount() == 0)

{

this->DeleteBlockData(deadBlockSucc);

}

}

}

}

NEXT_DEAD_SUCCESSOR_BLOCK;

}

#endif

if (byteCodeUpwardExposedUsed)

{

FOREACH_DEAD_SUCCESSOR_BLOCK(deadBlockSucc, block)

{

Assert(deadBlockSucc->byteCodeUpwardExposedUsed || deadBlockSucc->isLoopHeader);

if (deadBlockSucc->byteCodeUpwardExposedUsed)

{

byteCodeUpwardExposedUsed->Or(deadBlockSucc->byteCodeUpwardExposedUsed);

if (this->tag == Js::DeadStorePhase)

{

#if DBG

for (uint i = 0; i < byteCodeLocalsCount; i++)

{

if (byteCodeRestoreSyms[i] == nullptr)

{

byteCodeRestoreSyms[i] = deadBlockSucc->byteCodeRestoreSyms[i];

}

else

{

Assert(deadBlockSucc->byteCodeRestoreSyms[i] == nullptr

|| byteCodeRestoreSyms[i] == deadBlockSucc->byteCodeRestoreSyms[i]);

}

}

#endif

}

}

if (!deadBlockSucc->isLoopHeader && deadBlockSucc->backwardPassCurrentLoop == this->currentPrePassLoop)

{

Assert(deadBlockSucc->GetDataUseCount() != 0);

if (deadBlockSucc->DecrementDataUseCount() == 0)

{

this->DeleteBlockData(deadBlockSucc);

}

}

}

NEXT_DEAD_SUCCESSOR_BLOCK;

}

if (block->isLoopHeader)

{

this->DeleteBlockData(block);

}

else

{

if(block->GetDataUseCount() == 0)

{

Assert(block->slotDeadStoreCandidates == nullptr);

Assert(block->tempNumberTracker == nullptr);

Assert(block->tempObjectTracker == nullptr);

Assert(block->tempObjectVerifyTracker == nullptr);

Assert(block->upwardExposedUses == nullptr);

Assert(block->upwardExposedFields == nullptr);

Assert(block->typesNeedingKnownObjectLayout == nullptr);

Assert(block->fieldHoistCandidates == nullptr);

// byteCodeUpwardExposedUsed is required to populate the writeThroughSymbolsSet for the try region in the backwards pass

Assert(block->byteCodeUpwardExposedUsed == nullptr || (this->tag == Js::BackwardPhase && this->func->HasTry() && this->func->DoOptimizeTryCatch()));

Assert(block->byteCodeRestoreSyms == nullptr);

Assert(block->stackSymToFinalType == nullptr);

Assert(block->stackSymToGuardedProperties == nullptr);

Assert(block->stackSymToWriteGuardsMap == nullptr);

Assert(block->cloneStrCandidates == nullptr);

Assert(block->noImplicitCallUses == nullptr);

Assert(block->noImplicitCallNoMissingValuesUses == nullptr);

Assert(block->noImplicitCallNativeArrayUses == nullptr);

Assert(block->noImplicitCallJsArrayHeadSegmentSymUses == nullptr);

Assert(block->noImplicitCallArrayLengthSymUses == nullptr);

}

else

{

// The collection pass sometimes does not know whether it can delete a successor block's data, so it may leave some

// blocks with data intact. Delete the block data now.