Skip to content

Commit f8fddd6

Browse files
schuayV8 LUCI CQ
schuay
authored and
V8 LUCI CQ
committed
Reland "[osr] Extract extended OSR checks to BaselineOnStackReplacement builtin"
This is a reland of commit a4216b7 Original change's description: > [osr] Extract extended OSR checks to BaselineOnStackReplacement builtin > > .. to reduce Sparkplug code size. > > Bug: v8:12161 > Change-Id: I4029a75dfa37f716c285ce27153c077a0a82a341 > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3576119 > Reviewed-by: Leszek Swirski <leszeks@chromium.org> > Commit-Queue: Jakob Linke <jgruber@chromium.org> > Cr-Commit-Position: refs/heads/main@{#79962} Bug: v8:12161 Change-Id: I69afd0832d7ca447b5481651ef47ebaa8d023ded Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3585943 Auto-Submit: Jakob Linke <jgruber@chromium.org> Reviewed-by: Leszek Swirski <leszeks@chromium.org> Commit-Queue: Leszek Swirski <leszeks@chromium.org> Cr-Commit-Position: refs/heads/main@{#79980}
1 parent 720329f commit f8fddd6

14 files changed

+355
-103
lines changed

‎src/baseline/baseline-compiler.cc

+8-28
Original file line numberDiff line numberDiff line change
@@ -1925,50 +1925,30 @@ void BaselineCompiler::VisitCreateRestParameter() {
19251925
}
19261926

