Skip to content

Commit c51bcd1

Browse files
rmcilroyCommit Bot
rmcilroy
authored and
Commit Bot
committed
[sfi] Remove DebugInfo field in SharedFunctionInfo.
Merges DebugInfo field into the function_identifier field, storing the function identifier in the DebugInfo. Also moves some debugging_hints bits to the SFI flags, and others to the DebugInfo. Finally, changes the logic to store debugger patched bytecode array on the SFI instead of the DebugInfo, simplifying the logic in the InterpreterEntryTrampoline. BUG=chromium:818642,chromium:783853 [email protected] Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng Change-Id: If440080c0f08fac4fb96f5e18dcc0eb9b86d4821 Reviewed-on: https://chromium-review.googlesource.com/1115819 Commit-Queue: Ross McIlroy <[email protected]> Reviewed-by: Jakob Gruber <[email protected]> Reviewed-by: Leszek Swirski <[email protected]> Cr-Commit-Position: refs/heads/master@{#54081}
1 parent edef59c commit c51bcd1

30 files changed

+397
-572
lines changed

‎src/api.cc‎

Lines changed: 8 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -9595,7 +9595,9 @@ void debug::ResetBlackboxedStateCache(Isolate* v8_isolate,
95959595
i::SharedFunctionInfo::ScriptIterator iter(isolate,
95969596
*Utils::OpenHandle(*script));
95979597
while (i::SharedFunctionInfo* info = iter.Next()) {
9598-
info->set_computed_debug_is_blackboxed(false);
9598+
if (info->HasDebugInfo()) {
9599+
info->GetDebugInfo()->set_computed_debug_is_blackboxed(false);
9600+
}
95999601
}
96009602
}
96019603

@@ -9841,16 +9843,11 @@ int64_t debug::GetNextRandomInt64(v8::Isolate* v8_isolate) {
98419843
}
98429844

98439845
int debug::GetDebuggingId(v8::Local<v8::Function> function) {
9844-
i::JSReceiver* callable = *v8::Utils::OpenHandle(*function);
9845-
if (!callable->IsJSFunction()) return i::SharedFunctionInfo::kNoDebuggingId;
9846-
i::JSFunction* fun = i::JSFunction::cast(callable);
9847-
i::SharedFunctionInfo* shared = fun->shared();
9848-
int id = shared->debugging_id();
9849-
if (id == i::SharedFunctionInfo::kNoDebuggingId) {
9850-
id = callable->GetHeap()->NextDebuggingId();
9851-
shared->set_debugging_id(id);
9852-
}
9853-
DCHECK_NE(i::SharedFunctionInfo::kNoDebuggingId, id);
9846+
i::Handle<i::JSReceiver> callable = v8::Utils::OpenHandle(*function);
9847+
if (!callable->IsJSFunction()) return i::DebugInfo::kNoDebuggingId;
9848+
i::Handle<i::JSFunction> func = i::Handle<i::JSFunction>::cast(callable);
9849+
int id = func->GetIsolate()->debug()->GetFunctionDebuggingId(func);
9850+
DCHECK_NE(i::DebugInfo::kNoDebuggingId, id);
98549851
return id;
98559852
}
98569853

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

Lines changed: 2 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -829,17 +829,12 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
829829
FrameScope frame_scope(masm, StackFrame::MANUAL);
830830
__ PushStandardFrame(closure);
831831

