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

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

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

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

#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->numMarkTempNumberTransferred = 0;

this->numMarkTempObject = 0;

#endif

}

void

BackwardPass::DoSetDead(IR::Opnd * opnd, bool isDead) const

{

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

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

if (isDead && this->tag == Js::BackwardPhase && !this->IsPrePass())

{

opnd->SetIsDead();

}

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

{

// Set or reset in DeadStorePhase.

// CSE could make previous dead operand not the last use, so reset it.

opnd->SetIsDead(isDead);

}

}

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 'transferred 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->HasProfileInfo() || !func->GetReadOnlyProfileInfo()->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;

block->couldRemoveNegZeroBailoutForDef = nullptr;

if (block->loop != nullptr)

{

block->loop->hasDeadStoreCollectionPass = false;

block->loop->hasDeadStorePrepass = false;

}

}

NEXT_BLOCK_IN_FUNC_DEAD_OR_ALIVE;

}

/*

* We Insert ArgIns at the start of the function for all the formals.

* Unused formals will be deadstored during the deadstore pass.

* We need ArgIns only for the outermost function(inliner).

*/

void

BackwardPass::InsertArgInsForFormals()

{

if (func->IsStackArgsEnabled() && !func->GetJITFunctionBody()->HasImplicitArgIns())

{

IR::Instr * insertAfterInstr = func->m_headInstr->m_next;

AssertMsg(insertAfterInstr->IsLabelInstr(), "First Instr of the first block should always have a label");

Js::ArgSlot paramsCount = insertAfterInstr->m_func->GetJITFunctionBody()->GetInParamsCount() - 1;

IR::Instr * argInInstr = nullptr;

for (Js::ArgSlot argumentIndex = 1; argumentIndex <= paramsCount; argumentIndex++)

{

IR::SymOpnd * srcOpnd;

StackSym * symSrc = StackSym::NewParamSlotSym(argumentIndex + 1, func);

StackSym * symDst = StackSym::New(func);

IR::RegOpnd * dstOpnd = IR::RegOpnd::New(symDst, TyVar, func);

func->SetArgOffset(symSrc, (argumentIndex + LowererMD::GetFormalParamOffset()) * MachPtr);

srcOpnd = IR::SymOpnd::New(symSrc, TyVar, func);

argInInstr = IR::Instr::New(Js::OpCode::ArgIn_A, dstOpnd, srcOpnd, func);

insertAfterInstr->InsertAfter(argInInstr);

insertAfterInstr = argInInstr;

AssertMsg(!func->HasStackSymForFormal(argumentIndex - 1), "Already has a stack sym for this formal?");

this->func->TrackStackSymForFormalIndex(argumentIndex - 1, symDst);

}

if (PHASE_VERBOSE_TRACE1(Js::StackArgFormalsOptPhase) && paramsCount > 0)

{

Output::Print(_u("StackArgFormals : %s (%d) :Inserting ArgIn_A for LdSlot (formals) in the start of Deadstore pass. \n"), func->GetJITFunctionBody()->GetDisplayName(), func->GetFunctionNumber());

Output::Flush();

}

}

}

void

BackwardPass::MarkScopeObjSymUseForStackArgOpt()

{

IR::Instr * instr = this->currentInstr;

if (tag == Js::DeadStorePhase)

{

if (instr->DoStackArgsOpt(this->func) && instr->m_func->GetScopeObjSym() != nullptr)

{

if (this->currentBlock->byteCodeUpwardExposedUsed == nullptr)

{

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

}

this->currentBlock->byteCodeUpwardExposedUsed->Set(instr->m_func->GetScopeObjSym()->m_id);

}

}

}

void

BackwardPass::ProcessBailOnStackArgsOutOfActualsRange()

