[inspector] Expose GetPossibleBreakpoints for wasm

src/inspector/wasm-translation.cc

 // Copyright 2016 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/inspector/wasm-translation.h"
 
 #include <algorithm>
 
 #include "src/debug/debug-interface.h"
 #include "src/inspector/protocol/Debugger.h"
@@ skipping 15 matching lines @@
     int line;
     int column;
     TransLocation(WasmTranslation *translation, String16 script_id, int line,
                   int column)
         : translation(translation),
           script_id(script_id),
           line(line),
           column(column) {}
   };
 
+  TranslatorImpl(WasmTranslation* translation, int script_id) {
+    DCHECK_EQ(0, translation->wasm_translators_.count(script_id));
+    translation->wasm_translators_.insert(
+        std::make_pair(script_id, std::unique_ptr<TranslatorImpl>(this)));
+  }
+
   virtual void Translate(TransLocation *loc) = 0;
   virtual void TranslateBack(TransLocation *loc) = 0;
 
   class RawTranslator;
   class DisassemblingTranslator;
 };
 
 class WasmTranslation::TranslatorImpl::RawTranslator
     : public WasmTranslation::TranslatorImpl {
  public:
+  RawTranslator(WasmTranslation* translation, Local<debug::WasmScript> script)
+      : TranslatorImpl(translation, script->Id()) {}
   void Translate(TransLocation *loc) {}
   void TranslateBack(TransLocation *loc) {}
 };
 
 class WasmTranslation::TranslatorImpl::DisassemblingTranslator
     : public WasmTranslation::TranslatorImpl {
   using OffsetTable = debug::WasmDisassembly::OffsetTable;
 
  public:
-  DisassemblingTranslator(Isolate *isolate, Local<debug::WasmScript> script,
-                          WasmTranslation *translation,
-                          V8DebuggerAgentImpl *agent)
-      : script_(isolate, script) {
+  DisassemblingTranslator(Isolate* isolate, Local<debug::WasmScript> script,
+                          WasmTranslation* translation,
+                          V8DebuggerAgentImpl* agent)
+      : TranslatorImpl(translation, script->Id()), script_(isolate, script) {
     // Register fake scripts for each function in this wasm module/script.
     int num_functions = script->NumFunctions();
     int num_imported_functions = script->NumImportedFunctions();
     DCHECK_LE(0, num_imported_functions);
     DCHECK_LE(0, num_functions);
     DCHECK_GE(num_functions, num_imported_functions);
     String16 script_id = String16::fromInteger(script->Id());
     for (int func_idx = num_imported_functions; func_idx < num_functions;
          ++func_idx) {
       AddFakeScript(isolate, script_id, func_idx, translation, agent);
@@ skipping 25 matching lines @@
       loc->line = 0;
       loc->column = 0;
     }
   }
 
   void TranslateBack(TransLocation *loc) {
     int func_index = GetFunctionIndexFromFakeScriptId(loc->script_id);
     const OffsetTable *reverse_table = GetReverseTable(func_index);
     if (!reverse_table) return;
     DCHECK(!reverse_table->empty());
+    v8::Isolate* isolate = loc->translation->isolate_;
 
     // Binary search for the given line and column.
     unsigned left = 0;                                              // inclusive
     unsigned right = static_cast<unsigned>(reverse_table->size());  // exclusive
     while (right - left > 1) {
       unsigned mid = (left + right) / 2;
       auto &entry = (*reverse_table)[mid];
       if (entry.line < loc->line ||
           (entry.line == loc->line && entry.column <= loc->column)) {
         left = mid;
       } else {
         right = mid;
       }
     }
 
     int found_byte_offset = 0;
     // If we found an exact match, use it. Otherwise check whether the next
     // bigger entry is still in the same line. Report that one then.
+    // Otherwise we might have hit the special case of pointing after the last
+    // line, which is translated to the end of the function (one byte after the
+    // last function byte).
     if ((*reverse_table)[left].line == loc->line &&
         (*reverse_table)[left].column == loc->column) {
       found_byte_offset = (*reverse_table)[left].byte_offset;
     } else if (left + 1 < reverse_table->size() &&
                (*reverse_table)[left + 1].line == loc->line) {
       found_byte_offset = (*reverse_table)[left + 1].byte_offset;
+    } else if (left == reverse_table->size() - 1 &&
+               (*reverse_table)[left].line == loc->line - 1 &&
+               loc->column == 0) {
+      std::pair<int, int> func_range =
+          script_.Get(isolate)->GetFunctionRange(func_index);
+      DCHECK_LE(func_range.first, func_range.second);
+      found_byte_offset = func_range.second - func_range.first;
     }
 
-    v8::Isolate *isolate = loc->translation->isolate_;
     loc->script_id = String16::fromInteger(script_.Get(isolate)->Id());
     loc->line = func_index;
     loc->column = found_byte_offset;
   }
 
  private:
   String16 GetFakeScriptUrl(v8::Isolate *isolate, int func_index) {
     Local<debug::WasmScript> script = script_.Get(isolate);
     String16 script_name = toProtocolString(script->Name().ToLocalChecked());
     int numFunctions = script->NumFunctions();
@@ skipping 29 matching lines @@
     v8::Local<debug::WasmScript> script = script_.Get(isolate);
     // TODO(clemensh): Generate disassembly lazily when queried by the frontend.
     debug::WasmDisassembly disassembly = script->DisassembleFunction(func_idx);
 
     DCHECK_EQ(0, offset_tables_.count(func_idx));
     offset_tables_.insert(
         std::make_pair(func_idx, std::move(disassembly.offset_table)));
     String16 source(disassembly.disassembly.data(),
                     disassembly.disassembly.length());
     std::unique_ptr<V8DebuggerScript> fake_script =
-        V8DebuggerScript::CreateWasm(isolate, script, fake_script_id,
-                                     std::move(fake_script_url), source);
+        V8DebuggerScript::CreateWasm(isolate, translation, script,
+                                     fake_script_id, std::move(fake_script_url),
+                                     source);
 
     translation->AddFakeScript(fake_script->scriptId(), this);
     agent->didParseSource(std::move(fake_script), true);
   }
 
   int GetFunctionIndexFromFakeScriptId(const String16 &fake_script_id) {
     size_t last_dash_pos = fake_script_id.reverseFind('-');
     DCHECK_GT(fake_script_id.length(), last_dash_pos);
     bool ok = true;
     int func_index = fake_script_id.substring(last_dash_pos + 1).toInteger(&ok);
@@ skipping 41 matching lines @@
   std::unordered_map<int, const OffsetTable> reverse_tables_;
 };
 
 WasmTranslation::WasmTranslation(v8::Isolate *isolate)
     : isolate_(isolate), mode_(Disassemble) {}
 
 WasmTranslation::~WasmTranslation() { Clear(); }
 
 void WasmTranslation::AddScript(Local<debug::WasmScript> script,
                                 V8DebuggerAgentImpl *agent) {
-  int script_id = script->Id();
-  DCHECK_EQ(0, wasm_translators_.count(script_id));
-  std::unique_ptr<TranslatorImpl> impl;
+  // Instantiate new TranslatorImpls via new, the base class will register them
+  // in wasm_translators_, taking ownership. This early registration is
+  // necessary since the DisassemblingTranslator constructor already registers
+  // the fake scripts, which triggers setting breakpoints.
   switch (mode_) {
     case Raw:
-      impl.reset(new TranslatorImpl::RawTranslator());
-      break;
+      new TranslatorImpl::RawTranslator(this, script);
+      return;
     case Disassemble:
-      impl.reset(new TranslatorImpl::DisassemblingTranslator(isolate_, script,
-                                                             this, agent));
-      break;
+      new TranslatorImpl::DisassemblingTranslator(isolate_, script, this,
+                                                  agent);
+      return;
   }
-  DCHECK(impl);
-  wasm_translators_.insert(std::make_pair(script_id, std::move(impl)));
+  UNREACHABLE();
 }
 
 void WasmTranslation::Clear() {
   wasm_translators_.clear();
   fake_scripts_.clear();
 }
 
 // Translation "forward" (to artificial scripts).
 bool WasmTranslation::TranslateWasmScriptLocationToProtocolLocation(
     String16 *script_id, int *line_number, int *column_number) {
@@ skipping 33 matching lines @@
   *column_number = trans_loc.column;
 
   return true;
 }
 
 void WasmTranslation::AddFakeScript(const String16 &scriptId,
                                     TranslatorImpl *translator) {
   DCHECK_EQ(0, fake_scripts_.count(scriptId));
   fake_scripts_.insert(std::make_pair(scriptId, translator));
 }