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

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

// Copyright (c) 2021 ChakraCore Project Contributors. All rights reserved.

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

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

#include "Backend.h"

void

Inline::Optimize()

{

this->Optimize(this->topFunc);

}

void

Inline::Optimize(Func *func, __in_ecount_opt(callerArgOutCount) IR::Instr *callerArgOuts[], Js::ArgSlot callerArgOutCount, uint recursiveInlineDepth)

{

if (!func->DoInline() || !topFunc->DoInline())

{

return;

}

bool doFixedMethods = !PHASE_OFF(Js::FixedMethodsPhase, func);

const FunctionJITTimeInfo * inlinerData = func->GetWorkItem()->GetJITTimeInfo();

bool doInline = (inlinerData->GetInlineeCount() > 0 || inlinerData->IsLdFldInlineePresent());

if (PHASE_OFF(Js::InlinePhase, this->topFunc) ||

PHASE_OFF(Js::InlinePhase, func) ||

func->IsJitInDebugMode())

{

doInline = false;

}

func->actualCount = callerArgOutCount;

// Current for..in depth starts with the inlinee's base depth

this->currentForInDepth = func->m_forInLoopBaseDepth;

// Keep the caller's "this" symbol (if any).

StackSym *symThis = nullptr;

lastStatementBoundary = nullptr;

IR::LabelInstr* loopTop = nullptr;

int32 backEdgeCount = 0;

// Profile data already filter call site outside of loops if the function has loops, so we don't need to detect that here.

FOREACH_INSTR_EDITING(instr, instrNext, func->m_headInstr)

{

bool isInlined = false;

bool isPolymorphic = false;

bool isBuiltIn = false;

bool isCtor = false;

if (doInline)

{

switch (instr->m_opcode)

{

case Js::OpCode::StatementBoundary:

lastStatementBoundary = instr->AsPragmaInstr();

break;

case Js::OpCode::Label:

{

if (!loopTop && instr->AsLabelInstr()->m_isLoopTop)

{

// We only need to know if we are inside loop or not, it doesn't matter how many nested levels we are in.

// This is the cheap way of doing so.

loopTop = instr->AsLabelInstr();

AnalysisAssert(loopTop);

this->isInLoop++;

backEdgeCount = loopTop->labelRefs.Count();

}

if (instr->AsLabelInstr()->m_isForInExit)

{

AssertOrFailFast(this->currentForInDepth != 0);

this->currentForInDepth--;

}

}

break;

case Js::OpCode::InitForInEnumerator:

// Loop body uses the for in enumerator in the interpreter frame.

// No need to keep track of its depth

if (!func->IsLoopBody())

{

this->currentForInDepth++;

}

break;

case Js::OpCode::BrOnNotEmpty:

// Byte code doesn't emit BrOnNotEmpty, and we have done any transformation yet.

Assert(false);

break;

case Js::OpCode::BrOnEmpty:

// Loop body uses the for in enumerator in the interpreter frame.

// No need to keep track of its depth

if (!func->IsLoopBody())

{

instr->AsBranchInstr()->GetTarget()->m_isForInExit = true;

}

break;

case Js::OpCode::StFld:

case Js::OpCode::LdFld:

case Js::OpCode::LdFldForCallApplyTarget:

{

// Try inlining of getter setter

if (!inlinerData->IsLdFldInlineePresent())

{

break;

}

if (!instr->IsProfiledInstr())

{

break;

}

if (!(instr->AsProfiledInstr()->u.FldInfo().flags & Js::FldInfoFlags::FldInfo_FromAccessor))

{

break;

}

bool getter = instr->m_opcode != Js::OpCode::StFld;

IR::Opnd *opnd = getter ? instr->GetSrc1() : instr->GetDst();

if (!(opnd && opnd->IsSymOpnd()))

{

break;

}

IR::SymOpnd* symOpnd = opnd->AsSymOpnd();

if (!symOpnd->m_sym->IsPropertySym())

{

break;

}

Assert(symOpnd->AsSymOpnd()->IsPropertySymOpnd());

const auto inlineCacheIndex = symOpnd->AsPropertySymOpnd()->m_inlineCacheIndex;

const FunctionJITTimeInfo * inlineeData = inlinerData->GetLdFldInlinee(inlineCacheIndex);

if (!inlineeData)

{

break;

}

JITTimeFunctionBody * body = inlineeData->GetBody();

if (!body)

{

break;

}

bool isInlinePhaseOff = PHASE_OFF(Js::InlineCandidatePhase, inlineeData) ||

PHASE_OFF(Js::InlineAccessorsPhase, inlineeData) ||

(getter && PHASE_OFF(Js::InlineGettersPhase, inlineeData)) ||

(!getter && PHASE_OFF(Js::InlineSettersPhase, inlineeData));

if (isInlinePhaseOff)

{

break;

}

this->InlineGetterSetterFunction(instr, inlineeData, symThis, inlineCacheIndex, getter /*isGetter*/, &isInlined, recursiveInlineDepth);

break;

}

case Js::OpCode::NewScObjArray:

// We know we're not going to inline these. Just break out and try to do a fixed function check.

isCtor = true;

isBuiltIn = true;

break;

case Js::OpCode::NewScObject:

isCtor = true;

if (PHASE_OFF(Js::InlineConstructorsPhase, this->topFunc))

{

break;

}

// fall-through

case Js::OpCode::CallI:

{

IR::PropertySymOpnd* methodValueOpnd = GetMethodLdOpndForCallInstr(instr);

if (this->inlineesProcessed == inlinerData->GetInlineeCount())

{

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

break;

}

if(!instr->IsProfiledInstr())

{

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

break;

}

const auto profileId = static_cast<Js::ProfileId>(instr->AsProfiledInstr()->u.profileId);

if(profileId >= func->GetJITFunctionBody()->GetProfiledCallSiteCount())

{

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

break;

}

const FunctionJITTimeInfo * inlineeData = inlinerData->GetInlinee(profileId);

IR::Instr * callbackDefInstr = nullptr;

if (inlineeData == nullptr)

{

if (PHASE_ENABLED(InlineCallbacksPhase, func))

{

callbackDefInstr = TryGetCallbackDefInstrForCallInstr(instr);

}

if (callbackDefInstr == nullptr)

{

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

break;

}

}

if (inlineeData != nullptr && inlinerData->IsPolymorphicCallSite(profileId))

{

if (PHASE_ENABLED(InlineCallbacksPhase, func))

{

callbackDefInstr = TryGetCallbackDefInstrForCallInstr(instr);

if (callbackDefInstr == nullptr)

{

isPolymorphic = true;

}

}

else

{

isPolymorphic = true;

}

}

if (callbackDefInstr != nullptr)

{

Js::ProfileId callSiteId = static_cast<Js::ProfileId>(callbackDefInstr->AsProfiledInstr()->u.profileId);

inlineeData = callbackDefInstr->m_func->GetWorkItem()->GetJITTimeInfo()->GetCallbackInlinee(callSiteId);

#if ENABLE_DEBUG_CONFIG_OPTIONS

char16 debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

INLINE_CALLBACKS_TRACE(_u("INLINING : Inlining callback at\tCallSite: %d\tCaller: %s (%s)\n"),

callSiteId, inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer));

#endif

}

if (isPolymorphic)

{

if (isCtor ||

(PHASE_OFF(Js::PolymorphicInlinePhase, this->topFunc) || PHASE_OFF(Js::PolymorphicInlinePhase, func)) ||

(this->IsInliningOutSideLoops() && !PHASE_FORCE(Js::InlinePhase, this->topFunc) && !PHASE_FORCE(Js::InlinePhase, func)))

{

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

char16 debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

#endif

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic): Skip Inline: Inlining polymorphic call site outside loop\tIsConstructorCall: %s \tisTopFunc: %s\tCaller: %s (%s)\n"),

(isCtor? _u("true"): _u("false")), (this->topFunc != func? _u("true"):_u("false")),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer));

// TODO: Constructor polymorphic inlining

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

break;

}

if (!PHASE_OFF(Js::FixedMethodsPhase, this->topFunc) && !PHASE_OFF(Js::PolymorphicInlineFixedMethodsPhase, this->topFunc))

{

instrNext = InlinePolymorphicFunctionUsingFixedMethods(instr, inlinerData, symThis, profileId, methodValueOpnd, &isInlined, recursiveInlineDepth);

}

else

{

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

instrNext = InlinePolymorphicFunction(instr, inlinerData, symThis, profileId, &isInlined, recursiveInlineDepth);

}

}

else

{

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

Js::OpCode builtInInlineCandidateOpCode;

ValueType builtInReturnType;

// If the inlinee info is the array constructor, just change the opcode to NewScObjArray

// so that we will inline the array allocation in lower

if (isCtor && inlineeData->GetFunctionInfoAddr() == this->topFunc->GetThreadContextInfo()->GetJavascriptArrayNewInstanceAddr())

{

isBuiltIn = true;

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

instr->AsProfiledInstr()->u.profileId = Js::Constants::NoProfileId;

break;

}

isBuiltIn = InliningDecider::GetBuiltInInfo(inlineeData, &builtInInlineCandidateOpCode, &builtInReturnType);

if(!builtInReturnType.IsUninitialized() && instr->GetDst())

{

Assert(!inlineeData->HasBody());

AssertMsg(instr->m_opcode != Js::OpCode::NewScObjArray, "We should have broken out of the switch statement earlier on this opcode.");

// Value types for the array built-in calls are pulled from the profile; don't change them here.

if ((instr->m_opcode != Js::OpCode::NewScObjArray) ||

!instr->GetDst()->GetValueType().IsLikelyNativeArray())

{

// Assume that this built-in function is not going to be inlined, so the return type cannot be definite

instr->GetDst()->SetValueType(builtInReturnType.ToLikely());

}

}

bool isInlinePhaseOff = inlineeData->HasBody() ?

PHASE_OFF(Js::InlineCandidatePhase, inlineeData) :

PHASE_OFF1(Js::InlineBuiltInPhase);

if (isInlinePhaseOff)

{

break;

}

if(!inlineeData->HasBody() && builtInInlineCandidateOpCode == 0)

{

// This built-in function is not going to be inlined

break;

}

bool hasDstUsedBuiltInReturnType = false;

if(!inlineeData->HasBody())

{

Assert(builtInInlineCandidateOpCode != 0);

if(isCtor)

{

// Inlining a built-in function called as a constructor is currently not supported. Although InliningDecider

// already checks for this, profile data matching with a function does not take into account the difference

// between a constructor call and a regular function call, so need to check it again.

break;

}

// This built-in function should be inlined, so reset the destination's value type

if(!builtInReturnType.IsUninitialized())

{

if(instr->GetDst())

{

hasDstUsedBuiltInReturnType = true;

instr->GetDst()->SetValueType(builtInReturnType);

if(builtInReturnType.IsDefinite())

{

instr->GetDst()->SetValueTypeFixed();

}

}

}

}

else

{

if (!inlineeData->GetBody()->HasProfileInfo()) // Don't try to inline a function if it doesn't have profile data

{

break;

}

uint16 constantArguments = 0;

if (!PHASE_OFF(Js::InlineRecursivePhase, func))

{

instr->IterateArgInstrs([&](IR::Instr* argInstr) {

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

if (!src1->IsRegOpnd())

{

return false;

}

StackSym *sym = src1->AsRegOpnd()->m_sym;

if (sym->IsIntConst())

{

if (argInstr->GetSrc2() && argInstr->GetSrc2()->IsSymOpnd())

{

StackSym *dstSym = argInstr->GetDst()->AsSymOpnd()->m_sym->AsStackSym();

Assert(dstSym->IsSingleDef());

Assert(dstSym->IsArgSlotSym());

Js::ArgSlot argCount = dstSym->GetArgSlotNum() - 1;

if (argCount == Js::Constants::MaximumArgumentCountForConstantArgumentInlining)

{

return true;

}

constantArguments |= (1 << argCount);

}

}

return false;

});

}

if (!inliningHeuristics.BackendInlineIntoInliner(inlineeData,

func, this->topFunc, profileId, isCtor, true /*isFixedMethodCall*/,

this->IsInliningOutSideLoops(), this->isInLoop != 0, recursiveInlineDepth, constantArguments))

{

break;

}

}

instrNext = builtInInlineCandidateOpCode != 0 ?

this->InlineBuiltInFunction(instr, inlineeData, builtInInlineCandidateOpCode, inlinerData, symThis, &isInlined, profileId, recursiveInlineDepth, instr) :

this->InlineScriptFunction(instr, inlineeData, symThis, profileId, &isInlined, callbackDefInstr, recursiveInlineDepth);

if (!isInlined && hasDstUsedBuiltInReturnType)

{

// We haven't actually inlined the builtin, we need to revert the value type to likely

instr->GetDst()->UnsetValueTypeFixed();

instr->GetDst()->SetValueType(instr->GetDst()->GetValueType().ToLikely());

}

}

if(++this->inlineesProcessed == inlinerData->GetInlineeCount())

{

// getterSetter inline caches are shared and we have no way of knowing how many more are present

if (!inlinerData->IsLdFldInlineePresent() && !doFixedMethods)

{

return ;

}

}

break;

}

