[wasm] prototype for breakpoint support.

src/wasm/wasm-interpreter.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/wasm/wasm-interpreter.h"
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/wasm-external-refs.h"
 #include "src/wasm/wasm-module.h"
 
@@ skipping 833 matching lines @@
     auto result = map_.find(from);
     if (result == map_.end()) {
       V8_Fatal(__FILE__, __LINE__, "no control target for pc %zu", from);
     }
     return result->second;
   }
 };
 
 // Code and metadata needed to execute a function.
 struct InterpreterCode {
-  const WasmFunction* function;  // wasm function
-  AstLocalDecls locals;          // local declarations
-  const byte* orig_start;        // start of original code
-  const byte* orig_end;          // end of original code
-  byte* start;                   // start of (maybe altered) code
-  byte* end;                     // end of (maybe altered) code
-  ControlTransfers* targets;     // helper for control flow.
+  const WasmFunction* function;    // wasm function
+  AstLocalDecls locals;            // local declarations
+  const byte* orig_start;          // start of original code
+  const byte* orig_end;            // end of original code
+  byte* start;                     // start of (maybe altered) code
+  byte* end;                       // end of (maybe altered) code
+  ControlTransfers* targets;       // helper for control flow.
+  BoolVector instruction_offsets;  // valid instruction offsets
 
   const byte* at(pc_t pc) { return start + pc; }
 };
 