19271927
void BaselineCompiler::VisitJumpLoop() {
1928-
Label osr_not_armed, osr;
1928+
Label osr_not_armed;
19291929
{
1930-
BaselineAssembler::ScratchRegisterScope scope(&basm_);
1931-
Register osr_urgency_and_install_target = scope.AcquireScratch();
1932-
19331930
ASM_CODE_COMMENT_STRING(&masm_, "OSR Check Armed");
1931+
using D = BaselineOnStackReplacementDescriptor;
1932+
Register osr_urgency_and_install_target =
1933+
D::OsrUrgencyAndInstallTargetRegister();
19341934
__ LoadRegister(osr_urgency_and_install_target,
19351935
interpreter::Register::bytecode_array());
19361936
__ LoadWord16FieldZeroExtend(
19371937
osr_urgency_and_install_target, osr_urgency_and_install_target,
19381938
BytecodeArray::kOsrUrgencyAndInstallTargetOffset);
1939-
int loop_depth = iterator().GetImmediateOperand(1);
1939+
const int loop_depth = iterator().GetImmediateOperand(1);
19401940
__ JumpIfImmediate(Condition::kUnsignedLessThanEqual,
19411941
osr_urgency_and_install_target, loop_depth,
19421942
&osr_not_armed, Label::kNear);
19431943

1944-
// TODO(jgruber): Move the extended checks into the
1945-
// BaselineOnStackReplacement builtin.
1946-
1947-
// OSR based on urgency, i.e. is the OSR urgency greater than the current
1948-
// loop depth?
1949-
STATIC_ASSERT(BytecodeArray::OsrUrgencyBits::kShift == 0);
1950-
Register scratch2 = scope.AcquireScratch();
1951-
__ Word32And(scratch2, osr_urgency_and_install_target,
1952-
BytecodeArray::OsrUrgencyBits::kMask);
1953-
__ JumpIfImmediate(Condition::kUnsignedGreaterThan, scratch2, loop_depth,
1954-
&osr, Label::kNear);
1955-
1956-
// OSR based on the install target offset, i.e. does the current bytecode
1957-
// offset match the install target offset?
1958-
static constexpr int kShift = BytecodeArray::OsrInstallTargetBits::kShift;
1959-
static constexpr int kMask = BytecodeArray::OsrInstallTargetBits::kMask;
19601944
const int encoded_current_offset =
19611945
BytecodeArray::OsrInstallTargetFor(
19621946
BytecodeOffset{iterator().current_offset()})
1963-
<< kShift;
1964-
__ Word32And(scratch2, osr_urgency_and_install_target, kMask);
1965-
__ JumpIfImmediate(Condition::kNotEqual, scratch2, encoded_current_offset,
1966-
&osr_not_armed, Label::kNear);
1947+
<< BytecodeArray::OsrInstallTargetBits::kShift;
1948+
CallBuiltin<Builtin::kBaselineOnStackReplacement>(
1949+
loop_depth, encoded_current_offset, osr_urgency_and_install_target);
19671950
}
19681951

1969-
__ Bind(&osr);
1970-
CallBuiltin<Builtin::kBaselineOnStackReplacement>();
1971-
19721952
__ Bind(&osr_not_armed);
19731953
Label* label = &labels_[iterator().GetJumpTargetOffset()]->unlinked;
19741954
int weight = iterator().GetRelativeJumpTargetOffset() -

‎src/builtins/arm/builtins-arm.cc

+52-4
Original file line numberDiff line numberDiff line change
@@ -1816,7 +1816,44 @@ void Generate_OSREntry(MacroAssembler* masm, Register entry_address,
18161816
__ Ret();
18171817
}
18181818

1819-
void OnStackReplacement(MacroAssembler* masm, bool is_interpreter) {
1819+
enum class OsrSourceTier {
1820+
kInterpreter,
1821+
kBaseline,
1822+
};
1823+
1824+
void OnStackReplacement(MacroAssembler* masm, OsrSourceTier source,
1825+
Register current_loop_depth,
1826+
Register encoded_current_bytecode_offset,
1827+
Register osr_urgency_and_install_target) {
1828+
static constexpr Register scratch = r3;
1829+
DCHECK(!AreAliased(scratch, current_loop_depth,
1830+
encoded_current_bytecode_offset,
1831+
osr_urgency_and_install_target));
1832+
// OSR based on urgency, i.e. is the OSR urgency greater than the current
1833+
// loop depth?
1834+
Label try_osr;
1835+
STATIC_ASSERT(BytecodeArray::OsrUrgencyBits::kShift == 0);
1836+
Register urgency = scratch;
1837+
__ and_(urgency, osr_urgency_and_install_target,
1838+
Operand(BytecodeArray::OsrUrgencyBits::kMask));
1839+
__ cmp(urgency, current_loop_depth);
1840+
__ b(hi, &try_osr);
1841+
1842+
// OSR based on the install target offset, i.e. does the current bytecode
1843+
// offset match the install target offset?
1844+
static constexpr int kMask = BytecodeArray::OsrInstallTargetBits::kMask;
1845+
Register install_target = osr_urgency_and_install_target;
1846+
__ and_(install_target, osr_urgency_and_install_target, Operand(kMask));
1847+
__ cmp(install_target, encoded_current_bytecode_offset);
1848+
__ b(eq, &try_osr);
1849+
1850+
// Neither urgency nor the install target triggered, return to the caller.
1851+
// Note: the return value must be nullptr or a valid Code object.
1852+
__ Move(r0, Operand(0));
1853+
__ Ret(0);
1854+
1855+
__ bind(&try_osr);
1856+
18201857
ASM_CODE_COMMENT(masm);
18211858
{
18221859
FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
@@ -1831,7 +1868,7 @@ void OnStackReplacement(MacroAssembler* masm, bool is_interpreter) {
18311868

18321869
__ bind(&skip);
18331870

1834-
if (is_interpreter) {
1871+
if (source == OsrSourceTier::kInterpreter) {
18351872
// Drop the handler frame that is be sitting on top of the actual
18361873
// JavaScript frame. This is the case then OSR is triggered from bytecode.
18371874
__ LeaveFrame(StackFrame::STUB);
@@ -1857,13 +1894,24 @@ void OnStackReplacement(MacroAssembler* masm, bool is_interpreter) {
18571894
} // namespace
18581895

18591896
void Builtins::Generate_InterpreterOnStackReplacement(MacroAssembler* masm) {
1860-
return OnStackReplacement(masm, true);
1897+
using D = InterpreterOnStackReplacementDescriptor;
1898+
STATIC_ASSERT(D::kParameterCount == 3);
1899+
OnStackReplacement(masm, OsrSourceTier::kInterpreter,
1900+
D::CurrentLoopDepthRegister(),
1901+
D::EncodedCurrentBytecodeOffsetRegister(),
1902+
D::OsrUrgencyAndInstallTargetRegister());
18611903
}
18621904

18631905
void Builtins::Generate_BaselineOnStackReplacement(MacroAssembler* masm) {
1906+
using D = BaselineOnStackReplacementDescriptor;
1907+
STATIC_ASSERT(D::kParameterCount == 3);
1908+
18641909
__ ldr(kContextRegister,
18651910
MemOperand(fp, BaselineFrameConstants::kContextOffset));
1866-
return OnStackReplacement(masm, false);
1911+
OnStackReplacement(masm, OsrSourceTier::kBaseline,
1912+
D::CurrentLoopDepthRegister(),
1913+
D::EncodedCurrentBytecodeOffsetRegister(),
1914+
D::OsrUrgencyAndInstallTargetRegister());
18671915
}
18681916

18691917
// static

‎src/builtins/arm64/builtins-arm64.cc

+52-4
Original file line numberDiff line numberDiff line change
@@ -2070,7 +2070,44 @@ void Generate_OSREntry(MacroAssembler* masm, Register entry_address,
20702070
__ Br(x17);
20712071
}
20722072

2073-
void OnStackReplacement(MacroAssembler* masm, bool is_interpreter) {
2073+
enum class OsrSourceTier {
2074+
kInterpreter,
2075+
kBaseline,
2076+
};
2077+
2078+
void OnStackReplacement(MacroAssembler* masm, OsrSourceTier source,
2079+
Register current_loop_depth,
2080+
Register encoded_current_bytecode_offset,
2081+
Register osr_urgency_and_install_target) {
2082+
static constexpr Register scratch = x3;
2083+
DCHECK(!AreAliased(scratch, current_loop_depth,
2084+
encoded_current_bytecode_offset,
2085+
osr_urgency_and_install_target));
2086+
// OSR based on urgency, i.e. is the OSR urgency greater than the current
2087+
// loop depth?
2088+
Label try_osr;
2089+
STATIC_ASSERT(BytecodeArray::OsrUrgencyBits::kShift == 0);
2090+
Register urgency = scratch;
2091+
__ And(urgency, osr_urgency_and_install_target,
2092+
BytecodeArray::OsrUrgencyBits::kMask);
2093+
__ Cmp(urgency, current_loop_depth);
2094+
__ B(hi, &try_osr);
2095+
2096+
// OSR based on the install target offset, i.e. does the current bytecode
2097+
// offset match the install target offset?
2098+
static constexpr int kMask = BytecodeArray::OsrInstallTargetBits::kMask;
2099+
Register install_target = osr_urgency_and_install_target;
2100+
__ And(install_target, osr_urgency_and_install_target, Operand(kMask));
2101+
__ Cmp(install_target, encoded_current_bytecode_offset);
2102+
__ B(eq, &try_osr);
2103+
2104+
// Neither urgency nor the install target triggered, return to the caller.
2105+
// Note: the return value must be nullptr or a valid Code object.
2106+
__ Move(x0, xzr);
2107+
__ Ret();
2108+
2109+
__ bind(&try_osr);
2110+
20742111
ASM_CODE_COMMENT(masm);
20752112
{
20762113
FrameScope scope(masm, StackFrame::INTERNAL);
@@ -2084,7 +2121,7 @@ void OnStackReplacement(MacroAssembler* masm, bool is_interpreter) {
20842121

20852122
__ Bind(&skip);
20862123

2087-
if (is_interpreter) {
2124+
if (source == OsrSourceTier::kInterpreter) {
20882125
// Drop the handler frame that is be sitting on top of the actual
20892126
// JavaScript frame. This is the case then OSR is triggered from bytecode.
20902127
__ LeaveFrame(StackFrame::STUB);
@@ -2115,13 +2152,24 @@ void OnStackReplacement(MacroAssembler* masm, bool is_interpreter) {
21152152
} // namespace
21162153

21172154
void Builtins::Generate_InterpreterOnStackReplacement(MacroAssembler* masm) {
2118-
return OnStackReplacement(masm, true);
2155+
using D = InterpreterOnStackReplacementDescriptor;
2156+
STATIC_ASSERT(D::kParameterCount == 3);
2157+
OnStackReplacement(masm, OsrSourceTier::kInterpreter,
2158+
D::CurrentLoopDepthRegister(),
2159+
D::EncodedCurrentBytecodeOffsetRegister(),
2160+
D::OsrUrgencyAndInstallTargetRegister());
21192161
}
21202162

21212163
void Builtins::Generate_BaselineOnStackReplacement(MacroAssembler* masm) {
2164+
using D = BaselineOnStackReplacementDescriptor;
2165+
STATIC_ASSERT(D::kParameterCount == 3);
2166+
21222167
__ ldr(kContextRegister,
21232168
MemOperand(fp, BaselineFrameConstants::kContextOffset));
2124-
return OnStackReplacement(masm, false);
2169+
OnStackReplacement(masm, OsrSourceTier::kBaseline,
2170+
D::CurrentLoopDepthRegister(),
2171+
D::EncodedCurrentBytecodeOffsetRegister(),
2172+
D::OsrUrgencyAndInstallTargetRegister());
21252173
}
21262174

21272175
// static

‎src/builtins/builtins-definitions.h

+2-2
Original file line numberDiff line numberDiff line change
@@ -189,11 +189,11 @@ namespace internal {
189189
InterpreterPushArgsThenConstruct) \
190190
ASM(InterpreterEnterAtBytecode, Dummy) \
191191
ASM(InterpreterEnterAtNextBytecode, Dummy) \
192-
ASM(InterpreterOnStackReplacement, ContextOnly) \
192+
ASM(InterpreterOnStackReplacement, InterpreterOnStackReplacement) \
193193
\
194194
/* Baseline Compiler */ \
195195
ASM(BaselineOutOfLinePrologue, BaselineOutOfLinePrologue) \
196-
ASM(BaselineOnStackReplacement, Void) \
196+
ASM(BaselineOnStackReplacement, BaselineOnStackReplacement) \
197197
ASM(BaselineLeaveFrame, BaselineLeaveFrame) \
198198
ASM(BaselineOrInterpreterEnterAtBytecode, Void) \
199199
ASM(BaselineOrInterpreterEnterAtNextBytecode, Void) \

‎src/builtins/ia32/builtins-ia32.cc

+52-4
Original file line numberDiff line numberDiff line change
@@ -2801,7 +2801,44 @@ void Generate_OSREntry(MacroAssembler* masm, Register entry_address) {
28012801
__ ret(0);
28022802
}
28032803

2804-
void OnStackReplacement(MacroAssembler* masm, bool is_interpreter) {
2804+
enum class OsrSourceTier {
2805+
kInterpreter,
2806+
kBaseline,
2807+
};
2808+
2809+
void OnStackReplacement(MacroAssembler* masm, OsrSourceTier source,
2810+
Register current_loop_depth,
2811+
Register encoded_current_bytecode_offset,
2812+
Register osr_urgency_and_install_target) {
2813+
static constexpr Register scratch = edi;
2814+
DCHECK(!AreAliased(scratch, current_loop_depth,
2815+
encoded_current_bytecode_offset,
2816+
osr_urgency_and_install_target));
2817+
// OSR based on urgency, i.e. is the OSR urgency greater than the current
2818+
// loop depth?
2819+
Label try_osr;
2820+
STATIC_ASSERT(BytecodeArray::OsrUrgencyBits::kShift == 0);
2821+
Register urgency = scratch;
2822+
__ Move(urgency, osr_urgency_and_install_target);
2823+
__ and_(urgency, Immediate(BytecodeArray::OsrUrgencyBits::kMask));
2824+
__ cmp(urgency, current_loop_depth);
2825+
__ j(above, &try_osr, Label::kNear);
2826+
2827+
// OSR based on the install target offset, i.e. does the current bytecode
2828+
// offset match the install target offset?
2829+
static constexpr int kMask = BytecodeArray::OsrInstallTargetBits::kMask;
2830+
Register install_target = osr_urgency_and_install_target;
2831+
__ and_(install_target, Immediate(kMask));
2832+
__ cmp(install_target, encoded_current_bytecode_offset);
2833+
__ j(equal, &try_osr, Label::kNear);
2834+
2835+
// Neither urgency nor the install target triggered, return to the caller.
2836+
// Note: the return value must be nullptr or a valid Code object.
2837+
__ Move(eax, Immediate(0));
2838+
__ ret(0);
2839+
2840+
__ bind(&try_osr);
2841+
28052842
ASM_CODE_COMMENT(masm);
28062843
{
28072844
FrameScope scope(masm, StackFrame::INTERNAL);
@@ -2816,7 +2853,7 @@ void OnStackReplacement(MacroAssembler* masm, bool is_interpreter) {
28162853

28172854
__ bind(&skip);
28182855

2819-
if (is_interpreter) {
2856+
if (source == OsrSourceTier::kInterpreter) {
28202857
// Drop the handler frame that is be sitting on top of the actual
28212858
// JavaScript frame. This is the case then OSR is triggered from bytecode.
28222859
__ leave();
@@ -2841,13 +2878,24 @@ void OnStackReplacement(MacroAssembler* masm, bool is_interpreter) {
28412878
} // namespace
28422879

28432880
void Builtins::Generate_InterpreterOnStackReplacement(MacroAssembler* masm) {
2844-
return OnStackReplacement(masm, true);
2881+
using D = InterpreterOnStackReplacementDescriptor;
2882+
STATIC_ASSERT(D::kParameterCount == 3);
2883+
OnStackReplacement(masm, OsrSourceTier::kInterpreter,
2884+
D::CurrentLoopDepthRegister(),
2885+
D::EncodedCurrentBytecodeOffsetRegister(),
2886+
D::OsrUrgencyAndInstallTargetRegister());
28452887
}
28462888

28472889
void Builtins::Generate_BaselineOnStackReplacement(MacroAssembler* masm) {
2890+
using D = BaselineOnStackReplacementDescriptor;
2891+
STATIC_ASSERT(D::kParameterCount == 3);
2892+
28482893
__ mov(kContextRegister,
28492894
MemOperand(ebp, BaselineFrameConstants::kContextOffset));
2850-
return OnStackReplacement(masm, false);
2895+
OnStackReplacement(masm, OsrSourceTier::kBaseline,
2896+
D::CurrentLoopDepthRegister(),
2897+
D::EncodedCurrentBytecodeOffsetRegister(),
2898+
D::OsrUrgencyAndInstallTargetRegister());
28512899
}
28522900

28532901
#if V8_ENABLE_WEBASSEMBLY

‎src/builtins/x64/builtins-x64.cc

+45-3
Original file line numberDiff line numberDiff line change
@@ -2729,7 +2729,38 @@ enum class OsrSourceTier {
27292729
kBaseline,
27302730
};
27312731

2732-
void OnStackReplacement(MacroAssembler* masm, OsrSourceTier source) {
2732+
void OnStackReplacement(MacroAssembler* masm, OsrSourceTier source,
2733+
Register current_loop_depth,
2734+
Register encoded_current_bytecode_offset,
2735+
Register osr_urgency_and_install_target) {
2736+
DCHECK(!AreAliased(kScratchRegister, current_loop_depth,
2737+
encoded_current_bytecode_offset,
2738+
osr_urgency_and_install_target));
2739+
// OSR based on urgency, i.e. is the OSR urgency greater than the current
2740+
// loop depth?
2741+
Label try_osr;
2742+
STATIC_ASSERT(BytecodeArray::OsrUrgencyBits::kShift == 0);
2743+
Register urgency = kScratchRegister;
2744+
__ Move(urgency, osr_urgency_and_install_target);
2745+
__ andq(urgency, Immediate(BytecodeArray::OsrUrgencyBits::kMask));
2746+
__ cmpq(urgency, current_loop_depth);
2747+
__ j(above, &try_osr, Label::kNear);
2748+
2749+
// OSR based on the install target offset, i.e. does the current bytecode
2750+
// offset match the install target offset?
2751+
static constexpr int kMask = BytecodeArray::OsrInstallTargetBits::kMask;
2752+
Register install_target = osr_urgency_and_install_target;
2753+
__ andq(install_target, Immediate(kMask));
2754+
__ cmpq(install_target, encoded_current_bytecode_offset);
2755+
__ j(equal, &try_osr, Label::kNear);
2756+
2757+
// Neither urgency nor the install target triggered, return to the caller.
2758+
// Note: the return value must be nullptr or a valid Code object.
2759+
__ Move(rax, Immediate(0));
2760+
__ ret(0);
2761+
2762+
__ bind(&try_osr);
2763+
27332764
{
27342765
FrameScope scope(masm, StackFrame::INTERNAL);
27352766
__ CallRuntime(Runtime::kCompileOptimizedOSR);
@@ -2771,13 +2802,24 @@ void OnStackReplacement(MacroAssembler* masm, OsrSourceTier source) {
27712802
} // namespace
27722803

27732804
void Builtins::Generate_InterpreterOnStackReplacement(MacroAssembler* masm) {
2774-
OnStackReplacement(masm, OsrSourceTier::kInterpreter);
2805+
using D = InterpreterOnStackReplacementDescriptor;
2806+
STATIC_ASSERT(D::kParameterCount == 3);
2807+
OnStackReplacement(masm, OsrSourceTier::kInterpreter,
2808+
D::CurrentLoopDepthRegister(),
2809+
D::EncodedCurrentBytecodeOffsetRegister(),
2810+
D::OsrUrgencyAndInstallTargetRegister());
27752811
}
27762812

27772813
void Builtins::Generate_BaselineOnStackReplacement(MacroAssembler* masm) {
2814+
using D = BaselineOnStackReplacementDescriptor;
2815+
STATIC_ASSERT(D::kParameterCount == 3);
2816+
27782817
__ movq(kContextRegister,
27792818
MemOperand(rbp, BaselineFrameConstants::kContextOffset));
2780-
OnStackReplacement(masm, OsrSourceTier::kBaseline);
2819+
OnStackReplacement(masm, OsrSourceTier::kBaseline,
2820+
D::CurrentLoopDepthRegister(),
2821+
D::EncodedCurrentBytecodeOffsetRegister(),
2822+
D::OsrUrgencyAndInstallTargetRegister());
27812823
}
27822824

27832825
#if V8_ENABLE_WEBASSEMBLY

0 commit comments

Comments
 (0)