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

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

#include "ByteCode\OpCodeUtilAsmJs.h"

void

IRBuilderAsmJs::Build()

{

m_funcAlloc = m_func->m_alloc;

NoRecoverMemoryJitArenaAllocator localAlloc(L"BE-IRBuilder", m_funcAlloc->GetPageAllocator(), Js::Throw::OutOfMemory);

m_tempAlloc = &localAlloc;

uint32 offset;

uint32 statementIndex = m_statementReader.GetStatementIndex();

m_argStack = JitAnew(m_tempAlloc, SList<IR::Instr *>, m_tempAlloc);

m_tempList = JitAnew(m_tempAlloc, SList<IR::Instr *>, m_tempAlloc);

m_argOffsetStack = JitAnew(m_tempAlloc, SList<int32>, m_tempAlloc);

m_branchRelocList = JitAnew(m_tempAlloc, SList<BranchReloc *>, m_tempAlloc);

m_switchBuilder.Init(m_func, m_tempAlloc, true);

m_firstVarConst = 0;

m_firstIntConst = AsmJsRegSlots::RegCount + m_firstVarConst;

m_firstFloatConst = m_asmFuncInfo->GetIntConstCount() + m_firstIntConst;

m_firstDoubleConst = m_asmFuncInfo->GetFloatConstCount() + m_firstFloatConst;

m_firstSimdConst = m_asmFuncInfo->GetDoubleConstCount() + m_firstDoubleConst;

m_firstIntVar = m_asmFuncInfo->GetSimdConstCount() + m_firstSimdConst;

m_firstFloatVar = m_asmFuncInfo->GetIntVarCount() + m_firstIntVar;

m_firstDoubleVar = m_asmFuncInfo->GetFloatVarCount() + m_firstFloatVar;

m_firstSimdVar = m_asmFuncInfo->GetDoubleVarCount() + m_firstDoubleVar;

m_firstIntTemp = m_asmFuncInfo->GetSimdVarCount() + m_firstSimdVar;

m_firstFloatTemp = m_asmFuncInfo->GetIntTmpCount() + m_firstIntTemp;

m_firstDoubleTemp = m_asmFuncInfo->GetFloatTmpCount() + m_firstFloatTemp;

m_firstSimdTemp = m_asmFuncInfo->GetDoubleTmpCount() + m_firstDoubleTemp;

m_firstIRTemp = m_asmFuncInfo->GetSimdTmpCount() + m_firstSimdTemp;

m_simdOpcodesMap = JitAnewArrayZ(m_tempAlloc, Js::OpCode, Js::Simd128AsmJsOpcodeCount());

{

#define MACRO_SIMD(opcode, asmjsLayout, opCodeAttrAsmJs, OpCodeAttr, ...) m_simdOpcodesMap[(uint32)(Js::OpCodeAsmJs::opcode - Js::OpCodeAsmJs::Simd128_Start)] = Js::OpCode::opcode;

#define MACRO_SIMD_WMS(opcode, asmjsLayout, opCodeAttrAsmJs, OpCodeAttr, ...) MACRO_SIMD(opcode, asmjsLayout, opCodeAttrAsmJs, OpCodeAttr)

// append extended opcodes

#define MACRO_SIMD_EXTEND(opcode, asmjsLayout, opCodeAttrAsmJs, OpCodeAttr, ...) \

m_simdOpcodesMap[(uint32)(Js::OpCodeAsmJs::opcode - Js::OpCodeAsmJs::Simd128_Start_Extend) + (Js::OpCodeAsmJs::Simd128_End - Js::OpCodeAsmJs::Simd128_Start + 1)] = Js::OpCode::opcode;

#define MACRO_SIMD_EXTEND_WMS(opcode, asmjsLayout, opCodeAttrAsmJs, OpCodeAttr, ...) MACRO_SIMD_EXTEND(opcode, asmjsLayout, opCodeAttrAsmJs, OpCodeAttr)

#include "ByteCode\OpCodesSimd.h"

}

// we will be using lower space for type specialized syms, so bump up where new temp syms can be created

m_func->m_symTable->IncreaseStartingID(m_firstIRTemp - m_func->m_symTable->GetMaxSymID());

Js::RegSlot tempCount = m_asmFuncInfo->GetDoubleTmpCount() + m_asmFuncInfo->GetFloatTmpCount() + m_asmFuncInfo->GetIntTmpCount();

tempCount += m_asmFuncInfo->GetSimdTmpCount();

if (tempCount > 0)

{

m_tempMap = (SymID*)m_tempAlloc->AllocZero(sizeof(SymID) * tempCount);

m_fbvTempUsed = BVFixed::New<JitArenaAllocator>(tempCount, m_tempAlloc);

}

else

{

m_tempMap = nullptr;

m_fbvTempUsed = nullptr;

}

m_func->m_headInstr = IR::EntryInstr::New(Js::OpCode::FunctionEntry, m_func);

m_func->m_exitInstr = IR::ExitInstr::New(Js::OpCode::FunctionExit, m_func);

m_func->m_tailInstr = m_func->m_exitInstr;

m_func->m_headInstr->InsertAfter(m_func->m_tailInstr);

m_func->m_isLeaf = true; // until proven otherwise

m_functionStartOffset = m_jnReader.GetCurrentOffset();

m_lastInstr = m_func->m_headInstr;

AssertMsg(sizeof(SymID) >= sizeof(Js::RegSlot), "sizeof(SymID) != sizeof(Js::RegSlot)!!");

offset = m_functionStartOffset;

// Skip the last EndOfBlock opcode

// EndOfBlock opcode has same value in Asm

Assert(!OpCodeAttr::HasMultiSizeLayout(Js::OpCode::EndOfBlock));

uint32 lastOffset = m_func->GetJnFunction()->GetByteCode()->GetLength() - Js::OpCodeUtil::EncodedSize(Js::OpCode::EndOfBlock, Js::SmallLayout);

uint32 offsetToInstructionCount = lastOffset;

Js::FunctionBody *funcBody = m_func->GetJnFunction()->GetFunctionBody();

if (this->IsLoopBody())

{

// LdSlot needs to cover all the register, including the temps, because we might treat

// those as if they are local for the value of the with statement

this->m_ldSlots = BVFixed::New<JitArenaAllocator>(m_firstIntTemp + tempCount, m_tempAlloc);

this->m_stSlots = BVFixed::New<JitArenaAllocator>(m_firstIntTemp, m_tempAlloc);

this->m_loopBodyRetIPSym = StackSym::New(TyInt32, this->m_func);

#if DBG

if (funcBody->GetTempCount() != 0)

{

this->m_usedAsTemp = BVFixed::New<JitArenaAllocator>(funcBody->GetTempCount(), m_tempAlloc);

}

#endif

JsLoopBodyCodeGen* loopBodyCodeGen = (JsLoopBodyCodeGen*)m_func->m_workItem;

lastOffset = loopBodyCodeGen->loopHeader->endOffset;

// Ret is created at lastOffset + 1, so we need lastOffset + 2 entries

offsetToInstructionCount = lastOffset + 2;

}

#if DBG

m_offsetToInstructionCount = offsetToInstructionCount;

#endif

m_offsetToInstruction = JitAnewArrayZ(m_tempAlloc, IR::Instr *, offsetToInstructionCount);

BuildConstantLoads();

if (!this->IsLoopBody() && m_func->GetJnFunction()->GetHasImplicitArgIns())

{

BuildImplicitArgIns();

}

if (m_statementReader.AtStatementBoundary(&m_jnReader))

{

statementIndex = AddStatementBoundary(statementIndex, offset);

}

Js::LayoutSize layoutSize;

for (Js::OpCodeAsmJs newOpcode = (Js::OpCodeAsmJs)m_jnReader.ReadOp(layoutSize); (uint)m_jnReader.GetCurrentOffset() <= lastOffset; newOpcode = (Js::OpCodeAsmJs)m_jnReader.ReadOp(layoutSize))

{

Assert(newOpcode != Js::OpCodeAsmJs::EndOfBlock);

AssertMsg(Js::OpCodeUtilAsmJs::IsValidByteCodeOpcode(newOpcode), "Error getting opcode from m_jnReader.Op()");

uint layoutAndSize = layoutSize * Js::OpLayoutTypeAsmJs::Count + Js::OpCodeUtilAsmJs::GetOpCodeLayout(newOpcode);

switch (layoutAndSize)

{

#define LAYOUT_TYPE(layout) \

case Js::OpLayoutTypeAsmJs::layout: \

Assert(layoutSize == Js::SmallLayout); \

Build##layout(newOpcode, offset); \

break;

#define LAYOUT_TYPE_WMS(layout) \

case Js::SmallLayout * Js::OpLayoutTypeAsmJs::Count + Js::OpLayoutTypeAsmJs::layout: \

Build##layout<Js::SmallLayoutSizePolicy>(newOpcode, offset); \

break; \

case Js::MediumLayout * Js::OpLayoutTypeAsmJs::Count + Js::OpLayoutTypeAsmJs::layout: \

Build##layout<Js::MediumLayoutSizePolicy>(newOpcode, offset); \

break; \

case Js::LargeLayout * Js::OpLayoutTypeAsmJs::Count + Js::OpLayoutTypeAsmJs::layout: \

Build##layout<Js::LargeLayoutSizePolicy>(newOpcode, offset); \

break;

#define EXCLUDE_FRONTEND_LAYOUT

#include "ByteCode\LayoutTypesAsmJs.h"

default:

AssertMsg(UNREACHED, "Unimplemented layout");

break;

}

offset = m_jnReader.GetCurrentOffset();

if (m_statementReader.AtStatementBoundary(&m_jnReader))

{

statementIndex = AddStatementBoundary(statementIndex, offset);

}

}

if (Js::Constants::NoStatementIndex != statementIndex)

{

statementIndex = AddStatementBoundary(statementIndex, Js::Constants::NoByteCodeOffset);

}

if (IsLoopBody())

{

// Insert the LdSlot/StSlot and Ret

IR::Opnd * retOpnd = this->InsertLoopBodyReturnIPInstr(offset, offset);

// Restore and Ret are at the last offset + 1

GenerateLoopBodySlotAccesses(lastOffset + 1);

IR::Instr * retInstr = IR::Instr::New(Js::OpCode::Ret, m_func);

retInstr->SetSrc1(retOpnd);

this->AddInstr(retInstr, lastOffset + 1);

}

// Now fix up the targets for all the branches we've introduced.

InsertLabels();

// Now that we know whether the func is a leaf or not, decide whether we'll emit fast paths.

// Do this once and for all, per-func, since the source size on the ThreadContext will be

// changing while we JIT.

if (m_func->IsTopFunc())

{

m_func->SetDoFastPaths();

}

}