case Js::OpCode::AsmJsCallI:

{

if (this->inlineesProcessed == inlinerData->GetInlineeCount() || !instr->IsProfiledInstr())

{

break;

}

const auto profileId = static_cast<Js::ProfileId>(instr->AsProfiledInstr()->u.profileId);

if (profileId >= func->GetJITFunctionBody()->GetProfiledCallSiteCount())

{

break;

}

const auto inlineeData = inlinerData->GetInlinee(profileId);

if (!inlineeData)

{

break;

}

if (PHASE_OFF(Js::InlineCandidatePhase, inlineeData))

{

break;

}

// Don't try to inline a function if it doesn't have profile data

if (!inlineeData->GetBody()->HasProfileInfo())

{

break;

}

uint16 constantArguments = 0;

if (!PHASE_OFF(Js::InlineRecursivePhase, func))

{

instr->IterateArgInstrs([&](IR::Instr* argInstr) {

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

if (!src1->IsRegOpnd())

{

return false;

}

StackSym *sym = src1->AsRegOpnd()->m_sym;

if (sym->IsIntConst())

{

if (argInstr->GetSrc2() && argInstr->GetSrc2()->IsSymOpnd())

{

StackSym *dstSym = argInstr->GetDst()->AsSymOpnd()->m_sym->AsStackSym();

Assert(dstSym->IsSingleDef());

Assert(dstSym->IsArgSlotSym());

Js::ArgSlot argCount = dstSym->GetArgSlotNum() - 1;

if (argCount == Js::Constants::MaximumArgumentCountForConstantArgumentInlining)

{

return true;

}

constantArguments |= (1 << argCount);

}

}

return false;

});

}

if (!inliningHeuristics.BackendInlineIntoInliner(

inlineeData, func, this->topFunc, profileId, isCtor, true /*isFixedMethodCall*/,

this->IsInliningOutSideLoops(), this->isInLoop != 0, recursiveInlineDepth, constantArguments))

{

break;

}

instrNext = this->InlineScriptFunction(instr, inlineeData, symThis, profileId, &isInlined, nullptr, recursiveInlineDepth);

if (++this->inlineesProcessed == inlinerData->GetInlineeCount())

{

return;

}

break;

}

