deps: cherry-pick b20faff from upstream V8

Original commit message:
[log] fix ExistingCodeLogger behavior on edge case
ExistingCodeLogger was behaving incorrectly when the
CodeEventHandler API was used in combination with
--interpreted-frames-native-stack. Instead of collecting copied
trampolines as InterpretedFunction:functionName, they were being
collected as Builtin:IntepreterEntryTrampolines. This patch adds
special handling for copied trampolines when using
ExistingCodeLogger.
R=yangguo@google.com
Change-Id: I3ee4be03800122d28d53b51b20c60dcf6263e4c1
Reviewed-on: https://chromium-review.googlesource.com/1087813
Reviewed-by: Yang Guo <yangguo@chromium.org>
Commit-Queue: Yang Guo <yangguo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53624}
Refs: v8/v8@b20faff
PR-URL: #21126
Refs: v8/v8@aa6ce3e
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: Matheus Marchini

common.gypi

@@ -27,7 +27,7 @@
 
 # Reset this number to 0 on major V8 upgrades.
 # Increment by one for each non-official patch applied to deps/v8.
-'v8_embedder_string': '-node.10',
+'v8_embedder_string': '-node.11',
 
 # Enable disassembler for `--print-code` v8 options
 'v8_enable_disassembler': 1,

deps/v8/src/log.cc

