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

// 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 "Base/EtwTrace.h"

#include "Base/ScriptContextProfiler.h"

#ifdef VTUNE_PROFILING

#include "Base/VTuneChakraProfile.h"

#endif

#include "Library/ForInObjectEnumerator.h"

Func::Func(JitArenaAllocator *alloc, JITTimeWorkItem * workItem,

ThreadContextInfo * threadContextInfo,

ScriptContextInfo * scriptContextInfo,

JITOutputIDL * outputData,

Js::EntryPointInfo* epInfo,

const FunctionJITRuntimeInfo *const runtimeInfo,

JITTimePolymorphicInlineCacheInfo * const polymorphicInlineCacheInfo, void * const codeGenAllocators,

#if !FLOATVAR

CodeGenNumberAllocator * numberAllocator,

#endif

Js::ScriptContextProfiler *const codeGenProfiler, const bool isBackgroundJIT, Func * parentFunc,

uint postCallByteCodeOffset, Js::RegSlot returnValueRegSlot, const bool isInlinedConstructor,

Js::ProfileId callSiteIdInParentFunc, bool isGetterSetter) :

m_alloc(alloc),

m_workItem(workItem),

m_output(outputData),

m_entryPointInfo(epInfo),

m_threadContextInfo(threadContextInfo),

m_scriptContextInfo(scriptContextInfo),

m_runtimeInfo(runtimeInfo),

m_polymorphicInlineCacheInfo(polymorphicInlineCacheInfo),

m_codeGenAllocators(codeGenAllocators),

m_inlineeId(0),

pinnedTypeRefs(nullptr),

singleTypeGuards(nullptr),

equivalentTypeGuards(nullptr),

propertyGuardsByPropertyId(nullptr),

ctorCachesByPropertyId(nullptr),

callSiteToArgumentsOffsetFixupMap(nullptr),

indexedPropertyGuardCount(0),

propertiesWrittenTo(nullptr),

lazyBailoutProperties(alloc),

anyPropertyMayBeWrittenTo(false),

#ifdef PROFILE_EXEC

m_codeGenProfiler(codeGenProfiler),

#endif

m_isBackgroundJIT(isBackgroundJIT),

m_cloner(nullptr),

m_cloneMap(nullptr),

m_loopParamSym(nullptr),

m_funcObjSym(nullptr),

m_localClosureSym(nullptr),

m_paramClosureSym(nullptr),

m_localFrameDisplaySym(nullptr),

m_bailoutReturnValueSym(nullptr),

m_hasBailedOutSym(nullptr),

m_inlineeFrameStartSym(nullptr),

m_regsUsed(0),

m_fg(nullptr),

m_labelCount(0),

m_argSlotsForFunctionsCalled(0),

m_isLeaf(false),

m_hasCalls(false),

m_hasInlineArgsOpt(false),

m_canDoInlineArgsOpt(true),

m_doFastPaths(false),

hasBailout(false),

hasBailoutInEHRegion(false),

hasInstrNumber(false),

maintainByteCodeOffset(true),

frameSize(0),

parentFunc(parentFunc),

argObjSyms(nullptr),

m_nonTempLocalVars(nullptr),

hasAnyStackNestedFunc(false),

hasMarkTempObjects(false),

postCallByteCodeOffset(postCallByteCodeOffset),

maxInlineeArgOutCount(0),

returnValueRegSlot(returnValueRegSlot),

firstActualStackOffset(-1),

m_localVarSlotsOffset(Js::Constants::InvalidOffset),

m_hasLocalVarChangedOffset(Js::Constants::InvalidOffset),

actualCount((Js::ArgSlot) - 1),

tryCatchNestingLevel(0),

m_localStackHeight(0),

tempSymDouble(nullptr),

tempSymBool(nullptr),

hasInlinee(false),

thisOrParentInlinerHasArguments(false),

hasStackArgs(false),

hasImplicitParamLoad(false),

hasThrow(false),

hasNonSimpleParams(false),

hasUnoptimizedArgumentsAcccess(false),

hasApplyTargetInlining(false),

hasImplicitCalls(false),

hasTempObjectProducingInstr(false),

isInlinedConstructor(isInlinedConstructor),

#if !FLOATVAR

numberAllocator(numberAllocator),

#endif

loopCount(0),

callSiteIdInParentFunc(callSiteIdInParentFunc),

isGetterSetter(isGetterSetter),

frameInfo(nullptr),

isTJLoopBody(false),

m_nativeCodeDataSym(nullptr),