case Js::OpCode::CallIExtended:

{

if (this->inlineesProcessed == inlinerData->GetInlineeCount())

{

break;

}

if (!instr->IsProfiledInstr())

{

break;

}

const auto profileId = static_cast<Js::ProfileId>(instr->AsProfiledInstr()->u.profileId);

if (profileId >= func->GetJITFunctionBody()->GetProfiledCallSiteCount())

{

break;

}

const auto inlineeData = inlinerData->GetInlinee(profileId);

if (!inlineeData)

{

break;

}

if (Lowerer::IsSpreadCall(instr))

{

InlineSpread(instr);

}

break;

}

case Js::OpCode::ArgOut_A:

InlConstFoldArg(instr, callerArgOuts, callerArgOutCount);

break;

case Js::OpCode::LdThis:

Assert(instr->GetDst() && instr->GetDst()->IsRegOpnd());

Assert(symThis == nullptr);

symThis = instr->GetDst()->AsRegOpnd()->m_sym;

break;

case Js::OpCode::CheckThis:

// Is this possible? Can we be walking an inlinee here? Doesn't hurt to support this case...

Assert(instr->GetSrc1() && instr->GetSrc1()->IsRegOpnd());

Assert(symThis == nullptr);

symThis = instr->GetSrc1()->AsRegOpnd()->m_sym;