void

IRBuilderAsmJs::AddInstr(IR::Instr * instr, uint32 offset)

{

m_lastInstr->InsertAfter(instr);

if (offset != Js::Constants::NoByteCodeOffset)

{

Assert(offset < m_offsetToInstructionCount);

if (m_offsetToInstruction[offset] == nullptr)

{

m_offsetToInstruction[offset] = instr;

}

else

{

Assert(m_lastInstr->GetByteCodeOffset() == offset);

}

instr->SetByteCodeOffset(offset);

}

else if (m_lastInstr)

{

instr->SetByteCodeOffset(m_lastInstr->GetByteCodeOffset());

}

m_lastInstr = instr;

Func *topFunc = m_func->GetTopFunc();

if (!topFunc->GetHasTempObjectProducingInstr())

{

if (OpCodeAttr::TempObjectProducing(instr->m_opcode))

{

topFunc->SetHasTempObjectProducingInstr(true);

}

}

#if DBG_DUMP

if (Js::Configuration::Global.flags.Trace.IsEnabled(Js::IRBuilderPhase, m_func->GetTopFunc()->GetSourceContextId(), m_func->GetTopFunc()->GetLocalFunctionId()))

{

instr->Dump();

}

#endif

}

IR::RegOpnd *

IRBuilderAsmJs::BuildDstOpnd(Js::RegSlot dstRegSlot, IRType type)