@@ -2031,18 +2031,18 @@ FILE* Logger::TearDown() {
 }
 
 voidExistingCodeLogger::LogCodeObject(Object* object) {
- AbstractCode* code_object = AbstractCode::cast(object);
+ AbstractCode* abstract_code = AbstractCode::cast(object);
  CodeEventListener::LogEventsAndTags tag = CodeEventListener::STUB_TAG;
 constchar* description = "Unknown code from before profiling";
-switch (code_object->kind()) {
+switch (abstract_code->kind()) {
 case AbstractCode::INTERPRETED_FUNCTION:
 case AbstractCode::OPTIMIZED_FUNCTION:
 return; // We log this later using LogCompiledFunctions.
 case AbstractCode::BYTECODE_HANDLER:
 return; // We log it later by walking the dispatch table.
 case AbstractCode::STUB:
  description =
-CodeStub::MajorName(CodeStub::GetMajorKey(code_object->GetCode()));
+CodeStub::MajorName(CodeStub::GetMajorKey(abstract_code->GetCode()));
 if (description == nullptr) description = "A stub from before profiling";
  tag = CodeEventListener::STUB_TAG;
 break;
@@ -2051,8 +2051,13 @@ void ExistingCodeLogger::LogCodeObject(Object* object) {
  tag = CodeEventListener::REG_EXP_TAG;
 break;
 case AbstractCode::BUILTIN:
+if (Code::cast(object)->is_interpreter_trampoline_builtin() &&
+Code::cast(object) ==
+ *BUILTIN_CODE(isolate_, InterpreterEntryTrampoline)) {
+return;
+ }
  description =
- isolate_->builtins()->name(code_object->GetCode()->builtin_index());
+ isolate_->builtins()->name(abstract_code->GetCode()->builtin_index());
  tag = CodeEventListener::BUILTIN_TAG;
 break;
 case AbstractCode::WASM_FUNCTION:
@@ -2078,7 +2083,7 @@ void ExistingCodeLogger::LogCodeObject(Object* object) {
 case AbstractCode::NUMBER_OF_KINDS:
 UNIMPLEMENTED();
  }
-CALL_CODE_EVENT_HANDLER(CodeCreateEvent(tag, code_object, description))
+CALL_CODE_EVENT_HANDLER(CodeCreateEvent(tag, abstract_code, description))
 }
 
 voidExistingCodeLogger::LogCodeObjects() {
@@ -2104,6 +2109,12 @@ void ExistingCodeLogger::LogCompiledFunctions() {
 // During iteration, there can be heap allocation due to
 // GetScriptLineNumber call.
 for (int i = 0; i < compiled_funcs_count; ++i) {
+if (sfis[i]->function_data()->IsInterpreterData()) {
+LogExistingFunction(sfis[i],
+ Handle<AbstractCode>(AbstractCode::cast(
+ sfis[i]->InterpreterTrampoline())),
+ CodeEventListener::INTERPRETED_FUNCTION_TAG);
+ }
 if (code_objects[i].is_identical_to(BUILTIN_CODE(isolate_, CompileLazy)))
 continue;
 LogExistingFunction(sfis[i], code_objects[i]);
@@ -2148,8 +2159,9 @@ void ExistingCodeLogger::LogBytecodeHandlers() {
  }
 }
 
-voidExistingCodeLogger::LogExistingFunction(Handle<SharedFunctionInfo> shared,
- Handle<AbstractCode> code) {
+voidExistingCodeLogger::LogExistingFunction(
+ Handle<SharedFunctionInfo> shared, Handle<AbstractCode> code,
+ CodeEventListener::LogEventsAndTags tag) {
 if (shared->script()->IsScript()) {
  Handle<Script> script(Script::cast(shared->script()));
 int line_num = Script::GetLineNumber(script, shared->StartPosition()) + 1;
@@ -2159,21 +2171,18 @@ void ExistingCodeLogger::LogExistingFunction(Handle<SharedFunctionInfo> shared,
  Handle<String> script_name(String::cast(script->name()));
 if (line_num > 0) {
 CALL_CODE_EVENT_HANDLER(
-CodeCreateEvent(Logger::ToNativeByScript(
- CodeEventListener::LAZY_COMPILE_TAG, *script),
- *code, *shared, *script_name, line_num, column_num))
+CodeCreateEvent(Logger::ToNativeByScript(tag, *script), *code,
+ *shared, *script_name, line_num, column_num))
  } else {
 // Can't distinguish eval and script here, so always use Script.
 CALL_CODE_EVENT_HANDLER(CodeCreateEvent(
 Logger::ToNativeByScript(CodeEventListener::SCRIPT_TAG, *script),
  *code, *shared, *script_name))
  }
  } else {
-CALL_CODE_EVENT_HANDLER(
-CodeCreateEvent(Logger::ToNativeByScript(
- CodeEventListener::LAZY_COMPILE_TAG, *script),
- *code, *shared, isolate_->heap()->empty_string(),
- line_num, column_num))
+CALL_CODE_EVENT_HANDLER(CodeCreateEvent(
+Logger::ToNativeByScript(tag, *script), *code, *shared,
+ isolate_->heap()->empty_string(), line_num, column_num))
  }
  } elseif (shared->IsApiFunction()) {
 // API function.
@@ -2189,9 +2198,8 @@ void ExistingCodeLogger::LogExistingFunction(Handle<SharedFunctionInfo> shared,
 CALL_CODE_EVENT_HANDLER(CallbackEvent(shared->DebugName(), entry_point))
  }
  } else {
-CALL_CODE_EVENT_HANDLER(CodeCreateEvent(CodeEventListener::LAZY_COMPILE_TAG,
- *code, *shared,
- isolate_->heap()->empty_string()))
+CALL_CODE_EVENT_HANDLER(
+CodeCreateEvent(tag, *code, *shared, isolate_->heap()->empty_string()))
  }
 }
 

deps/v8/src/log.h

@@ -105,7 +105,9 @@ class ExistingCodeLogger {
 
 voidLogCompiledFunctions();
 voidLogExistingFunction(Handle<SharedFunctionInfo> shared,
- Handle<AbstractCode> code);
+ Handle<AbstractCode> code,
+ CodeEventListener::LogEventsAndTags tag =
+ CodeEventListener::LAZY_COMPILE_TAG);
 voidLogCodeObject(Object* object);
 voidLogBytecodeHandler(interpreter::Bytecode bytecode,
  interpreter::OperandScale operand_scale, Code* code);

deps/v8/test/cctest/test-log.cc

@@ -876,6 +876,49 @@ TEST(ExternalCodeEventListener) {
  isolate->Dispose();
 }
 
+TEST(ExternalCodeEventListenerWithInterpretedFramesNativeStack) {
+ i::FLAG_log = false;
+ i::FLAG_prof = false;
+ i::FLAG_interpreted_frames_native_stack = true;
+
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+
+ {
+ v8::HandleScope scope(isolate);
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ context->Enter();
+
+ TestCodeEventHandler code_event_handler(isolate);
+
+constchar* source_text_before_start =
+"function testCodeEventListenerBeforeStart(a,b) { return a + b };"
+"testCodeEventListenerBeforeStart('1', 1);";
+CompileRun(source_text_before_start);
+
+CHECK_NULL(code_event_handler.FindLine("InterpretedFunction",
+"testCodeEventListenerBeforeStart"));
+
+ code_event_handler.Enable();
+
+CHECK_NOT_NULL(code_event_handler.FindLine(
+"InterpretedFunction", "testCodeEventListenerBeforeStart"));
+
+constchar* source_text_after_start =
+"function testCodeEventListenerAfterStart(a,b) { return a + b };"
+"testCodeEventListenerAfterStart('1', 1);";
+CompileRun(source_text_after_start);
+
+CHECK_NOT_NULL(code_event_handler.FindLine(
+"InterpretedFunction", "testCodeEventListenerAfterStart"));
+
+ context->Exit();
+ }
+ isolate->Dispose();
+}
+
 TEST(TraceMaps) {
 SETUP_FLAGS();
  i::FLAG_trace_maps = true;