break;

default:

{

if (loopTop && instr->IsBranchInstr())

{

// Look for the back edge to loopTop.

IR::BranchInstr *branch = instr->AsBranchInstr();

IR::LabelInstr *labelDestination = branch->GetTarget();

if (labelDestination == loopTop) // We found the back edge

{

backEdgeCount--;

if (backEdgeCount == 0) // We have seen all the back edges, hence we are outside loop now.

{

Assert(this->isInLoop > 0);

--this->isInLoop;

loopTop = nullptr;

}

}

}

}

}

}

// If we chose not to inline, let's try to optimize this call if it uses a fixed method

if (!isInlined)

{

switch (instr->m_opcode)

{

case Js::OpCode::NewScObject:

case Js::OpCode::NewScObjArray:

isCtor = true;

// intentionally fall through.

case Js::OpCode::CallI:

{

IR::PropertySymOpnd* methodValueOpnd = GetMethodLdOpndForCallInstr(instr);

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

StackSym* originalCallTargetStackSym = instr->GetSrc1()->GetStackSym();

bool originalCallTargetOpndIsJITOpt = instr->GetSrc1()->GetIsJITOptimizedReg();

bool safeThis = false;

if (TryOptimizeCallInstrWithFixedMethod(instr, nullptr, isPolymorphic /*isPolymorphic*/, isBuiltIn /*isBuiltIn*/, isCtor /*isCtor*/, false /*isInlined*/, safeThis /*unused here*/))

{

Assert(originalCallTargetStackSym != nullptr);

// Insert a ByteCodeUsesInstr to make sure the methodValueDstOpnd's constant value is captured by any

// bailout that occurs between CheckFixedMethodField and CallI.

IR::ByteCodeUsesInstr * useCallTargetInstr = IR::ByteCodeUsesInstr::New(instr);

useCallTargetInstr->SetRemovedOpndSymbol(originalCallTargetOpndIsJITOpt, originalCallTargetStackSym->m_id);

instr->InsertBefore(useCallTargetInstr);

// Split NewScObject into NewScObjectNoCtor and CallI, but don't touch NewScObjectArray.

if (instr->m_opcode == Js::OpCode::NewScObject && !PHASE_OFF(Js::SplitNewScObjectPhase, this->topFunc))

{

SplitConstructorCall(instr, false, true);

}

}

else if (instr->m_opcode == Js::OpCode::NewScObjArray)

{

if (instr->GetDst() && instr->GetDst()->GetValueType().IsLikelyNativeArray())

{

// We expect to create a native array here, so we'll insert a check against the

// expected call target, which requires a bailout.

instr = instr->ConvertToBailOutInstr(instr, IR::BailOutOnNotNativeArray);

}

}

}

break;

}

}

} NEXT_INSTR_EDITING;