{

SymID symID;

if (RegIsTemp(dstRegSlot))

{

#if DBG

if (this->IsLoopBody())

{

// If we are doing loop body, and a temp reg slot is loaded via LdSlot

// That means that we have detected that the slot is live coming in to the loop.

// This would only happen for the value of a "with" statement, so there shouldn't

// be any def for those

Assert(!this->m_ldSlots->Test(dstRegSlot));

this->m_usedAsTemp->Set(dstRegSlot - m_firstIntTemp);

}

#endif

// This is a def of a temp. Create a new sym ID for it if it's been used since its last def.

// !!!NOTE: always process an instruction's temp uses before its temp defs!!!

if (GetTempUsed(dstRegSlot))

{

symID = m_func->m_symTable->NewID();

SetTempUsed(dstRegSlot, FALSE);

SetMappedTemp(dstRegSlot, symID);

}

else

{

symID = GetMappedTemp(dstRegSlot);

// The temp hasn't been used since its last def. There are 2 possibilities:

if (symID == 0)

{

// First time we've seen the temp. Just use the number that the front end gave it.

symID = static_cast<SymID>(dstRegSlot);

SetMappedTemp(dstRegSlot, symID);

}

}

}

else

{

symID = static_cast<SymID>(dstRegSlot);

if (RegIsConstant(dstRegSlot))

{

// Don't need to track constant registers for bailout. Don't set the byte code register for constant.

dstRegSlot = Js::Constants::NoRegister;

}

else if (IsLoopBody() && RegIsVar(dstRegSlot))

{

// Loop body and not constants

this->m_stSlots->Set(symID);

// We need to make sure that the symbols is loaded as well

// so that the sym will be defined on all path.

this->EnsureLoopBodyAsmJsLoadSlot(symID, type);

}

else

{

Assert(!IsLoopBody() || dstRegSlot == 0); // if loop body then one of the above two conditions should hold true

}

}

StackSym * symDst = StackSym::FindOrCreate(symID, dstRegSlot, m_func, type);

// Always reset isSafeThis to false. We'll set it to true for singleDef cases,

// but want to reset it to false if it is multi-def.

// NOTE: We could handle the multiDef if they are all safe, but it probably isn't very common.

symDst->m_isSafeThis = false;

IR::RegOpnd *regOpnd = IR::RegOpnd::New(symDst, type, m_func);

return regOpnd;

}

IR::RegOpnd *

IRBuilderAsmJs::BuildSrcOpnd(Js::RegSlot srcRegSlot, IRType type)

{

StackSym * symSrc = m_func->m_symTable->FindStackSym(BuildSrcStackSymID(srcRegSlot, type));

AssertMsg(symSrc, "Tried to use an undefined stack slot?");

IR::RegOpnd * regOpnd = IR::RegOpnd::New(symSrc, type, m_func);

return regOpnd;

}

IR::RegOpnd *

IRBuilderAsmJs::BuildIntConstOpnd(Js::RegSlot regSlot)

{

Js::Var * constTable = static_cast<Js::Var *>(m_func->GetJnFunction()->GetConstTable());

int * intConstTable = reinterpret_cast<int *>(constTable + Js::AsmJsFunctionMemory::RequiredVarConstants - 1);

uint32 intConstCount = m_func->GetJnFunction()->GetAsmJsFunctionInfo()->GetIntConstCount();

Assert(regSlot >= Js::FunctionBody::FirstRegSlot && regSlot < intConstCount);

const int32 value = intConstTable[regSlot];

IR::IntConstOpnd *opnd = IR::IntConstOpnd::New(value, TyInt32, m_func);

return (IR::RegOpnd*)opnd;

}

SymID

IRBuilderAsmJs::BuildSrcStackSymID(Js::RegSlot regSlot, IRType type /*= IRType::TyVar*/)

