[wasm] Implement GetPossibleBreakpoints

test/cctest/wasm/wasm-run-utils.h

 // 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <setjmp.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ skipping 248 matching lines @@
       int table_size = static_cast<int>(table.values.size());
       for (int j = 0; j < table_size; j++) {
         WasmFunction& function = module_.functions[table.values[j]];
         array->set(j, Smi::FromInt(table.map.Find(function.sig)));
         array->set(j + table_size,
                    *instance->function_code[function.func_index]);
       }
     }
   }
 
+  uint32_t AddBytes(Vector<const byte> bytes) {
+    Handle<SeqOneByteString> old_bytes =
+        instance_object_->get_compiled_module()->module_bytes();
+    uint32_t old_size = static_cast<uint32_t>(old_bytes->length());
+    ScopedVector<byte> new_bytes(old_size + bytes.length());
+    memcpy(new_bytes.start(), old_bytes->GetChars(), old_size);
+    memcpy(new_bytes.start() + old_size, bytes.start(), bytes.length());
+    Handle<SeqOneByteString> new_bytes_str = Handle<SeqOneByteString>::cast(
+        isolate_->factory()->NewStringFromOneByte(new_bytes).ToHandleChecked());
+    instance_object_->get_compiled_module()->set_module_bytes(new_bytes_str);
+    return old_size;
+  }
+
   WasmFunction* GetFunctionAt(int index) { return &module_.functions[index]; }
 
   WasmInterpreter* interpreter() { return interpreter_; }
   WasmExecutionMode execution_mode() { return execution_mode_; }
   Isolate* isolate() { return isolate_; }
   Handle<WasmInstanceObject> instance_object() { return instance_object_; }
 
  private:
   WasmExecutionMode execution_mode_;
   WasmModule module_;
   WasmInstance instance_;
   Isolate* isolate_;
   uint32_t global_offset;
   V8_ALIGNED(8) byte global_data[kMaxGlobalsSize];  // preallocated global data.
   WasmInterpreter* interpreter_;
   Handle<WasmInstanceObject> instance_object_;
 
   const WasmGlobal* AddGlobal(LocalType type) {
     byte size = WasmOpcodes::MemSize(WasmOpcodes::MachineTypeFor(type));
     global_offset = (global_offset + size - 1) & ~(size - 1);  // align
     module_.globals.push_back(
         {type, true, WasmInitExpr(), global_offset, false, false});
     global_offset += size;
     // limit number of globals.
     CHECK_LT(global_offset, kMaxGlobalsSize);
     return &module->globals.back();
   }
 
-  uint32_t AddBytes(Vector<const byte> bytes) {
-    Handle<SeqOneByteString> old_bytes =
-        instance_object_->get_compiled_module()->module_bytes();
-    uint32_t old_size = static_cast<uint32_t>(old_bytes->length());
-    ScopedVector<byte> new_bytes(old_size + bytes.length());
-    memcpy(new_bytes.start(), old_bytes->GetChars(), old_size);
-    memcpy(new_bytes.start() + old_size, bytes.start(), bytes.length());
-    Handle<SeqOneByteString> new_bytes_str = Handle<SeqOneByteString>::cast(
-        isolate_->factory()->NewStringFromOneByte(new_bytes).ToHandleChecked());
-    instance_object_->get_compiled_module()->set_module_bytes(new_bytes_str);
-    return old_size;
-  }
-
   Handle<WasmInstanceObject> InitInstanceObject() {
     Handle<Managed<wasm::WasmModule>> module_wrapper =
         Managed<wasm::WasmModule>::New(isolate_, &module_, false);
     Handle<WasmCompiledModule> compiled_module =
         WasmCompiledModule::New(isolate_, module_wrapper);
     // Minimally initialize the compiled module such that IsWasmCompiledModule
     // passes.
     // If tests need more (correct) information, add it later.
     compiled_module->set_min_mem_pages(0);
     compiled_module->set_max_mem_pages(Smi::kMaxValue);
@@ skipping 171 matching lines @@
   CallDescriptor* descriptor() {
     if (descriptor_ == nullptr) {
       descriptor_ = testing_module_->GetWasmCallDescriptor(zone(), sig);
     }
     return descriptor_;
   }
   uint32_t function_index() { return function_->func_index; }
 
   void Build(const byte* start, const byte* end) {
     local_decls.Prepend(zone(), &start, &end);
+
+    CHECK_GE(kMaxInt, end - start);
+    int len = static_cast<int>(end - start);
+    function_->code_start_offset =
+        testing_module_->AddBytes(Vector<const byte>(start, len));
+    function_->code_end_offset = function_->code_start_offset + len;
+
     if (interpreter_) {
       // Add the code to the interpreter.
       CHECK(interpreter_->SetFunctionCodeForTesting(function_, start, end));
       return;
     }
 
     // Build the TurboFan graph.
     TestBuildingGraph(zone(), &jsgraph, testing_module_, sig,
                       &source_position_table_, start, end);
     Handle<Code> code = Compile();
@@ skipping 272 matching lines @@
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 #define WASM_EXEC_COMPILED_TEST(name)                                \
   void RunWasm_##name(WasmExecutionMode execution_mode);             \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 }  // namespace
 
 #endif