INLINE_FLUSH();

}

uint Inline::FillInlineesDataArray(

const FunctionJITTimeInfo* inlineeJitTimeData,

_Out_writes_to_(inlineesDataArrayLength, (return >= inlineesDataArrayLength ? inlineesDataArrayLength : return)) const FunctionJITTimeInfo ** inlineesDataArray,

uint inlineesDataArrayLength

)

{

uint inlineeCount = 0;

while(inlineeJitTimeData)

{

if (inlineeCount >= inlineesDataArrayLength)

{

// Count the actual number of inlinees for logging.

while (inlineeJitTimeData)

{

inlineeCount++;

inlineeJitTimeData = inlineeJitTimeData->GetNext();

}

return inlineeCount;

}

intptr_t inlineeFunctionInfoAddr = inlineeJitTimeData->GetFunctionInfoAddr();

#ifdef DBG

if (inlineeJitTimeData->HasBody() && !PHASE_OFF(Js::PolymorphicInlinePhase, inlineeJitTimeData))

#endif

{

const FunctionJITTimeInfo* rightInlineeJitTimeData = inlineeJitTimeData->GetJitTimeDataFromFunctionInfoAddr(inlineeFunctionInfoAddr);

if (rightInlineeJitTimeData)

{

inlineesDataArray[inlineeCount] = rightInlineeJitTimeData;

Assert(rightInlineeJitTimeData->GetBody() == inlineeJitTimeData->GetBody());

#ifdef DBG

for (uint k = 0; k < inlineeCount; k++)

{

if (inlineesDataArray[k]->GetBody() == inlineeJitTimeData->GetBody())

{

AssertMsg(false, "We should never see duplicate function body here");

}

}

#endif

inlineeCount++;

}

else

{

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

char16 debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

#endif

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic): Missing jit time data skipped inlinee\tInlinee: %s (%s)\n"),

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer));

}

}

inlineeJitTimeData = inlineeJitTimeData->GetNext();

}

return inlineeCount;

}

void Inline::FillInlineesDataArrayUsingFixedMethods(

const FunctionJITTimeInfo* inlineeJitTimeData,

__inout_ecount(inlineesDataArrayLength) const FunctionJITTimeInfo ** inlineesDataArray,

uint inlineesDataArrayLength,

__inout_ecount(cachedFixedInlineeCount) FixedFieldInfo* fixedFieldInfoArray,

uint16 cachedFixedInlineeCount

)

{

AnalysisAssert(cachedFixedInlineeCount <= inlineesDataArrayLength);

JITTimeFunctionBody* inlineeFuncBody = nullptr;

while (inlineeJitTimeData)

{

if (inlineeJitTimeData->HasBody())

{

inlineeFuncBody = inlineeJitTimeData->GetBody();

if (!PHASE_OFF(Js::PolymorphicInlinePhase, inlineeJitTimeData) && !PHASE_OFF(Js::PolymorphicInlineFixedMethodsPhase, inlineeJitTimeData))

{

const FunctionJITTimeInfo * jitTimeData = inlineeJitTimeData->GetJitTimeDataFromFunctionInfoAddr(inlineeJitTimeData->GetFunctionInfoAddr());

if (jitTimeData)

{

for (uint16 i = 0; i < cachedFixedInlineeCount; i++)

{

if (inlineeJitTimeData->GetFunctionInfoAddr() == fixedFieldInfoArray[i].GetFuncInfoAddr())

{

inlineesDataArray[i] = inlineeJitTimeData->GetJitTimeDataFromFunctionInfoAddr(inlineeJitTimeData->GetFunctionInfoAddr());

break;

}

}

}

else

{

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

char16 debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

#endif

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic): Missing jit time data skipped inlinee\tInlinee: %s (%s)\n"),

inlineeFuncBody->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer));

}

}

}