{

SymID symID;

if (this->RegIsTemp(regSlot))

{

// This is a use of a temp. Map the reg slot to its sym ID.

// !!!NOTE: always process an instruction's temp uses before its temp defs!!!

symID = this->GetMappedTemp(regSlot);

if (symID == 0)

{

// We might have temps that are live through the loop body via "with" statement

// We need to treat those as if they are locals and don't remap them

Assert(this->IsLoopBody());

Assert(!this->m_usedAsTemp->Test(regSlot - m_firstIntTemp));

symID = static_cast<SymID>(regSlot);

this->SetMappedTemp(regSlot, symID);

this->EnsureLoopBodyAsmJsLoadSlot(symID, type);

}

this->SetTempUsed(regSlot, TRUE);

}

else

{

symID = static_cast<SymID>(regSlot);

if (IsLoopBody() && RegIsVar(regSlot))

{

this->EnsureLoopBodyAsmJsLoadSlot(symID, type);

}

else

{

Assert(!IsLoopBody() || this->RegIsConstant(regSlot) || regSlot == 0);

}

}

return symID;

}

IR::SymOpnd *

IRBuilderAsmJs::BuildFieldOpnd(Js::RegSlot reg, Js::PropertyId propertyId, PropertyKind propertyKind, IRType type, bool scale)

{

Js::PropertyId scaledPropertyId = propertyId;

if (scale)

{

scaledPropertyId *= TySize[type];

}

PropertySym * propertySym = BuildFieldSym(reg, scaledPropertyId, propertyKind);

IR::SymOpnd * symOpnd = IR::SymOpnd::New(propertySym, type, m_func);

return symOpnd;

}

PropertySym *

IRBuilderAsmJs::BuildFieldSym(Js::RegSlot reg, Js::PropertyId propertyId, PropertyKind propertyKind)

{

SymID symId = BuildSrcStackSymID(reg);

AssertMsg(m_func->m_symTable->FindStackSym(symId), "Tried to use an undefined stacksym?");

PropertySym * propertySym = PropertySym::FindOrCreate(symId, propertyId, (Js::PropertyIdIndexType)-1, (uint)-1, propertyKind, m_func);

return propertySym;

}

uint

IRBuilderAsmJs::AddStatementBoundary(uint statementIndex, uint offset)

{

IR::PragmaInstr* pragmaInstr = IR::PragmaInstr::New(Js::OpCode::StatementBoundary, statementIndex, m_func);

this->AddInstr(pragmaInstr, offset);

return m_statementReader.MoveNextStatementBoundary();

}

Js::RegSlot

IRBuilderAsmJs::GetRegSlotFromIntReg(Js::RegSlot srcIntReg)

{

Assert(m_asmFuncInfo->GetIntConstCount() >= 0);

Js::RegSlot reg;

if (srcIntReg < (Js::RegSlot)m_asmFuncInfo->GetIntConstCount())

{

reg = srcIntReg + m_firstIntConst;

Assert(reg >= m_firstIntConst && reg < m_firstFloatConst);

}

else if (srcIntReg < (Js::RegSlot)(m_asmFuncInfo->GetIntVarCount() + m_asmFuncInfo->GetIntConstCount()))

{

reg = srcIntReg - m_asmFuncInfo->GetIntConstCount() + m_firstIntVar;

Assert(reg >= m_firstIntVar && reg < m_firstFloatVar);

}

else

{

reg = srcIntReg - (m_asmFuncInfo->GetIntVarCount() + m_asmFuncInfo->GetIntConstCount()) + m_firstIntTemp;

Assert(reg >= m_firstIntTemp && reg < m_firstFloatTemp);

}

return reg;

}

Js::RegSlot

IRBuilderAsmJs::GetRegSlotFromFloatReg(Js::RegSlot srcFloatReg)

{

Assert(m_asmFuncInfo->GetFloatConstCount() >= 0);

Js::RegSlot reg;

if (srcFloatReg < (Js::RegSlot)m_asmFuncInfo->GetFloatConstCount())

{

reg = srcFloatReg + m_firstFloatConst;

Assert(reg >= m_firstFloatConst && reg < m_firstDoubleConst);

}

else if (srcFloatReg < (Js::RegSlot)(m_asmFuncInfo->GetFloatVarCount() + m_asmFuncInfo->GetFloatConstCount()))

{

reg = srcFloatReg - m_asmFuncInfo->GetFloatConstCount() + m_firstFloatVar;

Assert(reg >= m_firstFloatVar && reg < m_firstDoubleVar);

}

else

{

reg = srcFloatReg - (m_asmFuncInfo->GetFloatVarCount() + m_asmFuncInfo->GetFloatConstCount()) + m_firstFloatTemp;

Assert(reg >= m_firstFloatTemp && reg < m_firstDoubleTemp);

}

return reg;

}

Js::RegSlot

IRBuilderAsmJs::GetRegSlotFromDoubleReg(Js::RegSlot srcDoubleReg)

{

Assert(m_asmFuncInfo->GetDoubleConstCount() >= 0);

Js::RegSlot reg;

if (srcDoubleReg < (Js::RegSlot)m_asmFuncInfo->GetDoubleConstCount())

{

reg = srcDoubleReg + m_firstDoubleConst;

Assert(reg >= m_firstDoubleConst && reg < m_firstSimdConst);

}

else if (srcDoubleReg < (Js::RegSlot)(m_asmFuncInfo->GetDoubleVarCount() + m_asmFuncInfo->GetDoubleConstCount()))

{

reg = srcDoubleReg - m_asmFuncInfo->GetDoubleConstCount() + m_firstDoubleVar;

Assert(reg >= m_firstDoubleVar && reg < m_firstSimdVar);

}

else

{

reg = srcDoubleReg - (m_asmFuncInfo->GetDoubleVarCount() + m_asmFuncInfo->GetDoubleConstCount()) + m_firstDoubleTemp;

Assert(reg >= m_firstDoubleTemp && reg < m_firstSimdTemp);

}

return reg;

}