isFlowGraphValid(false),

#if DBG

m_callSiteCount(0),

#endif

stackNestedFunc(false),

stackClosure(false)

#if defined(_M_ARM32_OR_ARM64)

, m_ArgumentsOffset(0)

, m_epilogLabel(nullptr)

#endif

, m_funcStartLabel(nullptr)

, m_funcEndLabel(nullptr)

#if DBG

, hasCalledSetDoFastPaths(false)

, allowRemoveBailOutArgInstr(false)

, currentPhases(alloc)

, isPostLower(false)

, isPostRegAlloc(false)

, isPostPeeps(false)

, isPostLayout(false)

, isPostFinalLower(false)

, vtableMap(nullptr)

#endif

, m_yieldOffsetResumeLabelList(nullptr)

, m_bailOutNoSaveLabel(nullptr)

, constantAddressRegOpnd(alloc)

, lastConstantAddressRegLoadInstr(nullptr)

, m_totalJumpTableSizeInBytesForSwitchStatements(0)

, slotArrayCheckTable(nullptr)

, frameDisplayCheckTable(nullptr)

, stackArgWithFormalsTracker(nullptr)

, m_forInLoopBaseDepth(0)

, m_forInEnumeratorArrayOffset(-1)

, argInsCount(0)

, m_globalObjTypeSpecFldInfoArray(nullptr)

{

Assert(this->IsInlined() == !!runtimeInfo);

if (this->IsTopFunc())

{

outputData->hasJittedStackClosure = false;

outputData->localVarSlotsOffset = m_localVarSlotsOffset;

outputData->localVarChangedOffset = m_hasLocalVarChangedOffset;

}

if (this->IsInlined())

{

m_inlineeId = ++(GetTopFunc()->m_inlineeId);

}

bool doStackNestedFunc = GetJITFunctionBody()->DoStackNestedFunc();

bool doStackClosure = GetJITFunctionBody()->DoStackClosure() && !PHASE_OFF(Js::FrameDisplayFastPathPhase, this) && !PHASE_OFF(Js::StackClosurePhase, this);

Assert(!doStackClosure || doStackNestedFunc);

this->stackClosure = doStackClosure && this->IsTopFunc();

if (this->stackClosure)

{

// TODO: calculate on runtime side?

m_output.SetHasJITStackClosure();

}

if (m_workItem->Type() == JsFunctionType &&

GetJITFunctionBody()->DoBackendArgumentsOptimization() &&

!GetJITFunctionBody()->HasTry())

{

// doBackendArgumentsOptimization bit is set when there is no eval inside a function

// as determined by the bytecode generator.

SetHasStackArgs(true);

}

if (doStackNestedFunc && GetJITFunctionBody()->GetNestedCount() != 0 &&

(this->IsTopFunc() || this->GetTopFunc()->m_workItem->Type() != JsLoopBodyWorkItemType)) // make sure none of the functions inlined in a jitted loop body allocate nested functions on the stack

{

Assert(!(this->IsJitInDebugMode() && !GetJITFunctionBody()->IsLibraryCode()));

stackNestedFunc = true;

this->GetTopFunc()->hasAnyStackNestedFunc = true;

}

if (GetJITFunctionBody()->HasOrParentHasArguments() || (parentFunc && parentFunc->thisOrParentInlinerHasArguments))

{

thisOrParentInlinerHasArguments = true;

}

if (parentFunc == nullptr)

{

inlineDepth = 0;

m_symTable = JitAnew(alloc, SymTable);

m_symTable->Init(this);

m_symTable->SetStartingID(static_cast<SymID>(workItem->GetJITFunctionBody()->GetLocalsCount() + 1));

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

Assert(Js::Constants::NoRegister == returnValueRegSlot);

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

if (HasArgumentSlot())

{

// Pre-allocate the single argument slot we'll reserve for the arguments object.

// For ARM, the argument slot is not part of the local but part of the register saves

m_localStackHeight = MachArgsSlotOffset;

}

#endif

}

else

{

inlineDepth = parentFunc->inlineDepth + 1;

Assert(Js::Constants::NoByteCodeOffset != postCallByteCodeOffset);

}

this->constructorCacheCount = 0;

this->constructorCaches = AnewArrayZ(this->m_alloc, JITTimeConstructorCache*, GetJITFunctionBody()->GetProfiledCallSiteCount());

#if DBG_DUMP

m_codeSize = -1;

#endif

#if defined(_M_X64)

m_spillSize = -1;

m_argsSize = -1;

m_savedRegSize = -1;

#endif

if (this->IsJitInDebugMode())

{

m_nonTempLocalVars = Anew(this->m_alloc, BVSparse<JitArenaAllocator>, this->m_alloc);

}

if (GetJITFunctionBody()->IsCoroutine())

{

m_yieldOffsetResumeLabelList = YieldOffsetResumeLabelList::New(this->m_alloc);

}

if (this->IsTopFunc())

{

m_globalObjTypeSpecFldInfoArray = JitAnewArrayZ(this->m_alloc, JITObjTypeSpecFldInfo*, GetWorkItem()->GetJITTimeInfo()->GetGlobalObjTypeSpecFldInfoCount());

}

for (uint i = 0; i < GetJITFunctionBody()->GetInlineCacheCount(); ++i)

{

JITObjTypeSpecFldInfo * info = GetWorkItem()->GetJITTimeInfo()->GetObjTypeSpecFldInfo(i);

if (info != nullptr)

{

Assert(info->GetObjTypeSpecFldId() < GetTopFunc()->GetWorkItem()->GetJITTimeInfo()->GetGlobalObjTypeSpecFldInfoCount());

GetTopFunc()->m_globalObjTypeSpecFldInfoArray[info->GetObjTypeSpecFldId()] = info;

}

}

canHoistConstantAddressLoad = !PHASE_OFF(Js::HoistConstAddrPhase, this);

m_forInLoopMaxDepth = this->GetJITFunctionBody()->GetForInLoopDepth();

}