+namespace {
+
+pc_t FindPreviousInstruction(InterpreterCode* code, pc_t pc) {
+  BoolVector& offsets = code->instruction_offsets;
+  DCHECK(offsets[pc]);
+  while (!offsets[--pc]) DCHECK_LE(0U, pc);
+  return pc;
+}
+
+}  // namespace
+
 // The main storage for interpreter code. It maps {WasmFunction} to the
 // metadata needed to execute each function.
 class CodeMap {
  public:
   Zone* zone_;
   const WasmModule* module_;
   ZoneVector<InterpreterCode> interpreter_code_;
 
   CodeMap(const WasmModule* module, Zone* zone)
       : zone_(zone), module_(module), interpreter_code_(zone) {
@@ skipping 28 matching lines @@
     return GetCode(index);
   }
 
   InterpreterCode* Preprocess(InterpreterCode* code) {
     if (code->targets == nullptr && code->start) {
       // Compute the control targets map and the local declarations.
       CHECK(DecodeLocalDecls(code->locals, code->start, code->end));
       code->targets =
           new (zone_) ControlTransfers(zone_, code->locals.decls_encoded_size,
                                        code->orig_start, code->orig_end);
+
+      // Initialize the instruction_offsets bitset.
+      DCHECK(code->instruction_offsets.empty());
+      code->instruction_offsets.resize(code->end - code->start);
+      const byte* pc = code->orig_start + code->locals.decls_encoded_size;
+      while (pc < code->orig_end) {
+        code->instruction_offsets[pc - code->orig_start] = 1;
+        pc += OpcodeLength(pc, code->orig_end);
+      }
     }
     return code;
   }
 
   int AddFunction(const WasmFunction* function, const byte* code_start,
                   const byte* code_end) {
-    InterpreterCode code = {
-        function, AstLocalDecls(zone_),          code_start,
-        code_end, const_cast<byte*>(code_start), const_cast<byte*>(code_end),
-        nullptr};
+    InterpreterCode code = {function,
+                            AstLocalDecls(zone_),
+                            code_start,
+                            code_end,
+                            const_cast<byte*>(code_start),
+                            const_cast<byte*>(code_end),
+                            nullptr,
+                            BoolVector(zone_)};
 
     DCHECK_EQ(interpreter_code_.size(), function->func_index);
     interpreter_code_.push_back(code);
     return static_cast<int>(interpreter_code_.size()) - 1;
   }
 
   bool SetFunctionCode(const WasmFunction* function, const byte* start,
                        const byte* end) {
     InterpreterCode* code = FindCode(function);
     if (code == nullptr) return false;
@@ skipping 23 matching lines @@
 
   //==========================================================================
   // Implementation of public interface for WasmInterpreter::Thread.
   //==========================================================================
 
   virtual WasmInterpreter::State state() { return state_; }
 
   virtual void PushFrame(const WasmFunction* function, WasmVal* args) {
     InterpreterCode* code = codemap()->FindCode(function);
     CHECK_NOT_NULL(code);
+    codemap()->Preprocess(code);
     frames_.push_back({code, 0, 0, stack_.size()});
     for (size_t i = 0; i < function->sig->parameter_count(); ++i) {
       stack_.push_back(args[i]);
     }
     frames_.back().ret_pc = InitLocals(code);
     TRACE("  => PushFrame(#%u @%zu)\n", code->function->func_index,
           frames_.back().ret_pc);
   }
 
   virtual WasmInterpreter::State Run() {
@@ skipping 23 matching lines @@
   virtual void Reset() {
     TRACE("----- RESET -----\n");
     stack_.clear();
     frames_.clear();
     state_ = WasmInterpreter::STOPPED;
     trap_reason_ = kTrapCount;
   }
 
   virtual int GetFrameCount() { return static_cast<int>(frames_.size()); }
 
-  virtual const WasmFrame* GetFrame(int index) {
+  virtual const WasmInterpreterFrame* GetFrame(int index) {
+    Frame* frame = &frames_[index];
+    DCHECK_LE(frame->sp, stack_.size());
+    DCHECK_LE(stack_.size(), static_cast<size_t>(kMaxInt));
+    // For all but the top frame, the pc is one behine the call instruction.
+    bool top_frame = static_cast<size_t>(index) == frames_.size() - 1;
+    pc_t pc = top_frame ? frame->ret_pc
+                        : FindPreviousInstruction(frame->code, frame->ret_pc);
+    return new WasmInterpreterFrame(frame->code->function,  // wasm function
+                                    static_cast<int>(pc),   // pc
+                                    static_cast<int>(frame->sp),       // fp
+                                    static_cast<int>(stack_.size()));  // sp
+  }
+
+  virtual WasmInterpreterFrame* GetMutableFrame(int index) {
     UNIMPLEMENTED();
     return nullptr;
   }
-
-  virtual WasmFrame* GetMutableFrame(int index) {
-    UNIMPLEMENTED();
-    return nullptr;
-  }
 
   virtual WasmVal GetReturnValue() {
     if (state_ == WasmInterpreter::TRAPPED) return WasmVal(0xdeadbeef);
     CHECK_EQ(WasmInterpreter::FINISHED, state_);
     CHECK_EQ(1, stack_.size());
     return stack_[0];
   }
 
   virtual pc_t GetBreakpointPc() { return break_pc_; }
 
@@ skipping 617 matching lines @@
 
   void TraceStack(const char* phase, pc_t pc) {
     if (FLAG_trace_wasm_interpreter) {
       PrintF("%s @%zu", phase, pc);
       UNIMPLEMENTED();
       PrintF("\n");
     }
   }
 
   void TraceValueStack() {
+#if DEBUG
     Frame* top = frames_.size() > 0 ? &frames_.back() : nullptr;
     sp_t sp = top ? top->sp : 0;
     sp_t plimit = top ? top->plimit() : 0;
     sp_t llimit = top ? top->llimit() : 0;
     if (FLAG_trace_wasm_interpreter) {
       for (size_t i = sp; i < stack_.size(); ++i) {
         if (i < plimit)
           PrintF(" p%zu:", i);
         else if (i < llimit)
           PrintF(" l%zu:", i);
@@ skipping 15 matching lines @@
             break;
           case kAstStmt:
             PrintF("void");
             break;
           default:
             UNREACHABLE();
             break;
         }
       }
     }
+#endif
   }
 };
 
 //============================================================================
 // The implementation details of the interpreter.
 //============================================================================
 class WasmInterpreterInternals : public ZoneObject {
  public:
   WasmModuleInstance* instance_;
   CodeMap codemap_;
   ZoneVector<ThreadImpl*> threads_;
 
   WasmInterpreterInternals(Zone* zone, WasmModuleInstance* instance)
       : instance_(instance),
         codemap_(instance_ ? instance_->module : nullptr, zone),
         threads_(zone) {
     threads_.push_back(new ThreadImpl(zone, &codemap_, instance));
   }
 
   void Delete() {
     // TODO(titzer): CFI doesn't like threads in the ZoneVector.
     for (auto t : threads_) delete t;
     threads_.resize(0);
   }
 };
 
 //============================================================================
 // Implementation of the public interface of the interpreter.
 //============================================================================
-WasmInterpreter::WasmInterpreter(WasmModuleInstance* instance,
-                                 base::AccountingAllocator* allocator)
-    : zone_(allocator),
-      internals_(new (&zone_) WasmInterpreterInternals(&zone_, instance)) {}
+WasmInterpreter::WasmInterpreter(WasmModuleInstance* instance, Zone* zone)
+    : zone_(zone),
+      internals_(new (zone_) WasmInterpreterInternals(zone_, instance)) {}
 
 WasmInterpreter::~WasmInterpreter() { internals_->Delete(); }
 
 void WasmInterpreter::Run() { internals_->threads_[0]->Run(); }
 
 void WasmInterpreter::Pause() { internals_->threads_[0]->Pause(); }
 
-bool WasmInterpreter::SetBreakpoint(const WasmFunction* function, pc_t pc,
+bool WasmInterpreter::SetBreakpoint(uint32_t function_index, pc_t pc,
                                     bool enabled) {
-  InterpreterCode* code = internals_->codemap_.FindCode(function);
-  if (!code) return false;
+  auto interpreter_code = internals_->codemap_.interpreter_code_;
+  if (function_index > interpreter_code.size()) return false;
+  InterpreterCode* code = internals_->codemap_.GetCode(function_index);
   size_t size = static_cast<size_t>(code->end - code->start);
   // Check bounds for {pc}.
-  if (pc < code->locals.decls_encoded_size || pc >= size) return false;
+  if (pc >= size) return false;
+  // Check that it's a valid instruction offset.
+  DCHECK_LE(pc, code->instruction_offsets.size());
+  if (!code->instruction_offsets[pc]) return false;
   // Make a copy of the code before enabling a breakpoint.
   if (enabled && code->orig_start == code->start) {
-    code->start = reinterpret_cast<byte*>(zone_.New(size));
+    code->start = reinterpret_cast<byte*>(zone_->New(size));
     memcpy(code->start, code->orig_start, size);
     code->end = code->start + size;
   }
   bool prev = code->start[pc] == kInternalBreakpoint;
-  if (enabled) {
-    code->start[pc] = kInternalBreakpoint;
-  } else {
-    code->start[pc] = code->orig_start[pc];
-  }
+  code->start[pc] = enabled ? kInternalBreakpoint : code->orig_start[pc];
   return prev;
 }
 
-bool WasmInterpreter::GetBreakpoint(const WasmFunction* function, pc_t pc) {
-  InterpreterCode* code = internals_->codemap_.FindCode(function);
-  if (!code) return false;
+bool WasmInterpreter::GetBreakpoint(uint32_t function_index, pc_t pc) {
+  auto interpreter_code = internals_->codemap_.interpreter_code_;
+  if (function_index > interpreter_code.size()) return false;
+  InterpreterCode* code = internals_->codemap_.GetCode(function_index);
   size_t size = static_cast<size_t>(code->end - code->start);
   // Check bounds for {pc}.
-  if (pc < code->locals.decls_encoded_size || pc >= size) return false;
+  if (pc >= size) return false;
+  // Check that it's a valid instruction offset.
+  DCHECK_LE(pc, code->instruction_offsets.size());
+  if (!code->instruction_offsets[pc]) return false;
   // Check if a breakpoint is present at that place in the code.
   return code->start[pc] == kInternalBreakpoint;
 }
 
 bool WasmInterpreter::SetTracing(const WasmFunction* function, bool enabled) {
   UNIMPLEMENTED();
   return false;
 }
 
 int WasmInterpreter::GetThreadCount() {
   return 1;  // only one thread for now.
 }
 
 WasmInterpreter::Thread* WasmInterpreter::GetThread(int id) {
   CHECK_EQ(0, id);  // only one thread for now.
   return internals_->threads_[id];
 }
 
-WasmVal WasmInterpreter::GetLocalVal(const WasmFrame* frame, int index) {
+WasmVal WasmInterpreter::GetLocalVal(const WasmInterpreterFrame* frame,
+                                     int index) {
   CHECK_GE(index, 0);
   UNIMPLEMENTED();
+  USE(frame->fp_);
+  USE(frame->sp_);
+  WasmVal none;
+  none.type = kAstStmt;
+  return none;
+}
+
+WasmVal WasmInterpreter::GetExprVal(const WasmInterpreterFrame* frame, int pc) {
+  UNIMPLEMENTED();
   WasmVal none;
   none.type = kAstStmt;
   return none;
 }
 
-WasmVal WasmInterpreter::GetExprVal(const WasmFrame* frame, int pc) {
-  UNIMPLEMENTED();
-  WasmVal none;
-  none.type = kAstStmt;
-  return none;
-}
-
-void WasmInterpreter::SetLocalVal(WasmFrame* frame, int index, WasmVal val) {
+void WasmInterpreter::SetLocalVal(WasmInterpreterFrame* frame, int index,
+                                  WasmVal val) {
   UNIMPLEMENTED();
 }
 
-void WasmInterpreter::SetExprVal(WasmFrame* frame, int pc, WasmVal val) {
+void WasmInterpreter::SetExprVal(WasmInterpreterFrame* frame, int pc,
+                                 WasmVal val) {
   UNIMPLEMENTED();
 }
 
 size_t WasmInterpreter::GetMemorySize() {
   return internals_->instance_->mem_size;
 }
 
 WasmVal WasmInterpreter::ReadMemory(size_t offset) {
   UNIMPLEMENTED();
   return WasmVal();
@@ skipping 15 matching lines @@
 
 ControlTransferMap WasmInterpreter::ComputeControlTransfersForTesting(
     Zone* zone, const byte* start, const byte* end) {
   ControlTransfers targets(zone, 0, start, end);
   return targets.map_;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8