Refactor FrameSummary for JS and Wasm frames

src/runtime/runtime-debug.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/compiler.h"
 #include "src/debug/debug-evaluate.h"
 #include "src/debug/debug-frames.h"
@@ skipping 417 matching lines @@
   CHECK(isolate->debug()->CheckExecutionState(break_id));
 
   // Count all frames which are relevant to debugging stack trace.
   int n = 0;
   StackFrame::Id id = isolate->debug()->break_frame_id();
   if (id == StackFrame::NO_ID) {
     // If there is no JavaScript stack frame count is 0.
     return Smi::kZero;
   }
 
+  List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
   for (StackTraceFrameIterator it(isolate, id); !it.done(); it.Advance()) {
-    List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
-    if (it.is_wasm()) {
-      n++;
-    } else {
-      it.javascript_frame()->Summarize(&frames);
-      for (int i = frames.length() - 1; i >= 0; i--) {
-        // Omit functions from native and extension scripts.
-        if (frames[i].function()->shared()->IsSubjectToDebugging()) n++;
-      }
+    frames.Clear();
+    it.frame()->Summarize(&frames);
+    for (int i = frames.length() - 1; i >= 0; i--) {
+      // Omit functions from native and extension scripts.
+      if (frames[i].is_subject_to_debugging()) n++;
     }
   }
   return Smi::FromInt(n);
 }
 
-
 static const int kFrameDetailsFrameIdIndex = 0;
 static const int kFrameDetailsReceiverIndex = 1;
 static const int kFrameDetailsFunctionIndex = 2;
 static const int kFrameDetailsScriptIndex = 3;
 static const int kFrameDetailsArgumentCountIndex = 4;
 static const int kFrameDetailsLocalCountIndex = 5;
 static const int kFrameDetailsSourcePositionIndex = 6;
 static const int kFrameDetailsConstructCallIndex = 7;
 static const int kFrameDetailsAtReturnIndex = 8;
 static const int kFrameDetailsFlagsIndex = 9;
@@ skipping 28 matching lines @@
 
   // Find the relevant frame with the requested index.
   StackFrame::Id id = isolate->debug()->break_frame_id();
   if (id == StackFrame::NO_ID) {
     // If there are no JavaScript stack frames return undefined.
     return heap->undefined_value();
   }
 
   StackTraceFrameIterator it(isolate, id);
   // Inlined frame index in optimized frame, starting from outer function.
-  int inlined_jsframe_index =
+  int inlined_frame_index =
       DebugFrameHelper::FindIndexedNonNativeFrame(&it, index);
-  if (inlined_jsframe_index == -1) return heap->undefined_value();
+  if (inlined_frame_index == -1) return heap->undefined_value();
 
-  FrameInspector frame_inspector(it.frame(), inlined_jsframe_index, isolate);
+  FrameInspector frame_inspector(it.frame(), inlined_frame_index, isolate);
 
   // Traverse the saved contexts chain to find the active context for the
   // selected frame.
   SaveContext* save =
       DebugFrameHelper::FindSavedContextForFrame(isolate, it.frame());
 
   // Get the frame id.
   Handle<Object> frame_id(DebugFrameHelper::WrapFrameId(it.frame()->id()),
                           isolate);
 