bool

Func::IsLoopBodyInTry() const

{

return IsLoopBody() && m_workItem->GetLoopHeader()->isInTry;

}

/* static */

void

Func::Codegen(JitArenaAllocator *alloc, JITTimeWorkItem * workItem,

ThreadContextInfo * threadContextInfo,

ScriptContextInfo * scriptContextInfo,

JITOutputIDL * outputData,

Js::EntryPointInfo* epInfo, // for in-proc jit only

const FunctionJITRuntimeInfo *const runtimeInfo,

JITTimePolymorphicInlineCacheInfo * const polymorphicInlineCacheInfo, void * const codeGenAllocators,

#if !FLOATVAR

CodeGenNumberAllocator * numberAllocator,

#endif

Js::ScriptContextProfiler *const codeGenProfiler, const bool isBackgroundJIT)

{

bool rejit;

do

{

Func func(alloc, workItem, threadContextInfo,

scriptContextInfo, outputData, epInfo, runtimeInfo,

polymorphicInlineCacheInfo, codeGenAllocators,

#if !FLOATVAR

numberAllocator,

#endif

codeGenProfiler, isBackgroundJIT);

try

{

func.TryCodegen();

rejit = false;

}

catch (Js::RejitException ex)

{

// The work item needs to be rejitted, likely due to some optimization that was too aggressive

if (ex.Reason() == RejitReason::AggressiveIntTypeSpecDisabled)

{

workItem->GetJITFunctionBody()->GetProfileInfo()->DisableAggressiveIntTypeSpec(func.IsLoopBody());

outputData->disableAggressiveIntTypeSpec = TRUE;

}

else if (ex.Reason() == RejitReason::InlineApplyDisabled)

{

workItem->GetJITFunctionBody()->DisableInlineApply();

outputData->disableInlineApply = TRUE;

}

else if (ex.Reason() == RejitReason::InlineSpreadDisabled)

{

workItem->GetJITFunctionBody()->DisableInlineSpread();

outputData->disableInlineSpread = TRUE;

}

else if (ex.Reason() == RejitReason::DisableStackArgOpt)

{

workItem->GetJITFunctionBody()->GetProfileInfo()->DisableStackArgOpt();

outputData->disableStackArgOpt = TRUE;

}

else if (ex.Reason() == RejitReason::DisableSwitchOptExpectingInteger ||

ex.Reason() == RejitReason::DisableSwitchOptExpectingString)

{

workItem->GetJITFunctionBody()->GetProfileInfo()->DisableSwitchOpt();

outputData->disableSwitchOpt = TRUE;

}

else

{

Assert(ex.Reason() == RejitReason::TrackIntOverflowDisabled);

workItem->GetJITFunctionBody()->GetProfileInfo()->DisableTrackCompoundedIntOverflow();

outputData->disableTrackCompoundedIntOverflow = TRUE;

}

if (PHASE_TRACE(Js::ReJITPhase, &func))

{

char16 debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

Output::Print(

_u("Rejit (compile-time): function: %s (%s) reason: %S\n"),

workItem->GetJITFunctionBody()->GetDisplayName(),

workItem->GetJITTimeInfo()->GetDebugNumberSet(debugStringBuffer),

ex.ReasonName());

}

rejit = true;

}

// Either the entry point has a reference to the number now, or we failed to code gen and we

// don't need to numbers, we can flush the completed page now.

//

// If the number allocator is NULL then we are shutting down the thread context and so too the

// code generator. The number allocator must be freed before the recycler (and thus before the

// code generator) so we can't and don't need to flush it.

// TODO: OOP JIT, allocator cleanup

} while (rejit);

}

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