832-
// Get the bytecode array from the function object (or from the DebugInfo if
833-
// it is present) and load it into kInterpreterBytecodeArrayRegister.
834-
Label maybe_load_debug_bytecode_array, bytecode_array_loaded;
832+
// Get the bytecode array from the function object and load it into
833+
// kInterpreterBytecodeArrayRegister.
835834
__ ldr(r0, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
836835
__ ldr(kInterpreterBytecodeArrayRegister,
837836
FieldMemOperand(r0, SharedFunctionInfo::kFunctionDataOffset));
838837
GetSharedFunctionInfoBytecode(masm, kInterpreterBytecodeArrayRegister, r4);
839-
__ ldr(r4, FieldMemOperand(r0, SharedFunctionInfo::kDebugInfoOffset));
840-
__ SmiTst(r4);
841-
__ b(ne, &maybe_load_debug_bytecode_array);
842-
__ bind(&bytecode_array_loaded);
843838

844839
// Increment invocation count for the function.
845840
__ ldr(r9, FieldMemOperand(feedback_vector,
@@ -950,37 +945,6 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
950945
// The return value is in r0.
951946
LeaveInterpreterFrame(masm, r2);
952947
__ Jump(lr);
953-
954-
// Load debug copy of the bytecode array if it exists.
955-
// kInterpreterBytecodeArrayRegister is already loaded with
956-
// SharedFunctionInfo::kFunctionDataOffset.
957-
__ bind(&maybe_load_debug_bytecode_array);
958-
__ ldr(r9, FieldMemOperand(r4, DebugInfo::kDebugBytecodeArrayOffset), ne);
959-
__ JumpIfRoot(r9, Heap::kUndefinedValueRootIndex, &bytecode_array_loaded);
960-
961-
__ mov(kInterpreterBytecodeArrayRegister, r9);
962-
__ ldr(r9, FieldMemOperand(r4, DebugInfo::kFlagsOffset));
963-
__ SmiUntag(r9);
964-
__ And(r9, r9, Operand(DebugInfo::kDebugExecutionMode));
965-
966-
ExternalReference debug_execution_mode =
967-
ExternalReference::debug_execution_mode_address(masm->isolate());
968-
__ mov(r4, Operand(debug_execution_mode));
969-
__ ldrsb(r4, MemOperand(r4));
970-
STATIC_ASSERT(static_cast<int>(DebugInfo::kDebugExecutionMode) ==
971-
static_cast<int>(DebugInfo::kSideEffects));
972-
__ cmp(r4, r9);
973-
__ b(eq, &bytecode_array_loaded);
974-
975-
__ push(closure);
976-
__ push(feedback_vector);
977-
__ push(kInterpreterBytecodeArrayRegister);
978-
__ push(closure);
979-
__ CallRuntime(Runtime::kDebugApplyInstrumentation);
980-
__ pop(kInterpreterBytecodeArrayRegister);
981-
__ pop(feedback_vector);
982-
__ pop(closure);
983-
__ b(&bytecode_array_loaded);
984948
}
985949

986950
static void Generate_InterpreterPushArgs(MacroAssembler* masm,

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

Lines changed: 3 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -901,10 +901,9 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
901901
__ Push(lr, fp, cp, closure);
902902
__ Add(fp, sp, StandardFrameConstants::kFixedFrameSizeFromFp);
903903

904-
// Get the bytecode array from the function object (or from the DebugInfo if
905-
// it is present) and load it into kInterpreterBytecodeArrayRegister.
906-
Label maybe_load_debug_bytecode_array, bytecode_array_loaded,
907-
has_bytecode_array;
904+
// Get the bytecode array from the function object and load it into
905+
// kInterpreterBytecodeArrayRegister.
906+
Label has_bytecode_array;
908907
__ Ldr(x0, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
909908
__ Ldr(kInterpreterBytecodeArrayRegister,
910909
FieldMemOperand(x0, SharedFunctionInfo::kFunctionDataOffset));
@@ -915,9 +914,6 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
915914
FieldMemOperand(kInterpreterBytecodeArrayRegister,
916915
InterpreterData::kBytecodeArrayOffset));
917916
__ Bind(&has_bytecode_array);
918-
__ Ldr(x11, FieldMemOperand(x0, SharedFunctionInfo::kDebugInfoOffset));
919-
__ JumpIfNotSmi(x11, &maybe_load_debug_bytecode_array);
920-
__ Bind(&bytecode_array_loaded);
921917

922918
// Increment invocation count for the function.
923919
__ Ldr(x11, FieldMemOperand(closure, JSFunction::kFeedbackCellOffset));
@@ -1030,31 +1026,6 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
10301026
// The return value is in x0.
10311027
LeaveInterpreterFrame(masm, x2);
10321028
__ Ret();
1033-
1034-
// Load debug copy of the bytecode array if it exists.
1035-
// kInterpreterBytecodeArrayRegister is already loaded with
1036-
// SharedFunctionInfo::kFunctionDataOffset.
1037-
__ Bind(&maybe_load_debug_bytecode_array);
1038-
__ Ldr(x10, FieldMemOperand(x11, DebugInfo::kDebugBytecodeArrayOffset));
1039-
__ JumpIfRoot(x10, Heap::kUndefinedValueRootIndex, &bytecode_array_loaded);
1040-
1041-
__ Mov(kInterpreterBytecodeArrayRegister, x10);
1042-
__ SmiUntag(x10, FieldMemOperand(x11, DebugInfo::kFlagsOffset));
1043-
__ And(x10, x10, Immediate(DebugInfo::kDebugExecutionMode));
1044-
1045-
STATIC_ASSERT(static_cast<int>(DebugInfo::kDebugExecutionMode) ==
1046-
static_cast<int>(DebugInfo::kSideEffects));
1047-
ExternalReference debug_execution_mode =
1048-
ExternalReference::debug_execution_mode_address(masm->isolate());
1049-
__ Mov(x11, Operand(debug_execution_mode));
1050-
__ Ldrsb(x11, MemOperand(x11));
1051-
__ CompareAndBranch(x10, x11, eq, &bytecode_array_loaded);
1052-
1053-
__ Push(closure, feedback_vector);
1054-
__ PushArgument(closure);
1055-
__ CallRuntime(Runtime::kDebugApplyInstrumentation);
1056-
__ Pop(feedback_vector, closure);
1057-
__ jmp(&bytecode_array_loaded);
10581029
}
10591030

10601031
static void Generate_InterpreterPushArgs(MacroAssembler* masm,

‎src/builtins/builtins-internal-gen.cc‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -185,9 +185,12 @@ TF_BUILTIN(DebugBreakTrampoline, CodeStubAssembler) {
185185
// Check break-at-entry flag on the debug info.
186186
TNode<SharedFunctionInfo> shared =
187187
CAST(LoadObjectField(function, JSFunction::kSharedFunctionInfoOffset));
188-
TNode<Object> maybe_debug_info =
189-
LoadObjectField(shared, SharedFunctionInfo::kDebugInfoOffset);
190-
GotoIf(TaggedIsSmi(maybe_debug_info), &tailcall_to_shared);
188+
TNode<Object> maybe_heap_object_or_smi = LoadObjectField(
189+
shared, SharedFunctionInfo::kFunctionIdentifierOrDebugInfoOffset);
190+
TNode<HeapObject> maybe_debug_info =
191+
TaggedToHeapObject(maybe_heap_object_or_smi, &tailcall_to_shared);
192+
GotoIfNot(HasInstanceType(maybe_debug_info, InstanceType::DEBUG_INFO_TYPE),
193+
&tailcall_to_shared);
191194

192195
{
193196
TNode<DebugInfo> debug_info = CAST(maybe_debug_info);

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

Lines changed: 2 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -800,19 +800,14 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
800800
__ push(esi); // Callee's context.
801801
__ push(edi); // Callee's JS function.
802802

803-
// Get the bytecode array from the function object (or from the DebugInfo if
804-
// it is present) and load it into kInterpreterBytecodeArrayRegister.
805-
Label maybe_load_debug_bytecode_array, bytecode_array_loaded,
806-
apply_instrumentation;
803+
// Get the bytecode array from the function object and load it into
804+
// kInterpreterBytecodeArrayRegister.
807805
__ mov(eax, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
808806
__ mov(kInterpreterBytecodeArrayRegister,
809807
FieldOperand(eax, SharedFunctionInfo::kFunctionDataOffset));
810808
__ Push(eax);
811809
GetSharedFunctionInfoBytecode(masm, kInterpreterBytecodeArrayRegister, eax);
812810
__ Pop(eax);
813-
__ JumpIfNotSmi(FieldOperand(eax, SharedFunctionInfo::kDebugInfoOffset),
814-
&maybe_load_debug_bytecode_array);
815-
__ bind(&bytecode_array_loaded);
816811

817812
__ inc(FieldOperand(feedback_vector, FeedbackVector::kInvocationCountOffset));
818813

@@ -921,35 +916,6 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
921916
// The return value is in eax.
922917
LeaveInterpreterFrame(masm, ebx, ecx);
923918
__ ret(0);
924-
925-
// Load debug copy of the bytecode array if it exists.
926-
// kInterpreterBytecodeArrayRegister is already loaded with
927-
// SharedFunctionInfo::kFunctionDataOffset.
928-
__ bind(&maybe_load_debug_bytecode_array);
929-
__ mov(eax, FieldOperand(eax, SharedFunctionInfo::kDebugInfoOffset));
930-
__ mov(ecx, FieldOperand(eax, DebugInfo::kDebugBytecodeArrayOffset));
931-
__ JumpIfRoot(ecx, Heap::kUndefinedValueRootIndex, &bytecode_array_loaded);
932-
933-
__ mov(kInterpreterBytecodeArrayRegister, ecx);
934-
__ mov(ecx, FieldOperand(eax, DebugInfo::kFlagsOffset));
935-
__ SmiUntag(ecx);
936-
__ and_(ecx, Immediate(DebugInfo::kDebugExecutionMode));
937-
STATIC_ASSERT(static_cast<int>(DebugInfo::kDebugExecutionMode) ==
938-
static_cast<int>(DebugInfo::kSideEffects));
939-
ExternalReference debug_execution_mode =
940-
ExternalReference::debug_execution_mode_address(masm->isolate());
941-
__ cmp(ecx, Operand::StaticVariable(debug_execution_mode));
942-
__ j(equal, &bytecode_array_loaded);
943-
944-
__ pop(ecx); // get JSFunction from stack
945-
__ push(ecx);
946-
__ push(ebx); // preserve feedback_vector and bytecode array register
947-
__ push(kInterpreterBytecodeArrayRegister);
948-
__ push(ecx); // pass function as argument
949-
__ CallRuntime(Runtime::kDebugApplyInstrumentation);
950-
__ pop(kInterpreterBytecodeArrayRegister);
951-
__ pop(ebx);
952-
__ jmp(&bytecode_array_loaded);
953919
}
954920

955921

‎src/builtins/mips/builtins-mips.cc‎

Lines changed: 2 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -804,16 +804,12 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
804804
FrameScope frame_scope(masm, StackFrame::MANUAL);
805805
__ PushStandardFrame(closure);
806806

807-
// Get the bytecode array from the function object (or from the DebugInfo if
808-
// it is present) and load it into kInterpreterBytecodeArrayRegister.
809-
Label maybe_load_debug_bytecode_array, bytecode_array_loaded;
807+
// Get the bytecode array from the function object and load it into
808+
// kInterpreterBytecodeArrayRegister.
810809
__ lw(a0, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
811810
__ lw(kInterpreterBytecodeArrayRegister,
812811
FieldMemOperand(a0, SharedFunctionInfo::kFunctionDataOffset));
813812
GetSharedFunctionInfoBytecode(masm, kInterpreterBytecodeArrayRegister, t0);
814-
__ lw(t0, FieldMemOperand(a0, SharedFunctionInfo::kDebugInfoOffset));
815-
__ JumpIfNotSmi(t0, &maybe_load_debug_bytecode_array);
816-
__ bind(&bytecode_array_loaded);
817813

818814
// Increment invocation count for the function.
819815
__ lw(t0, FieldMemOperand(feedback_vector,
@@ -927,36 +923,6 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
927923
// The return value is in v0.
928924
LeaveInterpreterFrame(masm, t0);
929925
__ Jump(ra);
930-
931-
// Load debug copy of the bytecode array if it exists.
932-
// kInterpreterBytecodeArrayRegister is already loaded with
933-
// SharedFunctionInfo::kFunctionDataOffset.
934-
__ bind(&maybe_load_debug_bytecode_array);
935-
__ lw(t1, FieldMemOperand(t0, DebugInfo::kDebugBytecodeArrayOffset));
936-
__ JumpIfRoot(t1, Heap::kUndefinedValueRootIndex, &bytecode_array_loaded);
937-
938-
__ mov(kInterpreterBytecodeArrayRegister, t1);
939-
__ lw(t1, FieldMemOperand(t0, DebugInfo::kFlagsOffset));
940-
__ SmiUntag(t1);
941-
__ And(t1, t1, Operand(DebugInfo::kDebugExecutionMode));
942-
943-
ExternalReference debug_execution_mode =
944-
ExternalReference::debug_execution_mode_address(masm->isolate());
945-
__ li(t0, Operand(debug_execution_mode));
946-
__ lb(t0, MemOperand(t0, kLeastSignificantByteInInt32Offset));
947-
STATIC_ASSERT(static_cast<int>(DebugInfo::kDebugExecutionMode) ==
948-
static_cast<int>(DebugInfo::kSideEffects));
949-
__ Branch(&bytecode_array_loaded, eq, t0, Operand(t1));
950-
951-
__ push(closure);
952-
__ push(feedback_vector);
953-
__ push(kInterpreterBytecodeArrayRegister);
954-
__ push(closure);
955-
__ CallRuntime(Runtime::kDebugApplyInstrumentation);
956-
__ pop(kInterpreterBytecodeArrayRegister);
957-
__ pop(feedback_vector);
958-
__ pop(closure);
959-
__ Branch(&bytecode_array_loaded);
960926
}
961927

962928

‎src/builtins/mips64/builtins-mips64.cc‎

Lines changed: 2 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -803,16 +803,12 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
803803
FrameScope frame_scope(masm, StackFrame::MANUAL);
804804
__ PushStandardFrame(closure);
805805

806-
// Get the bytecode array from the function object (or from the DebugInfo if
807-
// it is present) and load it into kInterpreterBytecodeArrayRegister.
808-
Label maybe_load_debug_bytecode_array, bytecode_array_loaded;
806+
// Get the bytecode array from the function object and load it into
807+
// kInterpreterBytecodeArrayRegister.
809808
__ Ld(a0, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
810809
__ Ld(kInterpreterBytecodeArrayRegister,
811810
FieldMemOperand(a0, SharedFunctionInfo::kFunctionDataOffset));
812811
GetSharedFunctionInfoBytecode(masm, kInterpreterBytecodeArrayRegister, a4);
813-
__ Ld(a4, FieldMemOperand(a0, SharedFunctionInfo::kDebugInfoOffset));
814-
__ JumpIfNotSmi(a4, &maybe_load_debug_bytecode_array);
815-
__ bind(&bytecode_array_loaded);
816812

817813
// Increment invocation count for the function.
818814
__ Lw(a4, FieldMemOperand(feedback_vector,
@@ -927,36 +923,6 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
927923
// The return value is in v0.
928924
LeaveInterpreterFrame(masm, t0);
929925
__ Jump(ra);
930-
931-
// Load debug copy of the bytecode array if it exists.
932-
// kInterpreterBytecodeArrayRegister is already loaded with
933-
// SharedFunctionInfo::kFunctionDataOffset.
934-
__ bind(&maybe_load_debug_bytecode_array);
935-
__ Ld(a5, FieldMemOperand(a4, DebugInfo::kDebugBytecodeArrayOffset));
936-
__ JumpIfRoot(a5, Heap::kUndefinedValueRootIndex, &bytecode_array_loaded);
937-
938-
__ mov(kInterpreterBytecodeArrayRegister, a5);
939-
__ Ld(a5, FieldMemOperand(a4, DebugInfo::kFlagsOffset));
940-
__ SmiUntag(a5);
941-
__ And(a5, a5, Operand(DebugInfo::kDebugExecutionMode));
942-
943-
ExternalReference debug_execution_mode =
944-
ExternalReference::debug_execution_mode_address(masm->isolate());
945-
__ li(a4, Operand(debug_execution_mode));
946-
__ Lb(a4, MemOperand(a4, kLeastSignificantByteInInt32Offset));
947-
STATIC_ASSERT(static_cast<int>(DebugInfo::kDebugExecutionMode) ==
948-
static_cast<int>(DebugInfo::kSideEffects));
949-
__ Branch(&bytecode_array_loaded, eq, a4, Operand(a5));
950-
951-
__ push(closure);
952-
__ push(feedback_vector);
953-
__ push(kInterpreterBytecodeArrayRegister);
954-
__ push(closure);
955-
__ CallRuntime(Runtime::kDebugApplyInstrumentation);
956-
__ pop(kInterpreterBytecodeArrayRegister);
957-
__ pop(feedback_vector);
958-
__ pop(closure);
959-
__ Branch(&bytecode_array_loaded);
960926
}
961927

962928
static void Generate_StackOverflowCheck(MacroAssembler* masm, Register num_args,

‎src/builtins/ppc/builtins-ppc.cc‎

Lines changed: 2 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -830,18 +830,13 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
830830
FrameScope frame_scope(masm, StackFrame::MANUAL);
831831
__ PushStandardFrame(closure);
832832

833-
// Get the bytecode array from the function object (or from the DebugInfo if
834-
// it is present) and load it into kInterpreterBytecodeArrayRegister.
835-
Label maybe_load_debug_bytecode_array, bytecode_array_loaded;
833+
// Get the bytecode array from the function object and load it into
834+
// kInterpreterBytecodeArrayRegister.
836835
__ LoadP(r3, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
837836
// Load original bytecode array or the debug copy.
838837
__ LoadP(kInterpreterBytecodeArrayRegister,
839838
FieldMemOperand(r3, SharedFunctionInfo::kFunctionDataOffset));
840839
GetSharedFunctionInfoBytecode(masm, kInterpreterBytecodeArrayRegister, r7);
841-
__ LoadP(r7, FieldMemOperand(r3, SharedFunctionInfo::kDebugInfoOffset));
842-
__ TestIfSmi(r7, r0);
843-
__ bne(&maybe_load_debug_bytecode_array, cr0);
844-
__ bind(&bytecode_array_loaded);
845840

846841
// Increment invocation count for the function.
847842
__ LoadWord(
@@ -963,32 +958,6 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
963958
// The return value is in r3.
964959
LeaveInterpreterFrame(masm, r5);
965960
__ blr();
966-
967-
// Load debug copy of the bytecode array if it exists.
968-
// kInterpreterBytecodeArrayRegister is already loaded with
969-
// SharedFunctionInfo::kFunctionDataOffset.
970-
__ bind(&maybe_load_debug_bytecode_array);
971-
__ LoadP(ip, FieldMemOperand(r7, DebugInfo::kDebugBytecodeArrayOffset));
972-
__ JumpIfRoot(ip, Heap::kUndefinedValueRootIndex, &bytecode_array_loaded);
973-
974-
__ mr(kInterpreterBytecodeArrayRegister, ip);
975-
__ LoadP(ip, FieldMemOperand(r7, DebugInfo::kFlagsOffset));
976-
__ SmiUntag(ip);
977-
__ andi(ip, ip, Operand(DebugInfo::kDebugExecutionMode));
978-
979-
ExternalReference debug_execution_mode =
980-
ExternalReference::debug_execution_mode_address(masm->isolate());
981-
__ mov(r7, Operand(debug_execution_mode));
982-
__ lwz(r7, MemOperand(r7));
983-
STATIC_ASSERT(static_cast<int>(DebugInfo::kDebugExecutionMode) ==
984-
static_cast<int>(DebugInfo::kSideEffects));
985-
__ cmp(r7, ip);
986-
__ beq(&bytecode_array_loaded);
987-
988-
__ Push(closure, feedback_vector, kInterpreterBytecodeArrayRegister, closure);
989-
__ CallRuntime(Runtime::kDebugApplyInstrumentation);
990-
__ Pop(closure, feedback_vector, kInterpreterBytecodeArrayRegister);
991-
__ b(&bytecode_array_loaded);
992961
}
993962

994963
static void Generate_StackOverflowCheck(MacroAssembler* masm, Register num_args,

0 commit comments

Comments
 (0)