[inspector] [wasm] Implement GetPossibleBreakpoints

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 84 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 (std::get<1>(entry) < loc->line ||
           (std::get<1>(entry) == loc->line &&
            std::get<2>(entry) <= 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 (std::get<1>((*reverse_table)[left]) == loc->line &&
         std::get<2>((*reverse_table)[left]) == loc->column) {
       found_byte_offset = std::get<0>((*reverse_table)[left]);
     } else if (left + 1 < reverse_table->size() &&
                std::get<1>((*reverse_table)[left + 1]) == loc->line) {
       found_byte_offset = std::get<0>((*reverse_table)[left + 1]);
+    } else if (left == reverse_table->size() - 1 &&
+               std::get<1>((*reverse_table)[left]) == 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 GetScriptName(v8::Isolate *isolate) {
     return toProtocolString(script_.Get(isolate)->Name().ToLocalChecked());
   }
 
@@ skipping 22 matching lines @@
     v8::Local<DebugInterface::WasmScript> script = script_.Get(isolate);
     // TODO(clemensh): Generate disassembly lazily when queried by the frontend.
     std::pair<std::string, OffsetTable> disassembly =
         script->DisassembleFunction(func_idx);
 
     DCHECK_EQ(0, offset_tables_.count(func_idx));
     offset_tables_.insert(
         std::make_pair(func_idx, std::move(disassembly.second)));
     String16 source(disassembly.first.data(), disassembly.first.length());
     std::unique_ptr<V8DebuggerScript> fake_script =
-        V8DebuggerScript::CreateWasm(isolate, script, fake_script_id,
-                                     std::move(fake_script_url), source);
+        V8DebuggerScript::CreateWasm(isolate, script, translation,
+                                     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 111 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));
 }