///

/// Func::TryCodegen

///

/// Attempt to Codegen this function.

///

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

void

Func::TryCodegen()

{

Assert(!IsJitInDebugMode() || !GetJITFunctionBody()->HasTry());

BEGIN_CODEGEN_PHASE(this, Js::BackEndPhase);

{

// IRBuilder

BEGIN_CODEGEN_PHASE(this, Js::IRBuilderPhase);

#ifdef ASMJS_PLAT

if (GetJITFunctionBody()->IsAsmJsMode())

{

IRBuilderAsmJs asmIrBuilder(this);

asmIrBuilder.Build();

}

else

#endif

{

IRBuilder irBuilder(this);

irBuilder.Build();

}

END_CODEGEN_PHASE(this, Js::IRBuilderPhase);

#ifdef IR_VIEWER

IRtoJSObjectBuilder::DumpIRtoGlobalObject(this, Js::IRBuilderPhase);

#endif /* IR_VIEWER */

BEGIN_CODEGEN_PHASE(this, Js::InlinePhase);

InliningHeuristics heuristics(GetWorkItem()->GetJITTimeInfo(), this->IsLoopBody());

Inline inliner(this, heuristics);

inliner.Optimize();

END_CODEGEN_PHASE(this, Js::InlinePhase);

ThrowIfScriptClosed();

// FlowGraph

{

// Scope for FlowGraph arena

NoRecoverMemoryJitArenaAllocator fgAlloc(_u("BE-FlowGraph"), m_alloc->GetPageAllocator(), Js::Throw::OutOfMemory);

BEGIN_CODEGEN_PHASE(this, Js::FGBuildPhase);

this->m_fg = FlowGraph::New(this, &fgAlloc);

this->m_fg->Build();

END_CODEGEN_PHASE(this, Js::FGBuildPhase);

// Global Optimization and Type Specialization

BEGIN_CODEGEN_PHASE(this, Js::GlobOptPhase);

GlobOpt globOpt(this);

globOpt.Optimize();

END_CODEGEN_PHASE(this, Js::GlobOptPhase);

// Delete flowGraph now

this->m_fg->Destroy();

this->m_fg = nullptr;

}

#ifdef IR_VIEWER

IRtoJSObjectBuilder::DumpIRtoGlobalObject(this, Js::GlobOptPhase);

#endif /* IR_VIEWER */

ThrowIfScriptClosed();

// Lowering

Lowerer lowerer(this);

BEGIN_CODEGEN_PHASE(this, Js::LowererPhase);

lowerer.Lower();

END_CODEGEN_PHASE(this, Js::LowererPhase);

#ifdef IR_VIEWER

IRtoJSObjectBuilder::DumpIRtoGlobalObject(this, Js::LowererPhase);

#endif /* IR_VIEWER */

// Encode constants

Security security(this);

BEGIN_CODEGEN_PHASE(this, Js::EncodeConstantsPhase)

security.EncodeLargeConstants();

END_CODEGEN_PHASE(this, Js::EncodeConstantsPhase);

if (GetJITFunctionBody()->DoInterruptProbe())

{

BEGIN_CODEGEN_PHASE(this, Js::InterruptProbePhase)

lowerer.DoInterruptProbes();

END_CODEGEN_PHASE(this, Js::InterruptProbePhase)

}

// Register Allocation

BEGIN_CODEGEN_PHASE(this, Js::RegAllocPhase);

LinearScan linearScan(this);

linearScan.RegAlloc();

END_CODEGEN_PHASE(this, Js::RegAllocPhase);

#ifdef IR_VIEWER

IRtoJSObjectBuilder::DumpIRtoGlobalObject(this, Js::RegAllocPhase);

#endif /* IR_VIEWER */

ThrowIfScriptClosed();

// Peephole optimizations

BEGIN_CODEGEN_PHASE(this, Js::PeepsPhase);

Peeps peeps(this);

peeps.PeepFunc();

END_CODEGEN_PHASE(this, Js::PeepsPhase);

// Layout

BEGIN_CODEGEN_PHASE(this, Js::LayoutPhase);

SimpleLayout layout(this);

layout.Layout();

END_CODEGEN_PHASE(this, Js::LayoutPhase);

if (this->HasTry() && this->hasBailoutInEHRegion)

{

BEGIN_CODEGEN_PHASE(this, Js::EHBailoutPatchUpPhase);

lowerer.EHBailoutPatchUp();

END_CODEGEN_PHASE(this, Js::EHBailoutPatchUpPhase);

}

// Insert NOPs (moving this before prolog/epilog for AMD64 and possibly ARM).

BEGIN_CODEGEN_PHASE(this, Js::InsertNOPsPhase);

security.InsertNOPs();

END_CODEGEN_PHASE(this, Js::InsertNOPsPhase);

// Prolog/Epilog

BEGIN_CODEGEN_PHASE(this, Js::PrologEpilogPhase);

if (GetJITFunctionBody()->IsAsmJsMode())

{

lowerer.LowerPrologEpilogAsmJs();

}

else

{

lowerer.LowerPrologEpilog();

}

END_CODEGEN_PHASE(this, Js::PrologEpilogPhase);

BEGIN_CODEGEN_PHASE(this, Js::FinalLowerPhase);

lowerer.FinalLower();

END_CODEGEN_PHASE(this, Js::FinalLowerPhase);

// Encoder

BEGIN_CODEGEN_PHASE(this, Js::EncoderPhase);

Encoder encoder(this);

encoder.Encode();

END_CODEGEN_PHASE_NO_DUMP(this, Js::EncoderPhase);

#ifdef IR_VIEWER

IRtoJSObjectBuilder::DumpIRtoGlobalObject(this, Js::EncoderPhase);

#endif /* IR_VIEWER */

}

#if DBG_DUMP

if (Js::Configuration::Global.flags.IsEnabled(Js::AsmDumpModeFlag))

{

FILE * oldFile = 0;

FILE * asmFile = GetScriptContext()->GetNativeCodeGenerator()->asmFile;

if (asmFile)

{

oldFile = Output::SetFile(asmFile);

}

this->Dump(IRDumpFlags_AsmDumpMode);

Output::Flush();

if (asmFile)

{

FILE *openedFile = Output::SetFile(oldFile);

Assert(openedFile == asmFile);

}

}

#endif

if (this->IsOOPJIT())

{

BEGIN_CODEGEN_PHASE(this, Js::NativeCodeDataPhase);

auto dataAllocator = this->GetNativeCodeDataAllocator();

if (dataAllocator->allocCount > 0)

{

NativeCodeData::DataChunk *chunk = (NativeCodeData::DataChunk*)dataAllocator->chunkList;

NativeCodeData::DataChunk *next1 = chunk;

while (next1)

{

if (next1->fixupFunc)

{

next1->fixupFunc(next1->data, chunk);

}

#if DBG

// Scan memory to see if there's missing pointer needs to be fixed up

// This can hit false positive if some data field happens to have value

// falls into the NativeCodeData memory range.

NativeCodeData::DataChunk *next2 = chunk;

while (next2)

{

for (unsigned int i = 0; i < next1->len / sizeof(void*); i++)

{

if (((void**)next1->data)[i] == (void*)next2->data)

{

NativeCodeData::VerifyExistFixupEntry((void*)next2->data, &((void**)next1->data)[i], next1->data);

}

}

next2 = next2->next;

}

#endif

next1 = next1->next;

}

JITOutputIDL* jitOutputData = m_output.GetOutputData();

size_t allocSize = offsetof(NativeDataFixupTable, fixupRecords) + sizeof(NativeDataFixupRecord)* (dataAllocator->allocCount);

jitOutputData->nativeDataFixupTable = (NativeDataFixupTable*)midl_user_allocate(allocSize);

if (!jitOutputData->nativeDataFixupTable)

{

Js::Throw::OutOfMemory();

}

__analysis_assume(jitOutputData->nativeDataFixupTable);

jitOutputData->nativeDataFixupTable->count = dataAllocator->allocCount;

jitOutputData->buffer = (NativeDataBuffer*)midl_user_allocate(offsetof(NativeDataBuffer, data) + dataAllocator->totalSize);

if (!jitOutputData->buffer)

{

Js::Throw::OutOfMemory();

}

__analysis_assume(jitOutputData->buffer);

jitOutputData->buffer->len = dataAllocator->totalSize;

unsigned int len = 0;

unsigned int count = 0;

next1 = chunk;

while (next1)

{

memcpy(jitOutputData->buffer->data + len, next1->data, next1->len);

len += next1->len;

jitOutputData->nativeDataFixupTable->fixupRecords[count].index = next1->allocIndex;

jitOutputData->nativeDataFixupTable->fixupRecords[count].length = next1->len;

jitOutputData->nativeDataFixupTable->fixupRecords[count].startOffset = next1->offset;

jitOutputData->nativeDataFixupTable->fixupRecords[count].updateList = next1->fixupList;

count++;

next1 = next1->next;

}

#if DBG

if (PHASE_TRACE1(Js::NativeCodeDataPhase))

{

Output::Print(_u("NativeCodeData Server Buffer: %p, len: %x, chunk head: %p\n"), jitOutputData->buffer->data, jitOutputData->buffer->len, chunk);

}

#endif

}

END_CODEGEN_PHASE(this, Js::NativeCodeDataPhase);

}

END_CODEGEN_PHASE(this, Js::BackEndPhase);

}

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