-  // Find source position in unoptimized code.
-  int position = frame_inspector.GetSourcePosition();
-
-  if (it.is_wasm()) {
+  if (frame_inspector.summary().IsWasm()) {
     // Create the details array (no dynamic information for wasm).
     Handle<FixedArray> details =
         isolate->factory()->NewFixedArray(kFrameDetailsFirstDynamicIndex);
 
     // Add the frame id.
     details->set(kFrameDetailsFrameIdIndex, *frame_id);
 
     // Add the function name.
-    Handle<WasmCompiledModule> compiled_module(
-        it.wasm_compiled_frame()->wasm_instance()->compiled_module(), isolate);
-    int func_index = it.wasm_compiled_frame()->function_index();
-    Handle<String> func_name = WasmCompiledModule::GetFunctionName(
-        isolate, compiled_module, func_index);
+    Handle<String> func_name = frame_inspector.summary().FunctionName();
     details->set(kFrameDetailsFunctionIndex, *func_name);
 
     // Add the script wrapper
     Handle<Object> script_wrapper =
         Script::GetWrapper(frame_inspector.GetScript());
     details->set(kFrameDetailsScriptIndex, *script_wrapper);
 
     // Add the arguments count.
     details->set(kFrameDetailsArgumentCountIndex, Smi::kZero);
 
     // Add the locals count
     details->set(kFrameDetailsLocalCountIndex, Smi::kZero);
 
     // Add the source position.
-    // For wasm, it is function-local, so translate it to a module-relative
-    // position, such that together with the script it uniquely identifies the
-    // position.
-    Handle<Object> positionValue;
-    if (position != kNoSourcePosition) {
-      int translated_position = position;
-      // No further translation needed for asm.js modules.
-      if (!compiled_module->is_asm_js()) {
-        translated_position +=
-            wasm::GetFunctionCodeOffset(compiled_module, func_index);
-      }
-      details->set(kFrameDetailsSourcePositionIndex,
-                   Smi::FromInt(translated_position));
-    }
+    int position = frame_inspector.summary().SourcePosition();
+    details->set(kFrameDetailsSourcePositionIndex, Smi::FromInt(position));
 
     // Add the constructor information.
     details->set(kFrameDetailsConstructCallIndex, heap->ToBoolean(false));
 
     // Add the at return information.
     details->set(kFrameDetailsAtReturnIndex, heap->ToBoolean(false));
 
     // Add flags to indicate information on whether this frame is
     //   bit 0: invoked in the debugger context.
     //   bit 1: optimized frame.
     //   bit 2: inlined in optimized frame
     int flags = 0;
     if (*save->context() == *isolate->debug()->debug_context()) {
       flags |= 1 << 0;
     }
     details->set(kFrameDetailsFlagsIndex, Smi::FromInt(flags));
 
     return *isolate->factory()->NewJSArrayWithElements(details);
   }
 
+  // Find source position in unoptimized code.
+  int position = frame_inspector.GetSourcePosition();
+
   // Handle JavaScript frames.
   bool is_optimized = it.frame()->is_optimized();
 
   // Check for constructor frame.
   bool constructor = frame_inspector.IsConstructor();
 
   // Get scope info and read from it for local variable information.
   Handle<JSFunction> function =
       Handle<JSFunction>::cast(frame_inspector.GetFunction());
   CHECK(function->shared()->IsSubjectToDebugging());
@@ skipping 61 matching lines @@
   // to the frame information.
   Handle<Object> return_value = isolate->factory()->undefined_value();
   if (at_return) {
     return_value = isolate->debug()->return_value();
   }
 
   // Now advance to the arguments adapter frame (if any). It contains all
   // the provided parameters whereas the function frame always have the number
   // of arguments matching the functions parameters. The rest of the
   // information (except for what is collected above) is the same.
-  if ((inlined_jsframe_index == 0) &&
+  if ((inlined_frame_index == 0) &&
       it.javascript_frame()->has_adapted_arguments()) {
     it.AdvanceToArgumentsFrame();
     frame_inspector.SetArgumentsFrame(it.frame());
   }
 
   // Find the number of arguments to fill. At least fill the number of
   // parameters for the function and fill more if more parameters are provided.
   int argument_count = scope_info->ParameterCount();
   if (argument_count < frame_inspector.GetParametersCount()) {
     argument_count = frame_inspector.GetParametersCount();
@@ skipping 37 matching lines @@
   // Add flags to indicate information on whether this frame is
   //   bit 0: invoked in the debugger context.
   //   bit 1: optimized frame.
   //   bit 2: inlined in optimized frame
   int flags = 0;
   if (*save->context() == *isolate->debug()->debug_context()) {
     flags |= 1 << 0;
   }
   if (is_optimized) {
     flags |= 1 << 1;
-    flags |= inlined_jsframe_index << 2;
+    flags |= inlined_frame_index << 2;
   }
   details->set(kFrameDetailsFlagsIndex, Smi::FromInt(flags));
 
   // Fill the dynamic part.
   int details_index = kFrameDetailsFirstDynamicIndex;
 
   // Add arguments name and value.
   for (int i = 0; i < argument_count; i++) {
     // Name of the argument.
     if (i < scope_info->ParameterCount()) {
@@ skipping 1207 matching lines @@
 }
 
 
 RUNTIME_FUNCTION(Runtime_DebugBreakInOptimizedCode) {
   UNIMPLEMENTED();
   return NULL;
 }
 
 }  // namespace internal
 }  // namespace v8