inlineeJitTimeData = inlineeJitTimeData->GetNext();

}

}

IR::Instr *

Inline::InlinePolymorphicFunctionUsingFixedMethods(IR::Instr *callInstr, const FunctionJITTimeInfo * inlinerData, const StackSym *symCallerThis, const Js::ProfileId profileId, IR::PropertySymOpnd* methodValueOpnd, bool* pIsInlined, uint recursiveInlineDepth)

{

IR::Instr* instrNext = callInstr->m_next;

*pIsInlined = false;

const FunctionJITTimeInfo* inlineeJitTimeData = inlinerData->GetInlinee(profileId);

AnalysisAssert(inlineeJitTimeData);

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

char16 debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

char16 debugStringBuffer2[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];

#endif

// Abort conditions:

if(!inlineeJitTimeData->GetNext())

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic): Skip Inline: Missing JitTime data \tInlinee: %s (%s):\tCaller: %s (%s)\n"),

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

// There are no multiple codegen jit-time data allocated for this call site, not sure how is this possible, abort

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

return instrNext;

}

// arguments exceed MaxInlineeArgoutCount

if (callInstr->GetSrc2() &&

callInstr->GetSrc2()->IsSymOpnd() &&

callInstr->GetSrc2()->AsSymOpnd()->m_sym->AsStackSym()->GetArgSlotNum() > Js::InlineeCallInfo::MaxInlineeArgoutCount)

{

// This is a hard limit as we only use 4 bits to encode the actual count in the InlineeCallInfo. Although

// InliningDecider already checks for this, the check is against profile data that may not be accurate since profile

// data matching does not take into account some types of changes to source code. Need to check this again with current

// information.

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic): Skip Inline: ArgSlot > MaxInlineeArgoutCount\tInlinee: %s (%s)\tArgSlotNum: %d\tMaxInlineeArgoutCount: %d\tCaller: %s (%s)\n"),

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer) , callInstr->GetSrc2()->AsSymOpnd()->m_sym->AsStackSym()->GetArgSlotNum(),

Js::InlineeCallInfo::MaxInlineeArgoutCount, inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

return instrNext;

}

uint inlineeCount = 0;

const FunctionJITTimeInfo * tmpInlineeJitTimeData = inlineeJitTimeData;

while(tmpInlineeJitTimeData)

{

inlineeCount++;

tmpInlineeJitTimeData = tmpInlineeJitTimeData->GetNext();

}

// Inlinee count too small (<2) or too large (>4)

if (inlineeCount < 2 || inlineeCount > Js::DynamicProfileInfo::maxPolymorphicInliningSize)

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic): Skip Inline: Inlinee count either too small or too large: InlineeCount %d (Max: %d)\tInlinee: %s (%s):\tCaller: %s (%s)\n"),

inlineeCount, Js::DynamicProfileInfo::maxPolymorphicInliningSize,

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

TryResetObjTypeSpecFldInfoOn(methodValueOpnd);

TryDisableRuntimePolymorphicCacheOn(methodValueOpnd);

return instrNext;

}

*pIsInlined = true;

IR::Instr* tmpInstr = callInstr->m_prev;

while (tmpInstr->m_opcode != Js::OpCode::StartCall)

{

if ((tmpInstr->m_opcode != Js::OpCode::ArgOut_A) && (tmpInstr->m_opcode != Js::OpCode::Ld_A))

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Skip Inline: ArgOuts may have side effects Inlinee: %s (%s):\tCaller: %s (%s)\n"),

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

tmpInstr = tmpInstr->m_prev;

}

StackSym* methodValueSym = callInstr->GetSrc1()->AsRegOpnd()->m_sym->AsStackSym();

if (!methodValueSym->IsSingleDef())