Js::RegSlot

IRBuilderAsmJs::GetRegSlotFromSimd128Reg(Js::RegSlot srcSimd128Reg)

{

Js::RegSlot reg;

if (srcSimd128Reg < (uint32)m_asmFuncInfo->GetSimdConstCount())

{

reg = srcSimd128Reg + m_firstSimdConst;

Assert(reg >= m_firstSimdConst && reg < m_firstIntVar);

}

else if (srcSimd128Reg < (Js::RegSlot)(m_asmFuncInfo->GetSimdVarCount() + m_asmFuncInfo->GetSimdConstCount()))

{

reg = srcSimd128Reg - m_asmFuncInfo->GetSimdConstCount() + m_firstSimdVar;

Assert(reg >= m_firstSimdVar && reg < m_firstIntTemp);

}

else

{

reg = srcSimd128Reg - (m_asmFuncInfo->GetSimdVarCount() + m_asmFuncInfo->GetSimdConstCount()) + m_firstSimdTemp;

Assert(reg >= m_firstSimdTemp && reg < m_firstIRTemp);

}

return reg;

}

IR::Instr *

IRBuilderAsmJs::AddExtendedArg(IR::RegOpnd *src1, IR::RegOpnd *src2, uint32 offset)

{

Assert(src1);

IR::RegOpnd * dst = IR::RegOpnd::New(src1->GetType(), m_func);

dst->SetValueType(src1->GetValueType());

IR::Instr * instr = IR::Instr::New(Js::OpCode::ExtendArg_A, dst, src1, m_func);

if (src2)

{

instr->SetSrc2(src2);

}

AddInstr(instr, offset);

return instr;

}

Js::RegSlot

IRBuilderAsmJs::GetRegSlotFromVarReg(Js::RegSlot srcVarReg)

{

Js::RegSlot reg;

if (srcVarReg < (Js::RegSlot)(AsmJsRegSlots::RegCount - 1))

{

reg = srcVarReg + m_firstVarConst;

Assert(reg >= m_firstVarConst && reg < m_firstIntConst);

}

else

{

reg = srcVarReg - AsmJsRegSlots::RegCount + m_firstIntTemp - 1;

Assert(reg >= m_firstIntTemp);

}

return reg;

}

SymID

IRBuilderAsmJs::GetMappedTemp(Js::RegSlot reg)

{

AssertMsg(RegIsTemp(reg), "Processing non-temp reg as a temp?");

AssertMsg(m_tempMap, "Processing non-temp reg without a temp map?");

return m_tempMap[reg - m_firstIntTemp];

}

void

IRBuilderAsmJs::SetMappedTemp(Js::RegSlot reg, SymID tempId)

{

AssertMsg(RegIsTemp(reg), "Processing non-temp reg as a temp?");

AssertMsg(m_tempMap, "Processing non-temp reg without a temp map?");

m_tempMap[reg - m_firstIntTemp] = tempId;

}

BOOL

IRBuilderAsmJs::GetTempUsed(Js::RegSlot reg)

{

AssertMsg(RegIsTemp(reg), "Processing non-temp reg as a temp?");

AssertMsg(m_fbvTempUsed, "Processing non-temp reg without a used BV?");

return m_fbvTempUsed->Test(reg - m_firstIntTemp);

}

void

IRBuilderAsmJs::SetTempUsed(Js::RegSlot reg, BOOL used)

{

AssertMsg(RegIsTemp(reg), "Processing non-temp reg as a temp?");

AssertMsg(m_fbvTempUsed, "Processing non-temp reg without a used BV?");

if (used)

{

m_fbvTempUsed->Set(reg - m_firstIntTemp);

}

else

{

m_fbvTempUsed->Clear(reg - m_firstIntTemp);

}

}

BOOL

IRBuilderAsmJs::RegIsTemp(Js::RegSlot reg)

{

return reg >= m_firstIntTemp;

}

BOOL

IRBuilderAsmJs::RegIsVar(Js::RegSlot reg)

{

BOOL result = RegIsIntVar(reg) || RegIsFloatVar(reg) || RegIsDoubleVar(reg);

result = result || RegIsSimd128Var(reg);

return result;

}

BOOL

IRBuilderAsmJs::RegIsIntVar(Js::RegSlot reg)

{

Js::RegSlot endVarSlotCount = (Js::RegSlot)(m_asmFuncInfo->GetIntVarCount()) + m_firstIntVar;

return reg >= m_firstIntVar && reg < endVarSlotCount;

}

BOOL

IRBuilderAsmJs::RegIsFloatVar(Js::RegSlot reg)

{

Js::RegSlot endVarSlotCount = (Js::RegSlot)(m_asmFuncInfo->GetFloatVarCount()) + m_firstFloatVar;

return reg >= m_firstFloatVar && reg < endVarSlotCount;

}

BOOL

IRBuilderAsmJs::RegIsDoubleVar(Js::RegSlot reg)

