[deoptimizer] use correct code/bytecode to compute source position.

src/deoptimizer.cc

 // Copyright 2013 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/deoptimizer.h"
 
 #include <memory>
 
 #include "src/accessors.h"
 #include "src/ast/prettyprinter.h"
@@ skipping 2665 matching lines @@
   TranslatedFrame::iterator parameter_it = parameter_frame->begin();
   parameter_it++;  // Skip the function.
   parameter_it++;  // Skip the receiver.
 
   // Figure out whether there is a construct stub frame on top of
   // the parameter frame.
   has_construct_stub_ =
       parameter_frame != state->begin() &&
       (parameter_frame - 1)->kind() == TranslatedFrame::kConstructStub;
 
-  source_position_ = Deoptimizer::ComputeSourcePosition(
-      *frame_it->shared_info(), frame_it->node_id());
+  if (frame_it->kind() == TranslatedFrame::kInterpretedFunction) {
+    source_position_ = Deoptimizer::ComputeSourcePositionFromBytecodeArray(
+        *frame_it->shared_info(), frame_it->node_id());
+  } else {
+    source_position_ = Deoptimizer::ComputeSourcePositionFromBaselineCode(

[Michael Starzinger, 2016/08/12 10:56:49]

nit: Can we add DCHECK(frame_it->kind() == TranslatedFrame::kFunction) into the
else case?

+        *frame_it->shared_info(), frame_it->node_id());
+  }
 
   TranslatedFrame::iterator value_it = frame_it->begin();
   // Get the function. Note that this might materialize the function.
   // In case the debugger mutates this value, we should deoptimize
   // the function and remember the value in the materialized value store.
   function_ = Handle<JSFunction>::cast(value_it->GetValue());
 
   parameters_.resize(static_cast<size_t>(parameter_count));
   for (int i = 0; i < parameter_count; i++) {
     Handle<Object> parameter = GetValueForDebugger(parameter_it, isolate);
@@ skipping 57 matching lines @@
       last_deopt_id = static_cast<int>(info->data());
     } else if (info->rmode() == RelocInfo::DEOPT_REASON) {
       last_reason = static_cast<DeoptimizeReason>(info->data());
     }
   }
   return DeoptInfo(SourcePosition::Unknown(), DeoptimizeReason::kNoReason, -1);
 }
 
 
 // static
-int Deoptimizer::ComputeSourcePosition(SharedFunctionInfo* shared,
-                                       BailoutId node_id) {
-  AbstractCode* abstract_code = shared->abstract_code();
-  int code_offset;
-  if (abstract_code->IsBytecodeArray()) {
-    // BailoutId points to the next bytecode in the bytecode aray. Subtract
-    // 1 to get the end of current bytecode.
-    code_offset = node_id.ToInt() - 1;
-  } else {
-    FixedArray* raw_data = abstract_code->GetCode()->deoptimization_data();
-    DeoptimizationOutputData* data = DeoptimizationOutputData::cast(raw_data);
-    unsigned pc_and_state = Deoptimizer::GetOutputInfo(data, node_id, shared);
-    code_offset =
-        static_cast<int>(FullCodeGenerator::PcField::decode(pc_and_state));
-  }
-  return abstract_code->SourcePosition(code_offset);
+int Deoptimizer::ComputeSourcePositionFromBaselineCode(
+    SharedFunctionInfo* shared, BailoutId node_id) {
+  DCHECK(shared->HasBaselineCode());
+  Code* code = shared->code();
+  FixedArray* raw_data = code->deoptimization_data();
+  DeoptimizationOutputData* data = DeoptimizationOutputData::cast(raw_data);
+  unsigned pc_and_state = Deoptimizer::GetOutputInfo(data, node_id, shared);
+  int code_offset =
+      static_cast<int>(FullCodeGenerator::PcField::decode(pc_and_state));
+  return AbstractCode::cast(code)->SourcePosition(code_offset);
 }
 
 // static
+int Deoptimizer::ComputeSourcePositionFromBytecodeArray(
+    SharedFunctionInfo* shared, BailoutId node_id) {
+  DCHECK(shared->HasBytecodeArray());
+  // BailoutId points to the next bytecode in the bytecode aray. Subtract
+  // 1 to get the end of current bytecode.
+  int code_offset = node_id.ToInt() - 1;
+  return AbstractCode::cast(shared->bytecode_array())
+      ->SourcePosition(code_offset);
+}
+
+// static
 TranslatedValue TranslatedValue::NewArgumentsObject(TranslatedState* container,
                                                     int length,
                                                     int object_index) {
   TranslatedValue slot(container, kArgumentsObject);
   slot.materialization_info_ = {object_index, length};
   return slot;
 }
 
 
 // static
@@ skipping 1201 matching lines @@
       CHECK(value_info->IsMaterializedObject());
 
       value_info->value_ =
           Handle<Object>(previously_materialized_objects->get(i), isolate_);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8