/// Func::StackAllocate

/// Allocate stack space of given size.

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

int32

Func::StackAllocate(int size)

{

Assert(this->IsTopFunc());

int32 offset;

#ifdef MD_GROW_LOCALS_AREA_UP

// Locals have positive offsets and are allocated from bottom to top.

m_localStackHeight = Math::Align(m_localStackHeight, min(size, MachStackAlignment));

offset = m_localStackHeight;

m_localStackHeight += size;

#else

// Locals have negative offsets and are allocated from top to bottom.

m_localStackHeight += size;

m_localStackHeight = Math::Align(m_localStackHeight, min(size, MachStackAlignment));

offset = -m_localStackHeight;

#endif

return offset;

}

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

///

/// Func::StackAllocate

///

/// Allocate stack space for this symbol.

///

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

int32

Func::StackAllocate(StackSym *stackSym, int size)

{

Assert(size > 0);

if (stackSym->IsArgSlotSym() || stackSym->IsParamSlotSym() || stackSym->IsAllocated())

{

return stackSym->m_offset;

}

Assert(stackSym->m_offset == 0);

stackSym->m_allocated = true;

stackSym->m_offset = StackAllocate(size);

return stackSym->m_offset;

}

void

Func::SetArgOffset(StackSym *stackSym, int32 offset)

