[wasm] Add more tests for interpreter breakpoints.

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 909 matching lines @@
 
 // Responsible for executing code directly.
 class ThreadImpl : public WasmInterpreter::Thread {
  public:
   ThreadImpl(Zone* zone, CodeMap* codemap, WasmModuleInstance* instance)
       : codemap_(codemap),
         instance_(instance),
         stack_(zone),
         frames_(zone),
         state_(WasmInterpreter::STOPPED),
+        break_pc_(kInvalidPc),
         trap_reason_(kTrapCount) {}
 
   virtual ~ThreadImpl() {}
 
   //==========================================================================
   // 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);
     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("  => push func#%u @%zu\n", code->function->func_index,
+    TRACE("  => PushFrame(#%u @%zu)\n", code->function->func_index,
           frames_.back().ret_pc);
   }
 
   virtual WasmInterpreter::State Run() {
     do {
+      TRACE("  => Run()\n");
       if (state_ == WasmInterpreter::STOPPED ||
           state_ == WasmInterpreter::PAUSED) {
         state_ = WasmInterpreter::RUNNING;
         Execute(frames_.back().code, frames_.back().ret_pc, kRunSteps);
       }
     } while (state_ == WasmInterpreter::STOPPED);
     return state_;
   }
 
   virtual WasmInterpreter::State Step() {
-    UNIMPLEMENTED();
-    return WasmInterpreter::STOPPED;
+    TRACE("  => Step()\n");
+    if (state_ == WasmInterpreter::STOPPED ||
+        state_ == WasmInterpreter::PAUSED) {
+      state_ = WasmInterpreter::RUNNING;
+      Execute(frames_.back().code, frames_.back().ret_pc, 1);
+    }
+    return state_;
   }
 
   virtual void Pause() { UNIMPLEMENTED(); }
 
   virtual void Reset() {
     TRACE("----- RESET -----\n");
     stack_.clear();
     frames_.clear();
     state_ = WasmInterpreter::STOPPED;
     trap_reason_ = kTrapCount;
@@ skipping 11 matching lines @@
     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_; }
+
   bool Terminated() {
     return state_ == WasmInterpreter::TRAPPED ||
            state_ == WasmInterpreter::FINISHED;
   }
 
  private:
   // Entries on the stack of functions being evaluated.
   struct Frame {
     InterpreterCode* code;
     pc_t call_pc;
     pc_t ret_pc;
     sp_t sp;
 
     // Limit of parameters.
     sp_t plimit() { return sp + code->function->sig->parameter_count(); }
     // Limit of locals.
     sp_t llimit() { return plimit() + code->locals.total_local_count; }
   };
 
   CodeMap* codemap_;
   WasmModuleInstance* instance_;
   ZoneVector<WasmVal> stack_;
   ZoneVector<Frame> frames_;
   WasmInterpreter::State state_;
+  pc_t break_pc_;
   TrapReason trap_reason_;
 
   CodeMap* codemap() { return codemap_; }
   WasmModuleInstance* instance() { return instance_; }
   const WasmModule* module() { return instance_->module; }
 
   void DoTrap(TrapReason trap, pc_t pc) {
     state_ = WasmInterpreter::TRAPPED;
     trap_reason_ = trap;
     CommitPc(pc);
@@ skipping 39 matching lines @@
     return code->locals.decls_encoded_size;
   }
 
   void CommitPc(pc_t pc) {
     if (!frames_.empty()) {
       frames_.back().ret_pc = pc;
     }
   }
 
   bool SkipBreakpoint(InterpreterCode* code, pc_t pc) {
-    // TODO(titzer): skip a breakpoint if we are resuming from it, or it
-    // is set for another thread only.
+    if (pc == break_pc_) {
+      break_pc_ = kInvalidPc;
+      return true;
+    }
     return false;
   }
 
   bool DoReturn(InterpreterCode** code, pc_t* pc, pc_t* limit, WasmVal val) {
     DCHECK_GT(frames_.size(), 0u);
     stack_.resize(frames_.back().sp);
     frames_.pop_back();
     if (frames_.size() == 0) {
       // A return from the top frame terminates the execution.
       state_ = WasmInterpreter::FINISHED;
@@ skipping 66 matching lines @@
 
       if (pc >= limit) {
         // Fell off end of code; do an implicit return.
         TRACE("@%-3zu: ImplicitReturn\n", pc);
         WasmVal val = PopArity(code->function->sig->return_count());
         if (!DoReturn(&code, &pc, &limit, val)) return;
         decoder.Reset(code->start, code->end);
         continue;
       }
 
-      const char* skip = "";
+      const char* skip = "        ";
       int len = 1;
       byte opcode = code->start[pc];
       byte orig = opcode;
       if (opcode == kInternalBreakpoint) {
+        orig = code->orig_start[pc];
         if (SkipBreakpoint(code, pc)) {
           // skip breakpoint by switching on original code.
-          orig = code->orig_start[pc];
-          skip = "[skip] ";
+          skip = "[skip]  ";
         } else {
           state_ = WasmInterpreter::PAUSED;
+          TRACE("@%-3zu: [break] %-24s:", pc,
+                WasmOpcodes::OpcodeName(static_cast<WasmOpcode>(orig)));
+          TraceValueStack();
+          TRACE("\n");
+          break_pc_ = pc;
           return CommitPc(pc);
         }
       }
 
       USE(skip);
       TRACE("@%-3zu: %s%-24s:", pc, skip,
             WasmOpcodes::OpcodeName(static_cast<WasmOpcode>(orig)));
       TraceValueStack();
       TRACE("\n");
 
@@ skipping 488 matching lines @@
                                  base::AccountingAllocator* allocator)
     : zone_(allocator),
       internals_(new (&zone_) WasmInterpreterInternals(&zone_, instance)) {}
 
 WasmInterpreter::~WasmInterpreter() {}
 
 void WasmInterpreter::Run() { internals_->threads_[0].Run(); }
 
 void WasmInterpreter::Pause() { internals_->threads_[0].Pause(); }
 
-bool WasmInterpreter::SetBreakpoint(const WasmFunction* function, int pc,
+bool WasmInterpreter::SetBreakpoint(const WasmFunction* function, pc_t pc,
                                     bool enabled) {
   InterpreterCode* code = internals_->codemap_.FindCode(function);
   if (!code) return false;
-  int size = static_cast<int>(code->end - code->start);
+  size_t size = static_cast<size_t>(code->end - code->start);
   // Check bounds for {pc}.
-  if (pc < 0 || pc >= size) return false;
+  if (pc < code->locals.decls_encoded_size || pc >= size) 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));
     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];
   }
   return prev;
 }
 
-bool WasmInterpreter::GetBreakpoint(const WasmFunction* function, int pc) {
+bool WasmInterpreter::GetBreakpoint(const WasmFunction* function, pc_t pc) {
   InterpreterCode* code = internals_->codemap_.FindCode(function);
   if (!code) return false;
-  int size = static_cast<int>(code->end - code->start);
+  size_t size = static_cast<size_t>(code->end - code->start);
   // Check bounds for {pc}.
-  if (pc < 0 || pc >= size) return false;
+  if (pc < code->locals.decls_encoded_size || pc >= size) 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() {
@@ skipping 53 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