{

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

IR::Instr* ldMethodFldInstr = methodValueSym->GetInstrDef();

if (!(ldMethodFldInstr->GetSrc1()->IsSymOpnd() && ldMethodFldInstr->GetSrc1()->AsSymOpnd()->IsPropertySymOpnd()))

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Skip Inline: Did not find property sym operand for the method load Inlinee: %s (%s):\tCaller: %s (%s)\n"),

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

IR::PropertySymOpnd* methodPropertyOpnd = ldMethodFldInstr->GetSrc1()->AsPropertySymOpnd();

if (!methodPropertyOpnd->HasObjTypeSpecFldInfo())

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Skip Inline: no ObjTypeSpecFldInfo to get Fixed Methods from Inlinee: %s (%s):\tCaller: %s (%s)\n"),

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

if (!methodPropertyOpnd->HasFixedValue())

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Skip Inline: ObjTypeSpecFldInfo doesn't have Fixed Methods for one or some of the inlinees Inlinee: %s (%s):\tCaller: %s (%s)\n"),

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

uint16 cachedFixedInlineeCount = methodPropertyOpnd->GetFixedFieldCount();

if (cachedFixedInlineeCount < 2)

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Skip Inline: fixed function count too less %d (Max: %d)\tInlinee: %s (%s):\tCaller: %s (%s)\n"),

cachedFixedInlineeCount, Js::DynamicProfileInfo::maxPolymorphicInliningSize,

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

FixedFieldInfo* fixedFunctionInfoArray = methodPropertyOpnd->GetFixedFieldInfoArray();

// It might so be the case that two objects of different types call the same function (body), for e.g., if they share the prototype on which the function is defined.

uint uniqueFixedFunctionCount = HandleDifferentTypesSameFunction(fixedFunctionInfoArray, cachedFixedInlineeCount);

if (uniqueFixedFunctionCount != inlineeCount)

{

// inlineeCount obtained from the inlineeJitTimeData is more accurate than cached number of fixed methods for inlinees.

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Skip Inline: cached fixed function count (%d) doesn't match inlinee count (%d); (Max: %d)\tInlinee: %s (%s):\tCaller: %s (%s)\n"),

uniqueFixedFunctionCount, inlineeCount, Js::DynamicProfileInfo::maxPolymorphicInliningSize,

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

Assert(cachedFixedInlineeCount <= Js::DynamicProfileInfo::maxPolymorphicInliningSize);

const FunctionJITTimeInfo* inlineesDataArray[Js::DynamicProfileInfo::maxPolymorphicInliningSize] = {};

FillInlineesDataArrayUsingFixedMethods(inlineeJitTimeData, inlineesDataArray, Js::DynamicProfileInfo::maxPolymorphicInliningSize, fixedFunctionInfoArray, cachedFixedInlineeCount);

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

{

if(!inlineesDataArray[i] || !inlineesDataArray[i]->HasBody())

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Skip Inline: One of the inlinees doesn't have the corresponding object/prototype's type cached\tCaller: %s (%s)\n"),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer));

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

#if DBG

if(inlineesDataArray[i]->GetBody() && inlineesDataArray[i]->GetFunctionInfoAddr() != methodPropertyOpnd->GetFixedFunction(i)->GetFuncInfoAddr())

{

AssertMsg(false, "inlineesDataArray and fixedfunctionInfoArray should be aligned with each other at this point");

}

#endif

while (fixedFunctionInfoArray[i].NextHasSameFixedField())

{

i++;

}

}

bool safeThis = true; // Eliminate CheckThis for inlining.

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

{

if (!methodPropertyOpnd->GetFieldValue(i))

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Skip Inline: no fixed method for one of the inlinees; Inlinee: %s (%s):\tCaller: %s (%s)\n"),

inlineesDataArray[i]->GetBody()->GetDisplayName(), inlineesDataArray[i]->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

if (i == 0)

{

// Do all the general, non-function-object-specific checks just once.

if (!TryOptimizeCallInstrWithFixedMethod(callInstr, inlineesDataArray[i], true, false, false, true /*isInlined*/, safeThis, true /*dontOptimizeJustCheck*/, i))

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Skip Inline: can't optimize using Fixed Methods %d (Max: %d)\tInlinee: %s (%s):\tCaller: %s (%s)\n"),

inlineeCount, Js::DynamicProfileInfo::maxPolymorphicInliningSize,

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

}

else

{

if (methodPropertyOpnd->GetFixedFunction(i) &&

methodPropertyOpnd->GetFixedFunction(i)->GetFuncInfoAddr() != inlineesDataArray[i]->GetFunctionInfoAddr())

{

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Skip Inline: can't optimize using Fixed Methods %d (Max: %d)\tInlinee: %s (%s):\tCaller: %s (%s)\n"),

inlineeCount, Js::DynamicProfileInfo::maxPolymorphicInliningSize,

inlineeJitTimeData->GetBody()->GetDisplayName(), inlineeJitTimeData->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

return InlinePolymorphicFunction(callInstr, inlinerData, symCallerThis, profileId, pIsInlined, recursiveInlineDepth, true);

}

}

Js::TypeId typeId = methodPropertyOpnd->GetTypeId(i);

if(!(typeId > Js::TypeIds_LastJavascriptPrimitiveType && typeId <= Js::TypeIds_LastTrueJavascriptObjectType))

{

// Don't eliminate CheckThis if it cannot be done for any one of the inlinees

safeThis = false;

}

while (fixedFunctionInfoArray[i].NextHasSameFixedField())

{

i++;

}

}

Assert(methodPropertyOpnd->IsPoly());

// emit property guard check for the method load, and load type

IR::RegOpnd *typeOpnd = IR::RegOpnd::New(TyVar, callInstr->m_func);

IR::Instr* propertyGuardCheckInstr = IR::Instr::New(Js::OpCode::CheckPropertyGuardAndLoadType, typeOpnd, ldMethodFldInstr->GetSrc1(), callInstr->m_func);

ldMethodFldInstr->InsertBefore(propertyGuardCheckInstr);

propertyGuardCheckInstr->SetByteCodeOffset(ldMethodFldInstr);

propertyGuardCheckInstr = propertyGuardCheckInstr->ConvertToBailOutInstr(ldMethodFldInstr, IR::BailOutFailedFixedFieldCheck);

POLYMORPHIC_INLINE_TESTTRACE(_u("------------------------------------------------\n"));

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

{

JITTimeFunctionBody *inlineeFunctionBody = inlineesDataArray[i]->GetBody();

POLYMORPHIC_INLINE_TESTTRACE(_u("INLINING (Polymorphic; Using Fixed Methods): Start inlining: \tInlinee: %s (%s):\tCaller: %s (%s)\n"),

inlineeFunctionBody->GetDisplayName(), inlineesDataArray[i]->GetDebugNumberSet(debugStringBuffer),

inlinerData->GetBody()->GetDisplayName(), inlinerData->GetDebugNumberSet(debugStringBuffer2));

while (fixedFunctionInfoArray[i].NextHasSameFixedField())

{

i++;

}

}

POLYMORPHIC_INLINE_TESTTRACE(_u("------------------------------------------------\n"));

IR::RegOpnd * returnValueOpnd;

if (callInstr->GetDst())

{

returnValueOpnd = callInstr->UnlinkDst()->AsRegOpnd();

}

else

{

returnValueOpnd = nullptr;

}

callInstr->MoveArgs(/*generateByteCodeCapture*/ true);

callInstr->m_opcode = Js::OpCode::CallIFixed;

// iterate over inlineesDataArray to emit each inlinee

IR::LabelInstr * doneLabel = IR::LabelInstr::New(Js::OpCode::Label, callInstr->m_func, false);

IR::Instr* dispatchStartLabel = IR::LabelInstr::New(Js::OpCode::Label, callInstr->m_func, false);

callInstr->InsertBefore(dispatchStartLabel);

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

{

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

callInstr->InsertBefore(inlineeStartLabel);

IR::AddrOpnd * constMethodValueOpnd = IR::AddrOpnd::New(methodPropertyOpnd->GetFieldValue(i), IR::AddrOpndKind::AddrOpndKindDynamicVar, callInstr->m_func);

constMethodValueOpnd->m_isFunction = true;

constMethodValueOpnd->m_metadata = &methodPropertyOpnd->GetFixedFieldInfoArray()[i];

InsertOneInlinee(callInstr, returnValueOpnd, constMethodValueOpnd, inlineesDataArray[i], inlineesDataArray[i]->GetRuntimeInfo(), doneLabel, symCallerThis, safeThis, recursiveInlineDepth);

while (fixedFunctionInfoArray[i].NextHasSameFixedField())

{

dispatchStartLabel->InsertBefore(IR::BranchInstr::New(Js::OpCode::BrAddr_A, inlineeStartLabel, typeOpnd, IR::AddrOpnd::New(methodPropertyOpnd->GetType(i)->GetAddr(),

IR::AddrOpndKindDynamicType, dispatchStartLabel->m_func), dispatchStartLabel->m_func));

this->topFunc->PinTypeRef(methodPropertyOpnd->GetType(i).t); // Keep the types alive as the types may not be equivalent and, hence, won't be kept alive by EquivalentTypeCache

i++;

}

dispatchStartLabel->InsertBefore(IR::BranchInstr::New(Js::OpCode::BrAddr_A, inlineeStartLabel,

typeOpnd, IR::AddrOpnd::New(methodPropertyOpnd->GetType(i)->GetAddr(), IR::AddrOpndKindDynamicType, dispatchStartLabel->m_func), dispatchStartLabel->m_func));

this->topFunc->PinTypeRef(methodPropertyOpnd->GetType(i).t); // Keep the types alive as the types may not be equivalent and, hence, won't be kept alive by EquivalentTypeCache

}

ldMethodFldInstr->Unlink();

ldMethodFldInstr->m_opcode = Js::OpCode::LdMethodFldPolyInlineMiss;

Assert(cachedFixedInlineeCount > 0);

CompletePolymorphicInlining(callInstr, returnValueOpnd, doneLabel, dispatchStartLabel, ldMethodFldInstr, IR::BailOutOnFailedPolymorphicInlineTypeCheck);

this->topFunc->SetHasInlinee();

InsertStatementBoundary(instrNext);

InsertStatementBoundary(ldMethodFldInstr);