{

AssertMsg(offset >= 0, "Why is the offset, negative?");

stackSym->m_offset = offset;

stackSym->m_allocated = true;

}

///

/// Ensures that local var slots are created, if the function has locals.

/// Allocate stack space for locals used for debugging

/// (for local non-temp vars we write-through memory so that locals inspection can make use of that.).

// On stack, after local slots we allocate space for metadata (in particular, whether any the locals was changed in debugger).

///

void

Func::EnsureLocalVarSlots()

{

Assert(IsJitInDebugMode());

if (!this->HasLocalVarSlotCreated())

{

uint32 localSlotCount = GetJITFunctionBody()->GetNonTempLocalVarCount();

if (localSlotCount && m_localVarSlotsOffset == Js::Constants::InvalidOffset)

{

// Allocate the slots.

int32 size = localSlotCount * GetDiagLocalSlotSize();

m_localVarSlotsOffset = StackAllocate(size);

m_hasLocalVarChangedOffset = StackAllocate(max(1, MachStackAlignment)); // Can't alloc less than StackAlignment bytes.

Assert(m_workItem->Type() == JsFunctionType);

m_output.SetVarSlotsOffset(AdjustOffsetValue(m_localVarSlotsOffset));

m_output.SetVarChangedOffset(AdjustOffsetValue(m_hasLocalVarChangedOffset));

}

}

}

void Func::SetFirstArgOffset(IR::Instr* inlineeStart)

