Uniform and precise source positions for inlining

src/objects.cc

 // Copyright 2015 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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 13352 matching lines @@
     array->set_map(isolate->heap()->fixed_cow_array_map());
   }
 
   script->set_line_ends(*array);
   DCHECK(script->line_ends()->IsFixedArray());
 }
 
 #define SMI_VALUE(x) (Smi::cast(x)->value())
 bool Script::GetPositionInfo(int position, PositionInfo* info,
                              OffsetFlag offset_flag) {
-  Handle<Script> script(this);
-  InitLineEnds(script);
+  Script* script = this;
+  if (script->line_ends()->IsUndefined(GetIsolate())) {
+    Handle<Script> script_handle(script);
+    InitLineEnds(script_handle);
+    script = *script_handle;
+  }
 
   DisallowHeapAllocation no_allocation;
 
   DCHECK(script->line_ends()->IsFixedArray());
   FixedArray* ends = FixedArray::cast(script->line_ends());
 
   const int ends_len = ends->length();
   if (ends_len == 0) return false;
 
   // Return early on invalid positions. Negative positions behave as if 0 was
@@ skipping 28 matching lines @@
     DCHECK(SMI_VALUE(ends->get(info->line)) >= position &&
            SMI_VALUE(ends->get(info->line - 1)) < position);
     info->line_start = SMI_VALUE(ends->get(info->line - 1)) + 1;
     info->column = position - info->line_start;
   }
 
   // Line end is position of the linebreak character.
   info->line_end = SMI_VALUE(ends->get(info->line));
   if (info->line_end > 0) {
     DCHECK(script->source()->IsString());
-    Handle<String> src(String::cast(script->source()));
+    String* src = String::cast(script->source());
     if (src->length() >= info->line_end &&
         src->Get(info->line_end - 1) == '\r') {
       info->line_end--;
     }
   }
 
   // Add offsets if requested.
   if (offset_flag == WITH_OFFSET) {
     if (info->line == 0) {
       info->column += script->column_offset();
@@ skipping 798 matching lines @@
   }
 }
 
 int AbstractCode::SourcePosition(int offset) {
   int position = 0;
   // Subtract one because the current PC is one instruction after the call site.
   if (IsCode()) offset--;
   for (SourcePositionTableIterator iterator(source_position_table());
        !iterator.done() && iterator.code_offset() <= offset;
        iterator.Advance()) {
-    position = iterator.source_position();
+    position = iterator.source_position().ScriptOffset();
   }
   return position;
 }
 
 int AbstractCode::SourceStatementPosition(int offset) {
   // First find the closest position.
   int position = SourcePosition(offset);
   // Now find the closest statement position before the position.
   int statement_position = 0;
   for (SourcePositionTableIterator it(source_position_table()); !it.done();
        it.Advance()) {
     if (it.is_statement()) {
-      int p = it.source_position();
+      int p = it.source_position().ScriptOffset();
       if (statement_position < p && p <= position) {
         statement_position = p;
       }
     }
   }
   return statement_position;
 }
 
 void JSFunction::ClearTypeFeedbackInfo() {
   feedback_vector()->ClearSlots(shared());
@@ skipping 199 matching lines @@
   }
   return NULL;
 }
 
 
 void Code::PrintDeoptLocation(FILE* out, Address pc) {
   Deoptimizer::DeoptInfo info = Deoptimizer::GetDeoptInfo(this, pc);
   class SourcePosition pos = info.position;
   if (info.deopt_reason != DeoptimizeReason::kNoReason || !pos.IsUnknown()) {
     if (FLAG_hydrogen_track_positions) {
-      PrintF(out, "            ;;; deoptimize at %d_%d: %s\n",
-             pos.inlining_id(), pos.position(),
-             DeoptimizeReasonToString(info.deopt_reason));
+      PrintF(out, "            ;;; deoptimize at %d_%d: %s\n", pos.InliningId(),
+             pos.ScriptOffset(), DeoptimizeReasonToString(info.deopt_reason));
     } else {
-      PrintF(out, "            ;;; deoptimize at %d: %s\n", pos.raw(),
-             DeoptimizeReasonToString(info.deopt_reason));
+      PrintF(out, "            ;;; deoptimize at ");
+      OFStream outstr(out);
+      pos.Print(outstr, this);
+      PrintF(out, ", %s\n", DeoptimizeReasonToString(info.deopt_reason));
     }
   }
 }
 
 
 bool Code::CanDeoptAt(Address pc) {
   DeoptimizationInputData* deopt_data =
       DeoptimizationInputData::cast(deoptimization_data());
   Address code_start_address = instruction_start();
   for (int i = 0; i < deopt_data->DeoptCount(); i++) {
@@ skipping 418 matching lines @@
       }
     }
   }
   os << "\n";
 
   SourcePositionTableIterator it(source_position_table());
   if (!it.done()) {
     os << "Source positions:\n pc offset  position\n";
     for (; !it.done(); it.Advance()) {
       os << std::setw(10) << it.code_offset() << std::setw(10)
-         << it.source_position() << (it.is_statement() ? "  statement" : "")
-         << "\n";
+         << it.source_position().ScriptOffset()
+         << (it.is_statement() ? "  statement" : "") << "\n";
     }
     os << "\n";
   }
 
   if (kind() == FUNCTION) {
     DeoptimizationOutputData* data =
         DeoptimizationOutputData::cast(this->deoptimization_data());
     data->DeoptimizationOutputDataPrint(os);
   } else if (kind() == OPTIMIZED_FUNCTION) {
     DeoptimizationInputData* data =
@@ skipping 81 matching lines @@
   os << "Parameter count " << parameter_count() << "\n";
   os << "Frame size " << frame_size() << "\n";
 
   const uint8_t* base_address = GetFirstBytecodeAddress();
   SourcePositionTableIterator source_positions(source_position_table());
 
   interpreter::BytecodeArrayIterator iterator(handle(this));
   while (!iterator.done()) {
     if (!source_positions.done() &&
         iterator.current_offset() == source_positions.code_offset()) {
-      os << std::setw(5) << source_positions.source_position();
+      os << std::setw(5) << source_positions.source_position().ScriptOffset();
       os << (source_positions.is_statement() ? " S> " : " E> ");
       source_positions.Advance();
     } else {
       os << "         ";
     }
     const uint8_t* current_address = base_address + iterator.current_offset();
     os << reinterpret_cast<const void*>(current_address) << " @ "
        << std::setw(4) << iterator.current_offset() << " : ";
     interpreter::BytecodeDecoder::Decode(os, current_address,
                                          parameter_count());
@@ skipping 5189 matching lines @@
         ns, Accessors::ModuleNamespaceEntryInfo(isolate, name, attr))
         .Check();
   }
   JSObject::PreventExtensions(ns, THROW_ON_ERROR).ToChecked();
 
   return ns;
 }
 
 }  // namespace internal
 }  // namespace v8