{

IR::Instr * instr = this->currentInstr;

if (tag == Js::DeadStorePhase &&

(instr->m_opcode == Js::OpCode::LdElemI_A || instr->m_opcode == Js::OpCode::TypeofElem) &&

instr->HasBailOutInfo() && !IsPrePass())

{

if (instr->DoStackArgsOpt(this->func))

{

AssertMsg(instr->GetBailOutKind() & IR::BailOnStackArgsOutOfActualsRange, "Stack args bail out is not set when the optimization is turned on? ");

if (instr->GetBailOutKind() & ~IR::BailOnStackArgsOutOfActualsRange)

{

Assert(instr->GetBailOutKind() == (IR::BailOnStackArgsOutOfActualsRange | IR::BailOutOnImplicitCallsPreOp));

//We are sure at this point, that we will not have any implicit calls as we wouldn't have done this optimization in the first place.

instr->SetBailOutKind(IR::BailOnStackArgsOutOfActualsRange);

}

}

else if (instr->GetBailOutKind() & IR::BailOnStackArgsOutOfActualsRange)

{

//If we don't decide to do StackArgs, then remove the bail out at this point.

//We would have optimistically set the bailout in the forward pass, and by the end of forward pass - we

//turned off stack args for some reason. So we are removing it in the deadstore pass.

IR::BailOutKind bailOutKind = instr->GetBailOutKind() & ~IR::BailOnStackArgsOutOfActualsRange;

if (bailOutKind == IR::BailOutInvalid)

{

instr->ClearBailOutInfo();

}

else

{

instr->SetBailOutKind(bailOutKind);

}

}

}

}

void

BackwardPass::Optimize()

{

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

{

return;

}

if (tag == Js::DeadStorePhase)

{

if (!this->func->DoLoopFastPaths() || !this->func->DoFastPaths())

{

//arguments[] access is similar to array fast path hence disable when array fastpath is disabled.

//loopFastPath is always true except explicitly disabled

//defaultDoFastPath can be false when we the source code size is huge

func->SetHasStackArgs(false);

}

InsertArgInsForFormals();

}

NoRecoverMemoryJitArenaAllocator localAlloc(tag == Js::BackwardPhase? _u("BE-Backward") : _u("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? _u("Backward Phase Stats:\n") : _u("Deadstore Phase Stats:\n"));

if (this->DoDeadStore())

{

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

}

if (this->DoMarkTempNumbers())

{

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

Output::Print(_u(" Transferred Temp Number: %3d\n"), this->numMarkTempNumberTransferred);

}

if (this->DoMarkTempObjects())

{

Output::Print(_u(" 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;

BVSparse<JitArenaAllocator> * couldRemoveNegZeroBailoutForDef = nullptr;

#if DBG

uint byteCodeLocalsCount = func->GetJITFunctionBody()->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);

}

else

{

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

}

}

bool firstSucc = true;

FOREACH_SUCCESSOR_BLOCK(blockSucc, block)

{

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

char16 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->HasMemOp(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,

_u("ObjTypeSpecStore: func %s, edge %d => %d: "),

this->func->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, _u("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))

{

char16 debugStringBuffer2[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

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

this->func->GetTopFunc()->GetJITFunctionBody()->GetDisplayName(),

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

this->func->GetJITFunctionBody()->GetDisplayName(),

this->func->GetDebugNumberSet(debugStringBuffer2), block->GetBlockNum(),

blockSucc->GetBlockNum());

}

#endif

if (blockSucc->stackSymToWriteGuardsMap != nullptr)

{

#if DBG_DUMP

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

{

Output::Print(_u("\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(_u("null\n"));

}

#endif

}

}

else

{

#if DBG_DUMP

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

{

char16 debugStringBuffer2[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

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

this->func->GetTopFunc()->GetJITFunctionBody()->GetDisplayName(),

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

this->func->GetJITFunctionBody()->GetDisplayName(),

this->func->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(_u("\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(_u("null\n"));

}

#endif

}

if (blockSucc->couldRemoveNegZeroBailoutForDef != nullptr)

{

couldRemoveNegZeroBailoutForDef->And(blockSucc->couldRemoveNegZeroBailoutForDef);

if (deleteData)

{

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

blockSucc->couldRemoveNegZeroBailoutForDef = nullptr;

}

}

}

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

char16 debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

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

{

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

this->func->GetDebugNumberSet(debugStringBuffer),

block->GetBlockNum());

if (stackSymToFinalType)

{

stackSymToFinalType->Dump();

}

else

{

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

}

}

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

{

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

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

if (stackSymToGuardedProperties)

{

stackSymToGuardedProperties->Dump();