{

Assert(inlineeStart->m_func == this);

Assert(!IsTopFunc());

int32 lastOffset;

IR::Instr* arg = inlineeStart->GetNextArg();

const auto lastArgOutStackSym = arg->GetDst()->AsSymOpnd()->m_sym->AsStackSym();

lastOffset = lastArgOutStackSym->m_offset;

Assert(lastArgOutStackSym->m_isSingleDef);

const auto secondLastArgOutOpnd = lastArgOutStackSym->m_instrDef->GetSrc2();

if (secondLastArgOutOpnd->IsSymOpnd())

{

const auto secondLastOffset = secondLastArgOutOpnd->AsSymOpnd()->m_sym->AsStackSym()->m_offset;

if (secondLastOffset > lastOffset)

{

lastOffset = secondLastOffset;

}

}

lastOffset += MachPtr;

int32 firstActualStackOffset = lastOffset - ((this->actualCount + Js::Constants::InlineeMetaArgCount) * MachPtr);

Assert((this->firstActualStackOffset == -1) || (this->firstActualStackOffset == firstActualStackOffset));

this->firstActualStackOffset = firstActualStackOffset;

}

int32

Func::GetLocalVarSlotOffset(int32 slotId)

{

this->EnsureLocalVarSlots();

Assert(m_localVarSlotsOffset != Js::Constants::InvalidOffset);

int32 slotOffset = slotId * GetDiagLocalSlotSize();

return m_localVarSlotsOffset + slotOffset;

}

void Func::OnAddSym(Sym* sym)

{

Assert(sym);

if (this->IsJitInDebugMode() && this->IsNonTempLocalVar(sym->m_id))

{

Assert(m_nonTempLocalVars);

m_nonTempLocalVars->Set(sym->m_id);

}

}

///

/// Returns offset of the flag (1 byte) whether any local was changed (in debugger).

/// If the function does not have any locals, returns -1.

///

int32

Func::GetHasLocalVarChangedOffset()

{

this->EnsureLocalVarSlots();

return m_hasLocalVarChangedOffset;

}

bool

Func::IsJitInDebugMode()

{

return m_workItem->IsJitInDebugMode();

}

bool

Func::IsNonTempLocalVar(uint32 slotIndex)

{

return GetJITFunctionBody()->IsNonTempLocalVar(slotIndex);

}

int32

Func::AdjustOffsetValue(int32 offset)

{

#ifdef MD_GROW_LOCALS_AREA_UP

return -(offset + BailOutInfo::StackSymBias);

#else

// Stack offset are negative, includes the PUSH EBP and return address

return offset - (2 * MachPtr);

#endif

}

#ifdef MD_GROW_LOCALS_AREA_UP

// Note: this is called during jit-compile when we finalize bail out record.

void

Func::AjustLocalVarSlotOffset()

{

if (GetJITFunctionBody()->GetNonTempLocalVarCount())

{

// Turn positive SP-relative base locals offset into negative frame-pointer-relative offset

// This is changing value for restoring the locals when read due to locals inspection.

int localsOffset = m_localVarSlotsOffset - (m_localStackHeight + m_ArgumentsOffset);

int valueChangeOffset = m_hasLocalVarChangedOffset - (m_localStackHeight + m_ArgumentsOffset);

m_output.SetVarSlotsOffset(localsOffset);

m_output.SetVarChangedOffset(valueChangeOffset);

}

}

#endif

bool

Func::DoGlobOptsForGeneratorFunc() const

{

// Disable GlobOpt optimizations for generators initially. Will visit and enable each one by one.

return !GetJITFunctionBody()->IsCoroutine();

}

bool

Func::DoSimpleJitDynamicProfile() const

{

return IsSimpleJit() && !PHASE_OFF(Js::SimpleJitDynamicProfilePhase, GetTopFunc()) && !CONFIG_FLAG(NewSimpleJit);

}

void

Func::SetDoFastPaths()

{

// Make sure we only call this once!

Assert(!this->hasCalledSetDoFastPaths);

bool doFastPaths = false;

if(!PHASE_OFF(Js::FastPathPhase, this) && (!IsSimpleJit() || CONFIG_FLAG(NewSimpleJit)))

{

doFastPaths = true;

}

this->m_doFastPaths = doFastPaths;

#ifdef DBG

this->hasCalledSetDoFastPaths = true;

#endif

}

#ifdef _M_ARM

RegNum

Func::GetLocalsPointer() const

{

#ifdef DBG

if (Js::Configuration::Global.flags.IsEnabled(Js::ForceLocalsPtrFlag))

{

return ALT_LOCALS_PTR;

}

#endif

if (GetJITFunctionBody()->HasTry())

{

return ALT_LOCALS_PTR;

}

return RegSP;

}

#endif

void Func::AddSlotArrayCheck(IR::SymOpnd *fieldOpnd)

