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

// 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"

namespace IR

{

void

Instr::Init(Js::OpCode opcode, IRKind kind, Func * func)

{

Assert(!OpCodeAttr::ByteCodeOnly(opcode));

this->m_opcode = opcode;

this->m_kind = kind;

this->m_func = func;

#ifdef BAILOUT_INJECTION

this->bailOutByteCodeLocation = (uint)-1;

#endif

}

uint32

Instr::GetByteCodeOffset() const

{

Assert(m_func->HasByteCodeOffset());

return m_number;

}

void

Instr::SetByteCodeOffset(uint32 offset)

{

Assert(m_func->HasByteCodeOffset());

Assert(m_number == Js::Constants::NoByteCodeOffset);

m_number = offset;

}

void

Instr::SetByteCodeOffset(IR::Instr * instr)

{

SetByteCodeOffset(instr->GetByteCodeOffset());

}

void

Instr::ClearByteCodeOffset()

{

Assert(m_func->HasByteCodeOffset());

m_number = Js::Constants::NoByteCodeOffset;

}

uint32

Instr::GetNumber() const

{

Assert(m_func->HasInstrNumber());

return m_number;

}

void

Instr::SetNumber(uint32 number)

{

Assert(m_func->HasInstrNumber());

m_number = number;

}

bool

Instr::IsPlainInstr() const

{

return this->GetKind() == IR::InstrKindInstr;

}

bool

Instr::DoStackArgsOpt(Func *topFunc) const

{

return this->usesStackArgumentsObject && m_func->IsStackArgsEnabled();

}

bool

Instr::HasTypeCheckBailOut() const

{

return this->HasBailOutInfo() && IR::IsTypeCheckBailOutKind(this->GetBailOutKind());

}

bool

Instr::HasEquivalentTypeCheckBailOut() const

{

return this->HasBailOutInfo() && IR::IsEquivalentTypeCheckBailOutKind(this->GetBailOutKind());

}

void

Instr::ChangeEquivalentToMonoTypeCheckBailOut()

{

Assert(this->HasEquivalentTypeCheckBailOut());

this->SetBailOutKind(IR::EquivalentToMonoTypeCheckBailOutKind(this->GetBailOutKind()));

}

intptr_t

Instr::TryOptimizeInstrWithFixedDataProperty(IR::Instr **pInstr, GlobOpt * globopt)

{

IR::Instr *&instr = *pInstr;

Assert(OpCodeAttr::CanLoadFixedFields(instr->m_opcode));

IR::Opnd * src1 = instr->GetSrc1();

Assert(src1 && src1->IsSymOpnd() && src1->AsSymOpnd()->IsPropertySymOpnd());

IR::PropertySymOpnd * propSymOpnd = src1->AsSymOpnd()->AsPropertySymOpnd();

if (propSymOpnd->HasFixedValue() && !propSymOpnd->IsPoly())

{

intptr_t fixedValue = propSymOpnd->GetFieldValueAsFixedData();

Assert(instr->IsProfiledInstr());

ValueType valType = instr->AsProfiledInstr()->u.FldInfo().valueType;

if (fixedValue && ((Js::TaggedInt::Is(fixedValue) && (valType.IsUninitialized() || valType.IsLikelyInt())) || PHASE_ON1(Js::FixDataVarPropsPhase)))

{

// Change Ld[Root]Fld to CheckFixedFld, which doesn't need a dst.

instr->m_opcode = Js::OpCode::CheckFixedFld;

IR::RegOpnd* dataValueDstOpnd = instr->UnlinkDst()->AsRegOpnd();

if (globopt)

{

globopt->GenerateBailAtOperation(&instr, !propSymOpnd->HasEquivalentTypeSet() ? IR::BailOutFailedFixedFieldTypeCheck : IR::BailOutFailedEquivalentFixedFieldTypeCheck);

}

else

{

instr = instr->ConvertToBailOutInstr(instr, !propSymOpnd->HasEquivalentTypeSet() ? IR::BailOutFailedFixedFieldTypeCheck : IR::BailOutFailedEquivalentFixedFieldTypeCheck);

}

IR::Instr* loadInstr = IR::Instr::NewConstantLoad(dataValueDstOpnd, (intptr_t)fixedValue, valType, instr->m_func);

OUTPUT_VERBOSE_TRACE(Js::UseFixedDataPropsPhase,

_u("FixedFields: Replacing the source (fixed Data prop) with property id %u with 0x%x .\n"),

propSymOpnd->GetPropertyId(), fixedValue);

instr->InsertAfter(loadInstr);

propSymOpnd->SetUsesFixedValue(true);

return fixedValue;

}

}

return 0;

}

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

///

/// Instr::IsEqual

/// Check if this instruction is the same instruction as compareInstr. Two

/// instructions are equal if kind, opcode, dst, src1 and src2 from both instrs

/// are the same.

///

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

bool

Instr::IsEqual(IR::Instr *compareInstr) const

{

Assert(compareInstr);

if (this->GetKind() == compareInstr->GetKind()

&& this->m_opcode == compareInstr->m_opcode)

{

IR::Opnd *dst = this->GetDst();

IR::Opnd *src1 = this->GetSrc1();

IR::Opnd *src2 = this->GetSrc2();

IR::Opnd *compareDst = compareInstr->GetDst();

IR::Opnd *compareSrc1 = compareInstr->GetSrc1();

IR::Opnd *compareSrc2 = compareInstr->GetSrc2();

// when both dst and compareDst are null, they are equal, same applies to src1, src2

if ((dst != compareDst) && (!dst || !compareDst || !dst->IsEqual(compareDst)))

{

return false;

}

if ((src1 != compareSrc1) && (!src1 || !compareSrc1 || !src1->IsEqual(compareSrc1)))

{

return false;

}

if ((src2 != compareSrc2) && (!src2 || !compareSrc2 || !src2->IsEqual(compareSrc2)))

{

return false;

}

return true;

}

else

{

return false;

}

}

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

///

/// Instr::InsertBefore

///

/// Insert 'instr' before 'this' instruction.

///

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

void

Instr::InsertBefore(Instr *instr)

{

Assert(!instr->IsLinked());

Instr * prevInstr = this->m_prev;

instr->m_prev = prevInstr;

this->m_prev = instr;

if (prevInstr)

{

prevInstr->m_next = instr;

}

instr->m_next = this;

}

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

///

/// Instr::InsertAfter

///

/// Insert 'instr' after 'this' instruction.

///

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

void

Instr::InsertAfter(Instr *instr)

{

Assert(!instr->IsLinked());

Instr * nextInstr = this->m_next;

instr->m_next = nextInstr;

this->m_next = instr;

if (nextInstr)

{

nextInstr->m_prev = instr;

}

instr->m_prev = this;

}

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

///

/// Instr::InsertRangeBefore

///

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

void

Instr::InsertRangeBefore(Instr *startInstr, Instr *endInstr)

{

Instr * prevInstr = this->m_prev;

startInstr->m_prev = prevInstr;

this->m_prev = endInstr;

if (prevInstr)

{

prevInstr->m_next = startInstr;

}

endInstr->m_next = this;

}

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

///

/// Instr::InsertMultipleBefore - Inserts multiple instr

///

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

void

Instr::InsertMultipleBefore(Instr *endInstr)

{

Instr *startInstr = endInstr->m_prev;

if (startInstr) // more than one instruction to insert

{

while (startInstr->m_prev)

{

startInstr = startInstr->m_prev;

}

return this->InsertRangeBefore(startInstr, endInstr);

}

return this->InsertBefore(endInstr);

}

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

///

/// Instr::InsertRangeAfter

///

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

void

Instr::InsertRangeAfter(Instr *startInstr, Instr *endInstr)

{

Instr * nextInstr = this->m_next;

endInstr->m_next = nextInstr;

this->m_next = startInstr;

if (nextInstr)

{

nextInstr->m_prev = endInstr;

}

startInstr->m_prev = this;

}

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

///

/// Instr::InsertMultipleAfter - Inserts multiple instr

///

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

void

Instr::InsertMultipleAfter(Instr *endInstr)

{

Instr *startInstr = endInstr->m_prev;

if (startInstr) //more than one instruction to insert

{

while (startInstr->m_prev)

{

startInstr = startInstr->m_prev;

}

return this->InsertRangeAfter(startInstr, endInstr);

}

return this->InsertAfter(endInstr);

}

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

///

/// Instr::Free

///

/// Free this instruction by putting it on a free list.

///

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

void

Instr::Free()

{

AssertMsg(!this->IsLabelInstr() || !this->AsLabelInstr()->m_hasNonBranchRef,

"Cannot free label with non-branch reference");

switch (this->GetKind())

{

case InstrKindBranch:

{

IR::BranchInstr *branchInstr = this->AsBranchInstr();

branchInstr->ClearTarget();

break;

}

}

IR::Opnd * dstOpnd = this->GetDst();

if (dstOpnd)

{

StackSym * stackSym = dstOpnd->GetStackSym();

if (stackSym)

{

if (stackSym->m_isSingleDef)

{

Assert(!stackSym->m_isEncodedConstant);

if (stackSym->m_instrDef == this)

{

Assert(!dstOpnd->isFakeDst);

if (stackSym->IsConst())

{

// keep the instruction around so we can get the constant value

// from the symbol

return;

}

Assert(this->m_func->GetTopFunc()->allowRemoveBailOutArgInstr || !stackSym->m_isBailOutReferenced);

stackSym->m_instrDef = nullptr;

}

else

{

Assert(dstOpnd->isFakeDst);

}

}

else

{

// Encoded constants are not single-defs anymore, and therefore not isConst.

Assert((!stackSym->m_isConst && stackSym->constantValue == 0)

|| (stackSym->m_isEncodedConstant && stackSym->constantValue != 0));

}

}

}

ClearBailOutInfo();

JitAdelete(this->m_func->m_alloc, this);

}

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

///

/// Instr::Unlink

///

/// Unlink this instr from the instr list.

///

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

void

Instr::Unlink()

{

m_prev->m_next = m_next;

if (m_next)

{

m_next->m_prev = m_prev;

}

else

{

Assert(this == this->m_func->m_tailInstr);

}

#if DBG_DUMP

// Transferring the globOptInstrString to the next non-Label Instruction

if(this->globOptInstrString != nullptr && m_next && m_next->globOptInstrString == nullptr && !m_next->IsLabelInstr())

{

m_next->globOptInstrString = this->globOptInstrString;

}

#endif

#if DBG

m_prev = nullptr;

m_next = nullptr;

#endif

}

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

///

/// Instr::Remove

///

/// Unlink and free this instr.

///

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

void

Instr::Remove()

{

this->Unlink();

this->Free();

}

void

Instr::SwapOpnds()

{

IR::Opnd *opndTemp = m_src1;

m_src1 = m_src2;

m_src2 = opndTemp;

}

// Copy a vanilla instruction.

Instr *

Instr::Copy()

{

Instr * instrCopy;

if (this->HasBailOutInfo() || this->HasAuxBailOut())

{

instrCopy = BailOutInstr::New(this->m_opcode, this->GetBailOutKind(), this->GetBailOutInfo(), this->m_func);

instrCopy->SetByteCodeOffset(this->GetByteCodeOffset());

if (this->HasAuxBailOut())

{

instrCopy->hasAuxBailOut = true;

instrCopy->SetAuxBailOutKind(this->GetAuxBailOutKind());

}

}

else

{

switch (this->GetKind())

{

case InstrKindInstr:

instrCopy = Instr::New(this->m_opcode, this->m_func);

break;

case InstrKindProfiled:

instrCopy = this->AsProfiledInstr()->CopyProfiledInstr();

break;

case InstrKindJitProfiling:

instrCopy = this->AsJitProfilingInstr()->CopyJitProfiling();

break;

case InstrKindPragma:

instrCopy = this->AsPragmaInstr()->CopyPragma();

break;

default:

instrCopy = nullptr;

AnalysisAssertMsg(UNREACHED, "Copy of other instr kinds NYI");

}

}

Opnd * opnd = this->GetDst();

if (opnd)

{

instrCopy->SetDst(opnd->Copy(this->m_func));

}

opnd = this->GetSrc1();

if (opnd)

{

instrCopy->SetSrc1(opnd->Copy(this->m_func));

opnd = this->GetSrc2();

if (opnd)

{

instrCopy->SetSrc2(opnd->Copy(this->m_func));

}

}

instrCopy->isInlineeEntryInstr = this->isInlineeEntryInstr;

if (this->m_func->DoMaintainByteCodeOffset())

{

instrCopy->SetByteCodeOffset(this->GetByteCodeOffset());

}

instrCopy->usesStackArgumentsObject = this->usesStackArgumentsObject;

return instrCopy;

}

LabelInstr *

LabelInstr::CloneLabel(BOOL fCreate)

{

Func * func = this->m_func;

Cloner * cloner = func->GetCloner();

IR::LabelInstr * instrLabel = nullptr;

AssertMsg(cloner, "Use Func::BeginClone to initialize cloner");

if (cloner->labelMap == nullptr)

{

if (!fCreate)

{

return nullptr;

}

cloner->labelMap = HashTable<LabelInstr*>::New(cloner->alloc, 7);

}

else

{

IR::LabelInstr ** map = cloner->labelMap->Get(this->m_id);

if (map)

{

instrLabel = *map;

}

}

if (instrLabel == nullptr)

{

if (!fCreate)

{

return nullptr;

}

if (this->IsProfiledLabelInstr())

{

instrLabel = IR::ProfiledLabelInstr::New(this->m_opcode, func, this->AsProfiledLabelInstr()->loopImplicitCallFlags, this->AsProfiledLabelInstr()->loopFlags);

#if DBG

instrLabel->AsProfiledLabelInstr()->loopNum = this->AsProfiledLabelInstr()->loopNum;

#endif

}

else

{

instrLabel = IR::LabelInstr::New(this->m_opcode, func, this->isOpHelper);

}

instrLabel->m_isLoopTop = this->m_isLoopTop;

cloner->labelMap->FindOrInsert(instrLabel, this->m_id);

}

return instrLabel;

}

ProfiledLabelInstr::ProfiledLabelInstr(JitArenaAllocator * allocator)

: LabelInstr(allocator)

{

}

ProfiledLabelInstr *

ProfiledLabelInstr::New(Js::OpCode opcode, Func *func, Js::ImplicitCallFlags flags, Js::LoopFlags loopFlags)

{

ProfiledLabelInstr * profiledLabelInstr = JitAnew(func->m_alloc, ProfiledLabelInstr, func->m_alloc);

profiledLabelInstr->Init(opcode, InstrKindProfiledLabel, func, false);

profiledLabelInstr->loopImplicitCallFlags = flags;

profiledLabelInstr->loopFlags = loopFlags;

return profiledLabelInstr;

}

void

BranchInstr::RetargetClonedBranch()

{

IR::LabelInstr * instrLabel = this->m_branchTarget->CloneLabel(false);

if (instrLabel == nullptr)

{

// Jumping outside the cloned range. No retarget.

return;

}

this->SetTarget(instrLabel);

}

PragmaInstr *

PragmaInstr::ClonePragma()

{

return this->CopyPragma();

}

PragmaInstr *

PragmaInstr::CopyPragma()

{

IR::PragmaInstr * instrPragma = IR::PragmaInstr::New(this->m_opcode, 0, this->m_func);

return instrPragma;

}

Instr *

Instr::CloneInstr() const

{

if (this->HasBailOutInfo() || this->HasAuxBailOut())

{

return ((BailOutInstr *)this)->CloneBailOut();

}

IR::Instr *clone = IR::Instr::New(this->m_opcode, this->m_func);

clone->isInlineeEntryInstr = this->isInlineeEntryInstr;

return clone;

}

// Clone a vanilla instruction, replacing single-def StackSym's with new syms where appropriate.

Instr *

Instr::Clone()

{

Func * func = this->m_func;

Cloner *cloner = func->GetCloner();

IR::Instr * instrClone;

IR::Opnd * opnd;

switch (this->GetKind())

{

case InstrKindInstr:

instrClone = this->CloneInstr();

break;

case InstrKindBranch:

instrClone = this->AsBranchInstr()->CloneBranchInstr();

break;

case InstrKindProfiled:

instrClone = this->AsProfiledInstr()->CloneProfiledInstr();

break;

case InstrKindLabel:

case InstrKindProfiledLabel:

instrClone = this->AsLabelInstr()->CloneLabel(true);

break;

case InstrKindPragma:

instrClone = this->AsPragmaInstr()->ClonePragma();

break;

case InstrKindJitProfiling:

instrClone = this->AsJitProfilingInstr()->CloneJitProfiling();

break;

default:

AssertMsg(0, "Clone of this instr kind NYI");

return nullptr;

}

opnd = this->GetDst();

if (opnd)

{

instrClone->SetDst(opnd->CloneDef(func));

}

opnd = this->GetSrc1();

if (opnd)

{

instrClone->SetSrc1(opnd->CloneUse(func));

opnd = this->GetSrc2();

if (opnd)

{

instrClone->SetSrc2(opnd->CloneUse(func));

}

}

if (this->m_func->DoMaintainByteCodeOffset())

{

instrClone->SetByteCodeOffset(this->GetByteCodeOffset());

}

instrClone->usesStackArgumentsObject = this->usesStackArgumentsObject;

cloner->AddInstr(this, instrClone);

return instrClone;

}

// Clone a range of instructions.

Instr *

Instr::CloneRange(

Instr * instrStart, Instr * instrLast, Instr * instrAfter, Lowerer *lowerer, JitArenaAllocator * alloc, bool (*fMapTest)(IR::Instr*), bool clonedInstrGetOrigArgSlotSym)

{

IR::Instr * instrReturn = instrAfter;

Func * topFunc = instrStart->m_func->GetTopFunc();

topFunc->BeginClone(lowerer, alloc);

topFunc->GetCloner()->clonedInstrGetOrigArgSlotSym = clonedInstrGetOrigArgSlotSym;

FOREACH_INSTR_IN_RANGE(instr, instrStart, instrLast)

{

Instr * instrClone = instr->Clone();

instrAfter->InsertAfter(instrClone);

instrAfter = instrClone;

instr->isCloned = true;

if (fMapTest(instrClone))

{

IR::LabelInstr *instrLabel = IR::LabelInstr::New(Js::OpCode::Label, instr->m_func);

instrClone->InsertBefore(instrLabel);

topFunc->GetCloneMap()->Item(instr, instrLabel);

}

}

NEXT_INSTR_IN_RANGE;

topFunc->EndClone();

return instrReturn;

}

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

///

/// Instr::MoveRangeAfter

///

/// Move a range of instruction after another instruction

///

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

void

Instr::MoveRangeAfter(Instr * instrStart, Instr * instrLast, Instr * instrAfter)

{

if (instrLast->m_next != nullptr)

{

instrLast->m_next->m_prev = instrStart->m_prev;

}

else

{

instrLast->m_func->m_tailInstr = instrStart->m_prev;

}

if (instrStart->m_prev != nullptr)

{

instrStart->m_prev->m_next = instrLast->m_next;

}

else

{

instrStart->m_func->m_headInstr = instrLast->m_next;

}

instrStart->m_prev = instrAfter;

instrLast->m_next = instrAfter->m_next;

if (instrAfter->m_next != nullptr)

{

instrAfter->m_next->m_prev = instrLast;

}

else

{

instrAfter->m_func->m_tailInstr = instrLast;

}

instrAfter->m_next = instrStart;

}

JitProfilingInstr *

JitProfilingInstr::New(Js::OpCode opcode, Opnd *dstOpnd, Opnd *src1Opnd, Opnd *src2Opnd, Func * func)

{

JitProfilingInstr * profiledInstr = JitProfilingInstr::New(opcode, dstOpnd, src1Opnd, func);

profiledInstr->SetSrc2(src2Opnd);

return profiledInstr;

}

JitProfilingInstr *

JitProfilingInstr::New(Js::OpCode opcode, Opnd *dstOpnd, Opnd *src1Opnd, Func * func)

{

Assert(func->DoSimpleJitDynamicProfile());

JitProfilingInstr * profiledInstr = JitAnew(func->m_alloc, IR::JitProfilingInstr);

profiledInstr->Init(opcode, InstrKindJitProfiling, func);

if (dstOpnd)

{

profiledInstr->SetDst(dstOpnd);

}

if (src1Opnd)

{

profiledInstr->SetSrc1(src1Opnd);

}

#if DBG

profiledInstr->profileId = Js::Constants::NoProfileId;

profiledInstr->arrayProfileId = Js::Constants::NoProfileId;

profiledInstr->inlineCacheIndex = Js::Constants::NoInlineCacheIndex;

Assert(profiledInstr->loopNumber == 0u - 1);

#endif

// default these to false.

profiledInstr->isProfiledReturnCall = false;

profiledInstr->isBeginSwitch = false;

profiledInstr->isNewArray = false;

profiledInstr->isLoopHelper = false;

return profiledInstr;

}

JitProfilingInstr*

JitProfilingInstr::CloneJitProfiling() const

{

// Adapted from Profiled::CloneProfiledInstr. Note that the dst and srcs are not set.

Assert(!(this->HasBailOutInfo() || this->HasAuxBailOut())); // Shouldn't have bailout info in a jitprofiling instr

return this->CopyJitProfiling();

}

JitProfilingInstr*

JitProfilingInstr::CopyJitProfiling() const

{

// Adapted from Profiled::CopyProfiledInstr. Note that the dst and srcs are not set.

IR::JitProfilingInstr * jitProfInstr;

jitProfInstr = JitAnew(this->m_func->m_alloc, IR::JitProfilingInstr);

jitProfInstr->Init(this->m_opcode, InstrKindProfiled, this->m_func);

jitProfInstr->isProfiledReturnCall = this->isProfiledReturnCall;

jitProfInstr->isBeginSwitch = this->isBeginSwitch;

jitProfInstr->isNewArray = this->isNewArray;

jitProfInstr->isLoopHelper = this->isLoopHelper;

jitProfInstr->profileId = this->profileId;

jitProfInstr->arrayProfileId = this->arrayProfileId;

jitProfInstr->inlineCacheIndex = this->inlineCacheIndex;

Assert(jitProfInstr->loopNumber == this->loopNumber);

return jitProfInstr;

}

ProfiledInstr *

ProfiledInstr::New(Js::OpCode opcode, Opnd *dstOpnd, Opnd *src1Opnd, Opnd *src2Opnd, Func * func)

{

ProfiledInstr * profiledInstr = ProfiledInstr::New(opcode, dstOpnd, src1Opnd, func);

profiledInstr->SetSrc2(src2Opnd);

return profiledInstr;

}

ProfiledInstr *

ProfiledInstr::New(Js::OpCode opcode, Opnd *dstOpnd, Opnd *src1Opnd, Func * func)

{

ProfiledInstr * profiledInstr = JitAnew(func->m_alloc, IR::ProfiledInstr);

profiledInstr->Init(opcode, InstrKindProfiled, func);

if (dstOpnd)

{

profiledInstr->SetDst(dstOpnd);

}

if (src1Opnd)

{

profiledInstr->SetSrc1(src1Opnd);

}

profiledInstr->u.ldElemInfo = nullptr;

return profiledInstr;

}

ProfiledInstr *

ProfiledInstr::CloneProfiledInstr() const

{

IR::ProfiledInstr * profiledInstr;

if (this->HasBailOutInfo() || this->HasAuxBailOut())

{

profiledInstr = ((ProfiledBailOutInstr *)this)->CloneBailOut();

profiledInstr->u = this->u;

}

else

{

profiledInstr = this->CopyProfiledInstr();

}

return profiledInstr;

}

ProfiledInstr *

ProfiledInstr::CopyProfiledInstr() const

{

IR::ProfiledInstr * profiledInstr;

profiledInstr = JitAnew(this->m_func->m_alloc, IR::ProfiledInstr);

profiledInstr->Init(this->m_opcode, InstrKindProfiled, this->m_func);

profiledInstr->u = this->u;

return profiledInstr;

}

ByteCodeUsesInstr *

ByteCodeUsesInstr::New(IR::Instr * originalBytecodeInstr)

{

Func* func = originalBytecodeInstr->m_func;

ByteCodeUsesInstr * byteCodeUses = JitAnew(func->m_alloc, IR::ByteCodeUsesInstr);

byteCodeUses->Init(Js::OpCode::ByteCodeUses, InstrKindByteCodeUses, func);

byteCodeUses->byteCodeUpwardExposedUsed = nullptr;

byteCodeUses->propertySymUse = nullptr;

byteCodeUses->SetByteCodeOffset(originalBytecodeInstr);

return byteCodeUses;

}

ByteCodeUsesInstr *

ByteCodeUsesInstr::New(Func * func, uint32 offset)

{

ByteCodeUsesInstr * byteCodeUses = JitAnew(func->m_alloc, IR::ByteCodeUsesInstr);

byteCodeUses->Init(Js::OpCode::ByteCodeUses, InstrKindByteCodeUses, func);

byteCodeUses->byteCodeUpwardExposedUsed = nullptr;

byteCodeUses->propertySymUse = nullptr;

byteCodeUses->SetByteCodeOffset(offset);

return byteCodeUses;

}

const BVSparse<JitArenaAllocator> * ByteCodeUsesInstr::GetByteCodeUpwardExposedUsed() const

{

return this->byteCodeUpwardExposedUsed;

}

// In the case of instances where you would like to add a ByteCodeUses to some sym,

// which doesn't have an operand associated with it (like a block closure sym), use

// this to set it without needing to pass the check for JIT-Optimized registers.

void ByteCodeUsesInstr::SetNonOpndSymbol(uint symId)

{

if (!this->byteCodeUpwardExposedUsed)

{

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

}

this->byteCodeUpwardExposedUsed->Set(symId);

}

// In cases where the operand you're working on may be changed between when you get

// access to it and when you determine that you can set it in the ByteCodeUsesInstr

// set method, cache the values and use this caller.

void ByteCodeUsesInstr::SetRemovedOpndSymbol(bool isJITOptimizedReg, uint symId)

{

if (isJITOptimizedReg)

{

AssertMsg(false, "Tried to add a jit-optimized register to a ByteCodeUses instruction!");

// Although we assert on debug builds, we should actually be ok with release builds

// if we ignore the operand; not ignoring it, however, can cause us to introduce an

// inconsistency in bytecode register lifetimes.

return;

}

if(!this->byteCodeUpwardExposedUsed)

{

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

}

this->byteCodeUpwardExposedUsed->Set(symId);

}

void ByteCodeUsesInstr::Set(IR::Opnd * originalOperand)

{

Assert(originalOperand && originalOperand->GetStackSym());

bool isJITOptimizedReg = originalOperand->GetIsJITOptimizedReg();

SymID symId = originalOperand->GetStackSym()->m_id;

if (isJITOptimizedReg)

{

AssertMsg(false, "Tried to add a jit-optimized register to a ByteCodeUses instruction!");

// Although we assert on debug builds, we should actually be ok with release builds

// if we ignore the operand; not ignoring it, however, can cause us to introduce an

// inconsistency in bytecode register lifetimes.

return;

}

if (!this->byteCodeUpwardExposedUsed)

{

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

}

this->byteCodeUpwardExposedUsed->Set(symId);

}

void ByteCodeUsesInstr::Clear(uint symId)

{

Assert(byteCodeUpwardExposedUsed != nullptr);

this->byteCodeUpwardExposedUsed->Clear(symId);

}

void ByteCodeUsesInstr::SetBV(BVSparse<JitArenaAllocator>* newbv)

{

Assert(byteCodeUpwardExposedUsed == nullptr && newbv != nullptr);

byteCodeUpwardExposedUsed = newbv;

}

// If possible, we want to aggregate with subsequent ByteCodeUses Instructions, so

// that we can do some optimizations in other places where we can simplify args in

// a compare, but still need to generate them for bailouts. Without this, we cause

// problems because we end up with an instruction losing atomicity in terms of its

// bytecode use and generation lifetimes.

void ByteCodeUsesInstr::Aggregate()

{

IR::Instr* scanner = this->m_next;

while (scanner && scanner->m_opcode == Js::OpCode::ByteCodeUses && scanner->GetByteCodeOffset() == this->GetByteCodeOffset() && scanner->GetDst() == nullptr)

{

IR::ByteCodeUsesInstr* target = scanner->AsByteCodeUsesInstr();

Assert(this->m_func == target->m_func);

if (target->byteCodeUpwardExposedUsed)

{

if (this->byteCodeUpwardExposedUsed)

{

this->byteCodeUpwardExposedUsed->Or(target->byteCodeUpwardExposedUsed);

JitAdelete(target->byteCodeUpwardExposedUsed->GetAllocator(), target->byteCodeUpwardExposedUsed);

target->byteCodeUpwardExposedUsed = nullptr;

}

else

{

this->byteCodeUpwardExposedUsed = target->byteCodeUpwardExposedUsed;

target->byteCodeUpwardExposedUsed = nullptr;

}

}

scanner = scanner->m_next;

}

}

BailOutInfo *

Instr::GetBailOutInfo() const

{

Assert(this->HasBailOutInfo() || this->HasAuxBailOut());

switch (this->m_kind)

{

case InstrKindInstr: