Skip to content

Commit cf09b48

Browse files
wyrichtewyrichte
committed
This optimization groups bailout instrs (created by the inliner when a non fixed field is called) into a single instr (CheckFunctionEntryPoint) which can be hoisted outside of a loop.
1 parent 28cd467 commit cf09b48

File tree

8 files changed

+197
-85
lines changed

8 files changed

+197
-85
lines changed

‎lib/Backend/Inline.cpp

Lines changed: 19 additions & 81 deletions
Original file line numberDiff line numberDiff line change
@@ -4443,35 +4443,14 @@ Inline::SplitConstructorCallCommon(
44434443
}
44444444

44454445
void
4446-
Inline::InsertObjectCheck(IR::RegOpnd * funcOpnd, IR::Instr* insertBeforeInstr, IR::Instr*bailOutIfNotObject)
4446+
Inline::InsertFunctionObjectCheck(IR::RegOpnd * funcOpnd, IR::Instr *insertBeforeInstr, IR::Instr *bailOutInstr, const FunctionJITTimeInfo *funcInfo)
44474447
{
4448-
// Bailout if 'functionRegOpnd' is not an object.
4449-
bailOutIfNotObject->SetSrc1(funcOpnd);
4450-
bailOutIfNotObject->SetByteCodeOffset(insertBeforeInstr);
4451-
insertBeforeInstr->InsertBefore(bailOutIfNotObject);
4452-
}
4448+
Js::BuiltinFunction index = Js::JavascriptLibrary::GetBuiltInForFuncInfo(funcInfo->GetLocalFunctionId());
4449+
AssertMsg(index < Js::BuiltinFunction::Count, "Invalid built-in index on a call target marked as built-in");
44534450

4454-
void
4455-
Inline::InsertFunctionTypeIdCheck(IR::RegOpnd * funcOpnd, IR::Instr* insertBeforeInstr, IR::Instr* bailOutIfNotJsFunction)
4456-
{
4457-
// functionTypeRegOpnd = Ld functionRegOpnd->type
4458-
IR::IndirOpnd *functionTypeIndirOpnd = IR::IndirOpnd::New(funcOpnd, Js::RecyclableObject::GetOffsetOfType(), TyMachPtr, insertBeforeInstr->m_func);
4459-
IR::RegOpnd *functionTypeRegOpnd = IR::RegOpnd::New(TyVar, this->topFunc);
4460-
IR::Instr *instr = IR::Instr::New(Js::OpCode::Ld_A, functionTypeRegOpnd, functionTypeIndirOpnd, insertBeforeInstr->m_func);
4461-
if(instr->m_func->HasByteCodeOffset())
4462-
{
4463-
instr->SetByteCodeOffset(insertBeforeInstr);
4464-
}
4465-
insertBeforeInstr->InsertBefore(instr);
4466-
4467-
CompileAssert(sizeof(Js::TypeId) == sizeof(int32));
4468-
// if (functionTypeRegOpnd->typeId != TypeIds_Function) goto $noInlineLabel
4469-
// BrNeq_I4 $noInlineLabel, functionTypeRegOpnd->typeId, TypeIds_Function
4470-
IR::IndirOpnd *functionTypeIdIndirOpnd = IR::IndirOpnd::New(functionTypeRegOpnd, Js::Type::GetOffsetOfTypeId(), TyInt32, insertBeforeInstr->m_func);
4471-
IR::IntConstOpnd *typeIdFunctionConstOpnd = IR::IntConstOpnd::New(Js::TypeIds_Function, TyInt32, insertBeforeInstr->m_func);
4472-
bailOutIfNotJsFunction->SetSrc1(functionTypeIdIndirOpnd);
4473-
bailOutIfNotJsFunction->SetSrc2(typeIdFunctionConstOpnd);
4474-
insertBeforeInstr->InsertBefore(bailOutIfNotJsFunction);
4451+
bailOutInstr->SetSrc1(funcOpnd);
4452+
bailOutInstr->SetSrc2(IR::IntConstOpnd::New(index, TyInt32, insertBeforeInstr->m_func));
4453+
insertBeforeInstr->InsertBefore(bailOutInstr);
44754454
}
44764455

44774456
void
@@ -4480,74 +4459,33 @@ Inline::InsertJsFunctionCheck(IR::Instr * callInstr, IR::Instr *insertBeforeInst
44804459
// This function only inserts bailout for tagged int & TypeIds_Function.
44814460
// As of now this is only used for polymorphic inlining.
44824461
Assert(bailOutKind == IR::BailOutOnPolymorphicInlineFunction);
4483-
44844462
Assert(insertBeforeInstr);
44854463
Assert(insertBeforeInstr->m_func == callInstr->m_func);
44864464

4487-
IR::RegOpnd * funcOpnd = callInstr->GetSrc1()->AsRegOpnd();
4488-
4489-
// bailOutIfNotFunction is primary bailout instruction
4490-
IR::Instr* bailOutIfNotFunction = IR::BailOutInstr::New(Js::OpCode::BailOnNotEqual, bailOutKind, insertBeforeInstr, callInstr->m_func);
4491-
4492-
IR::Instr *bailOutIfNotObject = IR::BailOutInstr::New(Js::OpCode::BailOnNotObject, bailOutKind, bailOutIfNotFunction->GetBailOutInfo(), callInstr->m_func);
4493-
InsertObjectCheck(funcOpnd, insertBeforeInstr, bailOutIfNotObject);
4494-
4495-
InsertFunctionTypeIdCheck(funcOpnd, insertBeforeInstr, bailOutIfNotFunction);
4496-
4497-
}
4498-
4499-
void
4500-
Inline::InsertFunctionInfoCheck(IR::RegOpnd * funcOpnd, IR::Instr *insertBeforeInstr, IR::Instr* bailoutInstr, const FunctionJITTimeInfo *funcInfo)
4501-
{
4502-
// if (VarTo<JavascriptFunction>(r1)->functionInfo != funcInfo) goto noInlineLabel
4503-
// BrNeq_I4 noInlineLabel, r1->functionInfo, funcInfo
4504-
IR::IndirOpnd* opndFuncInfo = IR::IndirOpnd::New(funcOpnd, Js::JavascriptFunction::GetOffsetOfFunctionInfo(), TyMachPtr, insertBeforeInstr->m_func);
4505-
IR::AddrOpnd* inlinedFuncInfo = IR::AddrOpnd::New(funcInfo->GetFunctionInfoAddr(), IR::AddrOpndKindDynamicFunctionInfo, insertBeforeInstr->m_func);
4506-
bailoutInstr->SetSrc1(opndFuncInfo);
4507-
bailoutInstr->SetSrc2(inlinedFuncInfo);
4508-
4509-
insertBeforeInstr->InsertBefore(bailoutInstr);
4510-
}
4511-
4512-
void
4513-
Inline::InsertFunctionObjectCheck(IR::RegOpnd * funcOpnd, IR::Instr *insertBeforeInstr, IR::Instr *bailOutInstr, const FunctionJITTimeInfo *funcInfo)
4514-
{
4515-
Js::BuiltinFunction index = Js::JavascriptLibrary::GetBuiltInForFuncInfo(funcInfo->GetLocalFunctionId());
4516-
AssertMsg(index < Js::BuiltinFunction::Count, "Invalid built-in index on a call target marked as built-in");
4517-
4518-
bailOutInstr->SetSrc1(funcOpnd);
4519-
bailOutInstr->SetSrc2(IR::IntConstOpnd::New(index, TyInt32, insertBeforeInstr->m_func));
4520-
insertBeforeInstr->InsertBefore(bailOutInstr);
4465+
// Two bailout checks, an object check followed by a function type ID check, are required. These bailout instructions are created
4466+
// when lowering checkFunctionEntryPoint rather than being created here as checkFunctionEntryPoint can be hoisted outside of a loop.
4467+
IR::Instr *checkIsFuncObj = IR::BailOutInstr::New(Js::OpCode::CheckIsFuncObj, bailOutKind, insertBeforeInstr, callInstr->m_func);
4468+
checkIsFuncObj->SetSrc1(callInstr->GetSrc1()->AsRegOpnd());
4469+
checkIsFuncObj->SetByteCodeOffset(insertBeforeInstr);
4470+
insertBeforeInstr->InsertBefore(checkIsFuncObj);
45214471
}
45224472

45234473
IR::Instr *
45244474
Inline::PrepareInsertionPoint(IR::Instr *callInstr, const FunctionJITTimeInfo *funcInfo, IR::Instr *insertBeforeInstr)
45254475
{
45264476
Assert(insertBeforeInstr);
45274477
Assert(insertBeforeInstr->m_func == callInstr->m_func);
4528-
IR::BailOutKind bailOutKind = IR::BailOutOnInlineFunction;
4529-
4530-
IR::RegOpnd * funcOpnd = callInstr->GetSrc1()->AsRegOpnd();
45314478

4532-
// FunctionBody check is the primary bailout instruction, create it first
4533-
IR::BailOutInstr* primaryBailOutInstr = IR::BailOutInstr::New(Js::OpCode::BailOnNotEqual, bailOutKind, insertBeforeInstr, callInstr->m_func);
4534-
primaryBailOutInstr->SetByteCodeOffset(insertBeforeInstr);
4479+
IR::Instr *checkFuncInfo = IR::BailOutInstr::New(Js::OpCode::CheckFuncInfo, IR::BailOutOnInlineFunction, insertBeforeInstr, callInstr->m_func);
4480+
checkFuncInfo->SetSrc1(callInstr->GetSrc1()->AsRegOpnd());
45354481

4536-
// 1. Bailout if function object is not an object.
4537-
IR::Instr *bailOutIfNotObject = IR::BailOutInstr::New(Js::OpCode::BailOnNotObject,
4538-
bailOutKind,
4539-
primaryBailOutInstr->GetBailOutInfo(),
4540-
callInstr->m_func);
4541-
InsertObjectCheck(funcOpnd, insertBeforeInstr, bailOutIfNotObject);
4542-
4543-
// 2. Bailout if function object is not a TypeId_Function
4544-
IR::Instr* bailOutIfNotJsFunction = IR::BailOutInstr::New(Js::OpCode::BailOnNotEqual, bailOutKind, primaryBailOutInstr->GetBailOutInfo(), callInstr->m_func);
4545-
InsertFunctionTypeIdCheck(funcOpnd, insertBeforeInstr, bailOutIfNotJsFunction);
4482+
IR::AddrOpnd* inlinedFuncInfo = IR::AddrOpnd::New(funcInfo->GetFunctionInfoAddr(), IR::AddrOpndKindDynamicFunctionInfo, insertBeforeInstr->m_func);
4483+
checkFuncInfo->SetSrc2(inlinedFuncInfo);
45464484

4547-
// 3. Bailout if function body doesn't match funcInfo
4548-
InsertFunctionInfoCheck(funcOpnd, insertBeforeInstr, primaryBailOutInstr, funcInfo);
4485+
checkFuncInfo->SetByteCodeOffset(insertBeforeInstr);
4486+
insertBeforeInstr->InsertBefore(checkFuncInfo);
45494487

4550-
return primaryBailOutInstr;
4488+
return checkFuncInfo;
45514489
}
45524490

45534491
IR::ByteCodeUsesInstr*

‎lib/Backend/Inline.h

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -153,10 +153,7 @@ class Inline
153153
void SetInlineeFrameStartSym(Func *inlinee, uint actualCount);
154154
void CloneCallSequence(IR::Instr* callInstr, IR::Instr* clonedCallInstr);
155155

156-
void InsertObjectCheck(IR::RegOpnd * funcOpnd, IR::Instr* insertBeforeInstr, IR::Instr*bailOutInstr);
157-
void InsertFunctionTypeIdCheck(IR::RegOpnd * funcOpnd, IR::Instr* insertBeforeInstr, IR::Instr*bailOutInstr);
158156
void InsertJsFunctionCheck(IR::Instr * callInstr, IR::Instr *insertBeforeInstr, IR::BailOutKind bailOutKind);
159-
void InsertFunctionInfoCheck(IR::RegOpnd * funcOpnd, IR::Instr *insertBeforeInstr, IR::Instr* bailoutInstr, const FunctionJITTimeInfo *funcInfo);
160157
void InsertFunctionObjectCheck(IR::RegOpnd * funcOpnd, IR::Instr *insertBeforeInstr, IR::Instr* bailoutInstr, const FunctionJITTimeInfo *funcInfo);
161158

162159
void TryResetObjTypeSpecFldInfoOn(IR::PropertySymOpnd* propertySymOpnd);

‎lib/Backend/Lower.cpp

Lines changed: 110 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2715,6 +2715,14 @@ Lowerer::LowerRange(IR::Instr *instrStart, IR::Instr *instrEnd, bool defaultDoFa
27152715
instrPrev = this->LowerBailOnNotObject(instr);
27162716
break;
27172717

2718+
case Js::OpCode::CheckIsFuncObj:
2719+
instrPrev = this->LowerCheckIsFuncObj(instr);
2720+
break;
2721+
2722+
case Js::OpCode::CheckFuncInfo:
2723+
instrPrev = this->LowerCheckIsFuncObj(instr, true);
2724+
break;
2725+
27182726
case Js::OpCode::BailOnNotBuiltIn:
27192727
instrPrev = this->LowerBailOnNotBuiltIn(instr);
27202728
break;
@@ -12510,7 +12518,52 @@ Lowerer::LowerBailOnNotObject(IR::Instr *instr,
1251012518
return prevInstr;
1251112519
}
1251212520

12513-
IR::Instr *
12521+
IR::Instr*
12522+
Lowerer::LowerCheckIsFuncObj(IR::Instr *instr, bool checkFuncInfo)
12523+
{
12524+
// The CheckIsFuncObj instr and CheckFuncInfo instr (checkFuncInfo = true) are used to
12525+
// generate bailout instrs that type check a function (and can also check the func info).
12526+
// Rather than creating these bailout instrs in Inline, they are created in Lower because
12527+
// CheckIsFuncObj and CheckFuncInfo instrs can be hoisted outside of loops and thus the
12528+
// bailout instrs created can exist outside of loops.
12529+
12530+
IR::RegOpnd *funcOpnd = instr->GetSrc1()->AsRegOpnd();
12531+
IR::BailOutKind bailOutKind = instr->GetBailOutKind();
12532+
BailOutInfo *bailOutInfo = instr->GetBailOutInfo();
12533+
12534+
// Check that the property is an object.
12535+
InsertObjectCheck(funcOpnd, instr, bailOutKind, bailOutInfo);
12536+
12537+
// Check that the object is a function with the correct type ID.
12538+
IR::Instr *lastInstr = InsertFunctionTypeIdCheck(funcOpnd, instr, bailOutKind, bailOutInfo);
12539+
12540+
if (checkFuncInfo)
12541+
{
12542+
// Check that the function body matches the func info.
12543+
lastInstr = InsertFunctionInfoCheck(
12544+
funcOpnd, instr, instr->GetSrc2()->AsAddrOpnd(), bailOutKind, bailOutInfo);
12545+
lastInstr->SetByteCodeOffset(instr);
12546+
}
12547+
12548+
if (bailOutInfo->bailOutInstr == instr)
12549+
{
12550+
// bailOutInstr is currently instr. By changing bailOutInstr to point to lastInstr, the next
12551+
// instruction to be lowered (lastInstr) will create the bailout target. This is necessary in
12552+
// cases where instr does not have a shared bailout (ex: instr was not hoisted outside of a loop).
12553+
bailOutInfo->bailOutInstr = lastInstr;
12554+
}
12555+
12556+
// the CheckFunctionEntryPoint instr exists in order to create the instrs above. It does not have
12557+
// any other purpose and thus it is removed. The instr's BailOutInfo continues to be used and thus
12558+
// must not be deleted. Flags are turned off to stop Remove() from deleting instr's BailOutInfo.
12559+
instr->hasBailOutInfo = false;
12560+
instr->hasAuxBailOut = false;
12561+
instr->Remove();
12562+
12563+
return lastInstr;
12564+
}
12565+
12566+
IR::Instr*
1251412567
Lowerer::LowerBailOnTrue(IR::Instr* instr, IR::LabelInstr* labelBailOut /*nullptr*/)
1251512568
{
1251612569
IR::Instr* instrPrev = instr->m_prev;
@@ -28592,6 +28645,62 @@ Lowerer::InsertAndLegalize(IR::Instr * instr, IR::Instr* insertBeforeInstr)
2859228645
LowererMD::Legalize(instr);
2859328646
}
2859428647

28648+
IR::Instr*
28649+
Lowerer::InsertObjectCheck(IR::RegOpnd *funcOpnd, IR::Instr *insertBeforeInstr, IR::BailOutKind bailOutKind, BailOutInfo *bailOutInfo)
28650+
{
28651+
IR::Instr *bailOutIfNotObject = IR::BailOutInstr::New(Js::OpCode::BailOnNotObject, bailOutKind, bailOutInfo, bailOutInfo->bailOutFunc);
28652+
28653+
// Bailout when funcOpnd is not an object.
28654+
bailOutIfNotObject->SetSrc1(funcOpnd);
28655+
bailOutIfNotObject->SetByteCodeOffset(insertBeforeInstr);
28656+
insertBeforeInstr->InsertBefore(bailOutIfNotObject);
28657+
28658+
return bailOutIfNotObject;
28659+
}
28660+
28661+
IR::Instr*
28662+
Lowerer::InsertFunctionTypeIdCheck(IR::RegOpnd * funcOpnd, IR::Instr* insertBeforeInstr, IR::BailOutKind bailOutKind, BailOutInfo *bailOutInfo)
28663+
{
28664+
IR::Instr *bailOutIfNotFunction = IR::BailOutInstr::New(Js::OpCode::BailOnNotEqual, bailOutKind, bailOutInfo, bailOutInfo->bailOutFunc);
28665+
28666+
// functionTypeRegOpnd = Ld functionRegOpnd->type
28667+
IR::IndirOpnd *functionTypeIndirOpnd = IR::IndirOpnd::New(funcOpnd, Js::RecyclableObject::GetOffsetOfType(), TyMachPtr, insertBeforeInstr->m_func);
28668+
IR::RegOpnd *functionTypeRegOpnd = IR::RegOpnd::New(TyVar, insertBeforeInstr->m_func->GetTopFunc());
28669+
IR::Instr *instr = IR::Instr::New(Js::OpCode::Ld_A, functionTypeRegOpnd, functionTypeIndirOpnd, insertBeforeInstr->m_func);
28670+
if (instr->m_func->HasByteCodeOffset())
28671+
{
28672+
instr->SetByteCodeOffset(insertBeforeInstr);
28673+
}
28674+
insertBeforeInstr->InsertBefore(instr);
28675+
28676+
CompileAssert(sizeof(Js::TypeId) == sizeof(int32));
28677+
// if (functionTypeRegOpnd->typeId != TypeIds_Function) goto $noInlineLabel
28678+
// BrNeq_I4 $noInlineLabel, functionTypeRegOpnd->typeId, TypeIds_Function
28679+
IR::IndirOpnd *functionTypeIdIndirOpnd = IR::IndirOpnd::New(functionTypeRegOpnd, Js::Type::GetOffsetOfTypeId(), TyInt32, insertBeforeInstr->m_func);
28680+
IR::IntConstOpnd *typeIdFunctionConstOpnd = IR::IntConstOpnd::New(Js::TypeIds_Function, TyInt32, insertBeforeInstr->m_func);
28681+
bailOutIfNotFunction->SetSrc1(functionTypeIdIndirOpnd);
28682+
bailOutIfNotFunction->SetSrc2(typeIdFunctionConstOpnd);
28683+
insertBeforeInstr->InsertBefore(bailOutIfNotFunction);
28684+
28685+
return bailOutIfNotFunction;
28686+
}
28687+
28688+
IR::Instr*
28689+
Lowerer::InsertFunctionInfoCheck(IR::RegOpnd * funcOpnd, IR::Instr *insertBeforeInstr, IR::AddrOpnd* inlinedFuncInfo, IR::BailOutKind bailOutKind, BailOutInfo *bailOutInfo)
28690+
{
28691+
IR::Instr *bailOutIfWrongFuncInfo = IR::BailOutInstr::New(Js::OpCode::BailOnNotEqual, bailOutKind, bailOutInfo, bailOutInfo->bailOutFunc);
28692+
28693+
// if (VarTo<JavascriptFunction>(r1)->functionInfo != funcInfo) goto noInlineLabel
28694+
// BrNeq_A noInlineLabel, r1->functionInfo, funcInfo
28695+
IR::IndirOpnd* opndFuncInfo = IR::IndirOpnd::New(funcOpnd, Js::JavascriptFunction::GetOffsetOfFunctionInfo(), TyMachPtr, insertBeforeInstr->m_func);
28696+
bailOutIfWrongFuncInfo->SetSrc1(opndFuncInfo);
28697+
bailOutIfWrongFuncInfo->SetSrc2(inlinedFuncInfo);
28698+
28699+
insertBeforeInstr->InsertBefore(bailOutIfWrongFuncInfo);
28700+
28701+
return bailOutIfWrongFuncInfo;
28702+
}
28703+
2859528704
#if DBG
2859628705
void
2859728706
Lowerer::LegalizeVerifyRange(IR::Instr * instrStart, IR::Instr * instrLast)

‎lib/Backend/Lower.h

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -565,6 +565,7 @@ class Lowerer
565565
IR::Instr * LowerBailOnNotPolymorphicInlinee(IR::Instr * instr);
566566
IR::Instr * LowerBailOnNotStackArgs(IR::Instr * instr);
567567
IR::Instr * LowerBailOnNotObject(IR::Instr *instr, IR::BranchInstr *branchInstr = nullptr, IR::LabelInstr *labelBailOut = nullptr);
568+
IR::Instr * LowerCheckIsFuncObj(IR::Instr *instr, bool checkFuncInfo = false);
568569
IR::Instr * LowerBailOnTrue(IR::Instr *instr, IR::LabelInstr *labelBailOut = nullptr);
569570
IR::Instr * LowerBailOnNotBuiltIn(IR::Instr *instr, IR::BranchInstr *branchInstr = nullptr, IR::LabelInstr *labelBailOut = nullptr);
570571
IR::Instr * LowerBailOnNotInteger(IR::Instr *instr, IR::BranchInstr *branchInstr = nullptr, IR::LabelInstr *labelBailOut = nullptr);
@@ -799,6 +800,11 @@ class Lowerer
799800

800801
IR::LabelInstr* InsertLoopTopLabel(IR::Instr * insertBeforeInstr);
801802
IR::Instr * AddBailoutToHelperCallInstr(IR::Instr * helperCallInstr, BailOutInfo * bailoutInfo, IR::BailOutKind bailoutKind, IR::Instr * primaryBailoutInstr);
803+
804+
IR::Instr* InsertObjectCheck(IR::RegOpnd *funcOpnd, IR::Instr *insertBeforeInstr, IR::BailOutKind bailOutKind, BailOutInfo *bailOutInfo);
805+
IR::Instr* InsertFunctionTypeIdCheck(IR::RegOpnd *funcOpnd, IR::Instr *insertBeforeInstr, IR::BailOutKind bailOutKind, BailOutInfo *bailOutInfo);
806+
IR::Instr* InsertFunctionInfoCheck(IR::RegOpnd *funcOpnd, IR::Instr *insertBeforeInstr, IR::AddrOpnd *inlinedFuncInfo, IR::BailOutKind bailOutKind, BailOutInfo *bailOutInfo);
807+
802808
public:
803809
static IRType GetImplicitCallFlagsType()
804810
{

‎lib/Runtime/ByteCode/OpCodes.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -771,6 +771,8 @@ MACRO_BACKEND_ONLY( InlineRegExpExec, Empty, OpSideEffect|OpInli
771771

772772
MACRO_BACKEND_ONLY( CallIFixed, Empty, OpSideEffect|OpUseAllFields|OpCallInstr|OpInlineCallInstr)
773773
MACRO_BACKEND_ONLY( CheckFixedFld, Empty, OpFastFldInstr|OpTempObjectSources|OpCanCSE)
774+
MACRO_BACKEND_ONLY( CheckIsFuncObj, Empty, OpCanCSE | OpBailOutRec)
775+
MACRO_BACKEND_ONLY( CheckFuncInfo, Empty, OpCanCSE | OpBailOutRec)
774776
MACRO_BACKEND_ONLY( CheckPropertyGuardAndLoadType, Empty, OpFastFldInstr|OpTempObjectSources|OpDoNotTransfer)
775777
MACRO_BACKEND_ONLY( CheckObjType, Empty, OpFastFldInstr|OpTempObjectSources|OpCanCSE)
776778
MACRO_BACKEND_ONLY( AdjustObjType, Empty, OpSideEffect)

‎test/FixedFields/NonFixedFieldHoist.baseline

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
-489500
2+
TypeError: Function expected
3+
TypeError: Object doesn't support property or method 'foo'

‎test/FixedFields/NonFixedFieldHoist.js

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
//-------------------------------------------------------------------------------------------------------
2+
// Copyright (C) Microsoft. All rights reserved.
3+
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
4+
//-------------------------------------------------------------------------------------------------------
5+
6+
function foo(a,b){ return a + b; }
7+
function bar(a,b){ return a - b; }
8+
9+
var obj = {};
10+
obj.foo = foo;
11+
12+
function test(obj)
13+
{
14+
var count = 0;
15+
16+
for (var i = 0; i < 1000; i++)
17+
{
18+
count += obj.foo(10, i);
19+
}
20+
21+
return count;
22+
}
23+
24+
obj.foo = bar;
25+
WScript.Echo(test(obj));
26+
obj.foo = 10;
27+
try
28+
{
29+
WScript.Echo(test(obj));
30+
}
31+
catch(e)
32+
{
33+
WScript.Echo(e);
34+
}
35+
36+
var obj2 = {};
37+
try
38+
{
39+
WScript.Echo(test(obj2));
40+
}
41+
catch(e)
42+
{
43+
WScript.Echo(e);
44+
}

‎test/FixedFields/rlexe.xml

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,18 @@
11
<?xml version="1.0" encoding="utf-8"?>
22
<regress-exe>
3+
<test>
4+
<default>
5+
<files>NonFixedFieldHoist.js</files>
6+
<baseline>NonFixedFieldHoist.baseline</baseline>
7+
<compile-flags>-maxinterpretcount:1 -bgjit- -off:simplejit</compile-flags>
8+
</default>
9+
</test>
10+
<test>
11+
<default>
12+
<files>NonFixedFieldHoist.js</files>
13+
<baseline>NonFixedFieldHoist.baseline</baseline>
14+
</default>
15+
</test>
316
<test>
417
<default>
518
<files>FixedFieldsOnSingletons.js</files>

0 commit comments

Comments
 (0)