{

Js::RegSlot endVarSlotCount = (Js::RegSlot)(m_asmFuncInfo->GetDoubleVarCount()) + m_firstDoubleVar;

return reg >= m_firstDoubleVar && reg < endVarSlotCount;

}

BOOL

IRBuilderAsmJs::RegIsSimd128Var(Js::RegSlot reg)

{

Js::RegSlot endVarSlotCount = (Js::RegSlot)(m_asmFuncInfo->GetSimdVarCount()) + m_firstSimdVar;

return reg >= m_firstSimdVar && reg < endVarSlotCount;

}

BOOL

IRBuilderAsmJs::RegIsConstant(Js::RegSlot reg)

{

return (reg > 0 && reg < m_firstIntVar);

}

BranchReloc *

IRBuilderAsmJs::AddBranchInstr(IR::BranchInstr * branchInstr, uint32 offset, uint32 targetOffset)

{

//

// Loop jitting would be done only till the LoopEnd

// Any branches beyond that offset are for the return statement

//

if (IsLoopBodyOuterOffset(targetOffset))

{

// if we have loaded the loop IP sym from the ProfiledLoopEnd then don't add it here

if (!IsLoopBodyReturnIPInstr(m_lastInstr))

{

this->InsertLoopBodyReturnIPInstr(targetOffset, offset);

}

// Jump the restore StSlot and Ret instruction

targetOffset = GetLoopBodyExitInstrOffset();

}

BranchReloc * reloc = nullptr;

reloc = CreateRelocRecord(branchInstr, offset, targetOffset);

AddInstr(branchInstr, offset);

return reloc;

}

BranchReloc *

IRBuilderAsmJs::CreateRelocRecord(IR::BranchInstr * branchInstr, uint32 offset, uint32 targetOffset)

{

BranchReloc * reloc = JitAnew(m_tempAlloc, BranchReloc, branchInstr, offset, targetOffset);

m_branchRelocList->Prepend(reloc);

return reloc;

}

void

IRBuilderAsmJs::BuildHeapBufferReload(uint32 offset)

{

// ArrayBuffer

IR::RegOpnd * dstOpnd = BuildDstOpnd(AsmJsRegSlots::ArrayReg, TyVar);

IR::Opnd * srcOpnd = IR::IndirOpnd::New(BuildSrcOpnd(AsmJsRegSlots::ModuleMemReg, TyVar), Js::AsmJsModuleMemory::MemoryTableBeginOffset, TyVar, m_func);

IR::Instr * instr = IR::Instr::New(Js::OpCode::Ld_A, dstOpnd, srcOpnd, m_func);

AddInstr(instr, offset);

// ArrayBuffer buffer

dstOpnd = BuildDstOpnd(AsmJsRegSlots::BufferReg, TyVar);

srcOpnd = IR::IndirOpnd::New(BuildSrcOpnd(AsmJsRegSlots::ArrayReg, TyVar), Js::ArrayBuffer::GetBufferOffset(), TyVar, m_func);

instr = IR::Instr::New(Js::OpCode::Ld_A, dstOpnd, srcOpnd, m_func);

AddInstr(instr, offset);

// ArrayBuffer length

dstOpnd = BuildDstOpnd(AsmJsRegSlots::LengthReg, TyUint32);

srcOpnd = IR::IndirOpnd::New(BuildSrcOpnd(AsmJsRegSlots::ArrayReg, TyVar), Js::ArrayBuffer::GetByteLengthOffset(), TyUint32, m_func);

instr = IR::Instr::New(Js::OpCode::Ld_A, dstOpnd, srcOpnd, m_func);

AddInstr(instr, offset);

}

void

IRBuilderAsmJs::BuildConstantLoads()