{

if (PHASE_OFF(Js::ClosureRangeCheckPhase, this))

{

return;

}

Assert(IsTopFunc());

if (this->slotArrayCheckTable == nullptr)

{

this->slotArrayCheckTable = SlotArrayCheckTable::New(m_alloc, 4);

}

PropertySym *propertySym = fieldOpnd->m_sym->AsPropertySym();

uint32 slot = propertySym->m_propertyId;

uint32 *pSlotId = this->slotArrayCheckTable->FindOrInsert(slot, propertySym->m_stackSym->m_id);

if (pSlotId && (*pSlotId == (uint32)-1 || *pSlotId < slot))

{

*pSlotId = propertySym->m_propertyId;

}

}

void Func::AddFrameDisplayCheck(IR::SymOpnd *fieldOpnd, uint32 slotId)

{

if (PHASE_OFF(Js::ClosureRangeCheckPhase, this))

{

return;

}

Assert(IsTopFunc());

if (this->frameDisplayCheckTable == nullptr)

{

this->frameDisplayCheckTable = FrameDisplayCheckTable::New(m_alloc, 4);

}

PropertySym *propertySym = fieldOpnd->m_sym->AsPropertySym();

FrameDisplayCheckRecord **record = this->frameDisplayCheckTable->FindOrInsertNew(propertySym->m_stackSym->m_id);

if (*record == nullptr)

{

*record = JitAnew(m_alloc, FrameDisplayCheckRecord);

}

uint32 frameDisplaySlot = propertySym->m_propertyId;

if ((*record)->table == nullptr || (*record)->slotId < frameDisplaySlot)

{

(*record)->slotId = frameDisplaySlot;

}

if (slotId != (uint32)-1)

{

if ((*record)->table == nullptr)

{

(*record)->table = SlotArrayCheckTable::New(m_alloc, 4);

}

uint32 *pSlotId = (*record)->table->FindOrInsert(slotId, frameDisplaySlot);

if (pSlotId && *pSlotId < slotId)

{

*pSlotId = slotId;

}

}

}

void Func::InitLocalClosureSyms()

{

Assert(this->m_localClosureSym == nullptr);

// Allocate stack space for closure pointers. Do this only if we're jitting for stack closures, and

// tell bailout that these are not byte code symbols so that we don't try to encode them in the bailout record,

// as they don't have normal lifetimes.

Js::RegSlot regSlot = GetJITFunctionBody()->GetLocalClosureReg();

if (regSlot != Js::Constants::NoRegister)

{

this->m_localClosureSym =

StackSym::FindOrCreate(static_cast<SymID>(regSlot),

this->DoStackFrameDisplay() ? (Js::RegSlot)-1 : regSlot,

this);

}

regSlot = this->GetJITFunctionBody()->GetParamClosureReg();

if (regSlot != Js::Constants::NoRegister)

{

Assert(this->GetParamClosureSym() == nullptr && !this->GetJITFunctionBody()->IsParamAndBodyScopeMerged());

this->m_paramClosureSym =

StackSym::FindOrCreate(static_cast<SymID>(regSlot),

this->DoStackFrameDisplay() ? (Js::RegSlot) - 1 : regSlot,

this);

}

regSlot = GetJITFunctionBody()->GetLocalFrameDisplayReg();

if (regSlot != Js::Constants::NoRegister)

{

this->m_localFrameDisplaySym =

StackSym::FindOrCreate(static_cast<SymID>(regSlot),

this->DoStackFrameDisplay() ? (Js::RegSlot)-1 : regSlot,

this);

}

}

bool Func::CanAllocInPreReservedHeapPageSegment ()

{

#ifdef _CONTROL_FLOW_GUARD

return PHASE_FORCE1(Js::PreReservedHeapAllocPhase) || (!PHASE_OFF1(Js::PreReservedHeapAllocPhase) &&

!IsJitInDebugMode() && GetThreadContextInfo()->IsCFGEnabled()

//&& !GetScriptContext()->IsScriptContextInDebugMode()

#if _M_IX86

&& m_workItem->GetJitMode() == ExecutionMode::FullJit

#if ENABLE_OOP_NATIVE_CODEGEN

&& (JITManager::GetJITManager()->IsJITServer()

? GetOOPCodeGenAllocators()->canCreatePreReservedSegment

: GetInProcCodeGenAllocators()->canCreatePreReservedSegment)

#else

&& GetInProcCodeGenAllocators()->canCreatePreReservedSegment

#endif

);

#elif _M_X64

&& true);

#else

&& false); //Not yet implemented for architectures other than x86 and amd64.

#endif //_M_ARCH

#else

return false;