{

uint32 intConstCount = m_func->GetJnFunction()->GetAsmJsFunctionInfo()->GetIntConstCount();

uint32 floatConstCount = m_func->GetJnFunction()->GetAsmJsFunctionInfo()->GetFloatConstCount();

uint32 doubleConstCount = m_func->GetJnFunction()->GetAsmJsFunctionInfo()->GetDoubleConstCount();

Js::Var * constTable = static_cast<Js::Var *>(m_func->GetJnFunction()->GetConstTable());

// Load FrameDisplay

IR::RegOpnd * dstOpnd = BuildDstOpnd(AsmJsRegSlots::ModuleMemReg, TyVar);

IR::Instr * instr = IR::Instr::New(Js::OpCode::LdAsmJsEnv, dstOpnd, m_func);

AddInstr(instr, Js::Constants::NoByteCodeOffset);

// Load heap buffer

if (m_asmFuncInfo->UsesHeapBuffer())

{

BuildHeapBufferReload(Js::Constants::NoByteCodeOffset);

}

uint32 regAllocated = AsmJsRegSlots::RegCount;

// build int const loads

int * intConstTable = reinterpret_cast<int *>(constTable + Js::AsmJsFunctionMemory::RequiredVarConstants - 1);

for (Js::RegSlot reg = Js::FunctionBody::FirstRegSlot; reg < intConstCount; ++reg)

{

int32 intConst = intConstTable[reg];

IR::RegOpnd * dstOpnd = BuildDstOpnd(regAllocated + Js::FunctionBody::FirstRegSlot, TyInt32);

Assert(RegIsConstant(reg));

dstOpnd->m_sym->SetIsFromByteCodeConstantTable();

dstOpnd->SetValueType(ValueType::GetInt(false));

IR::Instr *instr = IR::Instr::New(Js::OpCode::Ld_I4, dstOpnd, IR::IntConstOpnd::New(intConst, TyInt32, m_func), m_func);

if (dstOpnd->m_sym->IsSingleDef())

{

dstOpnd->m_sym->SetIsIntConst(intConst);

}

AddInstr(instr, Js::Constants::NoByteCodeOffset);

++regAllocated;

}

// do the same for float constants

// Space for F0

++regAllocated;

float * floatConstTable = reinterpret_cast<float *>(intConstTable + intConstCount);

for (Js::RegSlot reg = Js::FunctionBody::FirstRegSlot; reg < floatConstCount; ++reg)

{

float floatConst = floatConstTable[reg];

IR::RegOpnd * dstOpnd = BuildDstOpnd(regAllocated + Js::FunctionBody::FirstRegSlot, TyFloat32);

Assert(RegIsConstant(reg));

dstOpnd->m_sym->SetIsFromByteCodeConstantTable();

dstOpnd->SetValueType(ValueType::Float);

IR::Instr *instr = IR::Instr::New(Js::OpCode::LdC_F8_R8, dstOpnd, IR::FloatConstOpnd::New(floatConst, TyFloat32, m_func), m_func);

#if _M_IX86

if (dstOpnd->m_sym->IsSingleDef())

{

dstOpnd->m_sym->SetIsFloatConst();

}

#endif

AddInstr(instr, Js::Constants::NoByteCodeOffset);

++regAllocated;

}

// ... and doubles

// Space for D0

++regAllocated;

double * doubleConstTable = reinterpret_cast<double *>(floatConstTable + floatConstCount);

for (Js::RegSlot reg = Js::FunctionBody::FirstRegSlot; reg < doubleConstCount; ++reg)

{

double doubleConst = doubleConstTable[reg];

IR::RegOpnd * dstOpnd = BuildDstOpnd(regAllocated + Js::FunctionBody::FirstRegSlot, TyFloat64);

Assert(RegIsConstant(reg));

dstOpnd->m_sym->SetIsFromByteCodeConstantTable();

dstOpnd->SetValueType(ValueType::Float);

IR::Instr *instr = IR::Instr::New(Js::OpCode::LdC_F8_R8, dstOpnd, IR::FloatConstOpnd::New(doubleConst, TyFloat64, m_func), m_func);

#if _M_IX86

if (dstOpnd->m_sym->IsSingleDef())

{

dstOpnd->m_sym->SetIsFloatConst();

}

#endif

AddInstr(instr, Js::Constants::NoByteCodeOffset);

++regAllocated;

}

uint32 simdConstCount = m_func->GetJnFunction()->GetAsmJsFunctionInfo()->GetSimdConstCount();

// Space for SIMD0

++regAllocated;

AsmJsSIMDValue *simdConstTable = reinterpret_cast<AsmJsSIMDValue *>(doubleConstTable + doubleConstCount);

for (Js::RegSlot reg = Js::FunctionBody::FirstRegSlot; reg < simdConstCount; ++reg)

{

AsmJsSIMDValue simdConst = simdConstTable[reg];

// Simd constants are not sub-typed, we pick any IR type for now, when the constant is actually used (Ld_A to a variable), we type the variable from the opcode.

IR::RegOpnd * dstOpnd = BuildDstOpnd(regAllocated + Js::FunctionBody::FirstRegSlot, TySimd128F4);

Assert(RegIsConstant(reg));

dstOpnd->m_sym->SetIsFromByteCodeConstantTable();

// Constants vars are generic SIMD128 values, no sub-type. We currently don't have top SIMD128 type in ValueType, since it is not needed by globOpt.

// However, for ASMJS, the IR type is enough to tell us it is a Simd128 value.

dstOpnd->SetValueType(ValueType::UninitializedObject);

IR::Instr *instr = IR::Instr::New(Js::OpCode::Simd128_LdC, dstOpnd, IR::Simd128ConstOpnd::New(simdConst, TySimd128F4, m_func), m_func);

#if _M_IX86

if (dstOpnd->m_sym->IsSingleDef())

{

dstOpnd->m_sym->SetIsSimd128Const();

}

#endif

AddInstr(instr, Js::Constants::NoByteCodeOffset);

++regAllocated;

}

}

void

IRBuilderAsmJs::BuildImplicitArgIns()

{

int32 intArgInCount = 0;

int32 floatArgInCount = 0;

int32 doubleArgInCount = 0;

int32 simd128ArgInCount = 0;

// formal params are offset from EBP by the EBP chain, return address, and function object

int32 offset = 3 * MachPtr;

for (Js::ArgSlot i = 1; i < m_func->GetJnFunction()->GetInParamsCount(); ++i)

{

StackSym * symSrc = nullptr;

IR::Opnd * srcOpnd = nullptr;

IR::RegOpnd * dstOpnd = nullptr;

IR::Instr * instr = nullptr;

// TODO: double args are not aligned on stack

Js::AsmJsVarType varType = m_func->GetJnFunction()->GetAsmJsFunctionInfo()->GetArgType(i - 1);

switch (varType.which())

{

case Js::AsmJsVarType::Which::Int:

symSrc = StackSym::NewParamSlotSym(i, m_func, TyInt32);

m_func->SetArgOffset(symSrc, offset);

srcOpnd = IR::SymOpnd::New(symSrc, TyInt32, m_func);

dstOpnd = BuildDstOpnd(m_firstIntVar + intArgInCount, TyInt32);

dstOpnd->SetValueType(ValueType::GetInt(false));

instr = IR::Instr::New(Js::OpCode::ArgIn_A, dstOpnd, srcOpnd, m_func);

offset += MachPtr;

++intArgInCount;

break;

case Js::AsmJsVarType::Which::Float:

symSrc = StackSym::NewParamSlotSym(i, m_func, TyFloat32);

m_func->SetArgOffset(symSrc, offset);

srcOpnd = IR::SymOpnd::New(symSrc, TyFloat32, m_func);

dstOpnd = BuildDstOpnd(m_firstFloatVar + floatArgInCount, TyFloat32);

dstOpnd->SetValueType(ValueType::Float);

instr = IR::Instr::New(Js::OpCode::ArgIn_A, dstOpnd, srcOpnd, m_func);

offset += MachPtr;

++floatArgInCount;

break;

case Js::AsmJsVarType::Which::Double:

symSrc = StackSym::NewParamSlotSym(i, m_func, TyFloat64);

m_func->SetArgOffset(symSrc, offset);

srcOpnd = IR::SymOpnd::New(symSrc, TyFloat64, m_func);

dstOpnd = BuildDstOpnd(m_firstDoubleVar + doubleArgInCount, TyFloat64);

dstOpnd->SetValueType(ValueType::Float);

instr = IR::Instr::New(Js::OpCode::ArgIn_A, dstOpnd, srcOpnd, m_func);

offset += MachDouble;

++doubleArgInCount;

break;

case Js::AsmJsVarType::Which::Float32x4:

case Js::AsmJsVarType::Which::Int32x4:

case Js::AsmJsVarType::Which::Float64x2:

{

IRType argType;

if (varType.which() == Js::AsmJsVarType::Which::Float32x4)

{

argType = TySimd128F4;

}

else if (varType.which() == Js::AsmJsVarType::Which::Int32x4)

{

argType = TySimd128I4;

}

else

{

Assert(varType.which() == Js::AsmJsVarType::Which::Float64x2);

argType = TySimd128D2;

}

symSrc = StackSym::NewParamSlotSym(i, m_func, argType);

m_func->SetArgOffset(symSrc, offset);

srcOpnd = IR::SymOpnd::New(symSrc, argType, m_func);

dstOpnd = BuildDstOpnd(m_firstSimdVar + simd128ArgInCount, argType);

dstOpnd->SetValueType(ValueType::UninitializedObject);

instr = IR::Instr::New(Js::OpCode::ArgIn_A, dstOpnd, srcOpnd, m_func);

offset += sizeof(AsmJsSIMDValue);

++simd128ArgInCount;

break;

}

default:

Assume(UNREACHED);

}

AddInstr(instr, Js::Constants::NoByteCodeOffset);

}

}

void

IRBuilderAsmJs::InsertLabels()

{

AssertMsg(m_branchRelocList, "Malformed branch reloc list");

SList<BranchReloc *>::Iterator iter(m_branchRelocList);

while (iter.Next())

{

IR::LabelInstr * labelInstr;

BranchReloc * reloc = iter.Data();

IR::BranchInstr * branchInstr = reloc->GetBranchInstr();

uint offset = reloc->GetOffset();

uint const branchOffset = reloc->GetBranchOffset();

Assert(!IsLoopBody() || offset <= GetLoopBodyExitInstrOffset());

if (branchInstr->m_opcode == Js::OpCode::MultiBr)

{

IR::MultiBranchInstr * multiBranchInstr = branchInstr->AsBranchInstr()->AsMultiBrInstr();

multiBranchInstr->UpdateMultiBrTargetOffsets([&](uint32 offset) -> IR::LabelInstr *

{

labelInstr = this->CreateLabel(branchInstr, offset);

multiBranchInstr->ChangeLabelRef(nullptr, labelInstr);

return labelInstr;

});

}

else

{

labelInstr = CreateLabel(branchInstr, offset);

branchInstr->SetTarget(labelInstr);

}

if (!reloc->IsNotBackEdge() && branchOffset >= offset)

{

labelInstr->m_isLoopTop = true;

}

}

}

IR::LabelInstr *

IRBuilderAsmJs::CreateLabel(IR::BranchInstr * branchInstr, uint & offset)

{

IR::Instr * targetInstr = nullptr;

while (targetInstr == nullptr)

{

targetInstr = m_offsetToInstruction[offset];

Assert(offset < m_offsetToInstructionCount);

++offset;

}

IR::Instr *instrPrev = targetInstr->m_prev;

if (instrPrev)

{

instrPrev = targetInstr->GetPrevRealInstrOrLabel();

}

IR::LabelInstr * labelInstr;

if (instrPrev && instrPrev->IsLabelInstr())

{

// Found an existing label at the right offset. Just reuse it.

labelInstr = instrPrev->AsLabelInstr();

}

else

{

// No label at the desired offset. Create one.

labelInstr = IR::LabelInstr::New(Js::OpCode::Label, m_func);

labelInstr->SetByteCodeOffset(offset);

if (instrPrev)

{

instrPrev->InsertAfter(labelInstr);

}

else

{

targetInstr->InsertBefore(labelInstr);

}

}

return labelInstr;

}

void

IRBuilderAsmJs::BuildEmpty(Js::OpCodeAsmJs newOpcode, uint32 offset)

{