[wasm] Use pimpl idiom for interpreter thread implementation

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/utils.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/function-body-decoder.h"
 #include "src/wasm/wasm-external-refs.h"
@@ skipping 901 matching lines @@
     code->orig_start = start;
     code->orig_end = end;
     code->start = const_cast<byte*>(start);
     code->end = const_cast<byte*>(end);
     Preprocess(code);
     return true;
   }
 };
 
 // Responsible for executing code directly.
-class ThreadImpl : public WasmInterpreter::Thread {
+class WasmInterpreter::ThreadImpl : public ZoneObject {
  public:
   ThreadImpl(Zone* zone, CodeMap* codemap, WasmInstance* instance)
       : codemap_(codemap),
         instance_(instance),
         stack_(zone),
         frames_(zone),
         blocks_(zone),
         state_(WasmInterpreter::STOPPED),
         break_pc_(kInvalidPc),
         trap_reason_(kTrapCount),
         possible_nondeterminism_(false) {}
 
-  virtual ~ThreadImpl() {}
+  ~ThreadImpl() {}
 
   //==========================================================================
   // Implementation of public interface for WasmInterpreter::Thread.
   //==========================================================================
 
-  virtual WasmInterpreter::State state() { return state_; }
+  WasmInterpreter::State state() { return state_; }
 
-  virtual void PushFrame(const WasmFunction* function, WasmVal* args) {
+  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);
     blocks_.push_back(
         {0, stack_.size(), frames_.size(),
          static_cast<uint32_t>(code->function->sig->return_count())});
     TRACE("  => PushFrame(#%u @%zu)\n", code->function->func_index,
           frames_.back().ret_pc);
   }
 
-  virtual WasmInterpreter::State Run() {
+  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() {
+  WasmInterpreter::State Step() {
     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(); }
+  void Pause() { UNIMPLEMENTED(); }
 
-  virtual void Reset() {
+  void Reset() {
     TRACE("----- RESET -----\n");
     stack_.clear();
     frames_.clear();
     state_ = WasmInterpreter::STOPPED;
     trap_reason_ = kTrapCount;
     possible_nondeterminism_ = false;
   }
 
-  virtual int GetFrameCount() { return static_cast<int>(frames_.size()); }
+  int GetFrameCount() { return static_cast<int>(frames_.size()); }
 
-  virtual const WasmFrame* GetFrame(int index) {
+  const WasmFrame* GetFrame(int index) {
     UNIMPLEMENTED();
     return nullptr;
   }
 
-  virtual WasmFrame* GetMutableFrame(int index) {
+  WasmFrame* GetMutableFrame(int index) {
     UNIMPLEMENTED();
     return nullptr;
   }
 
-  virtual WasmVal GetReturnValue(int index) {
+  WasmVal GetReturnValue(int index) {
     if (state_ == WasmInterpreter::TRAPPED) return WasmVal(0xdeadbeef);
     CHECK_EQ(WasmInterpreter::FINISHED, state_);
     CHECK_LT(static_cast<size_t>(index), stack_.size());
     return stack_[index];
   }
 
-  virtual pc_t GetBreakpointPc() { return break_pc_; }
+  pc_t GetBreakpointPc() { return break_pc_; }
 
-  virtual bool PossibleNondeterminism() { return possible_nondeterminism_; }
-
-  bool Terminated() {
-    return state_ == WasmInterpreter::TRAPPED ||
-           state_ == WasmInterpreter::FINISHED;
-  }
+  bool PossibleNondeterminism() { return possible_nondeterminism_; }
 
  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.
@@ skipping 669 matching lines @@
           default:
             UNREACHABLE();
             break;
         }
       }
     }
   }
 };
 
 //============================================================================
+// Forwarding functions of WasmInterpreter::Thread (pimpl idiom).
+//============================================================================
+WasmInterpreter::Thread::Thread(ThreadImpl* impl) : impl_(impl) {}
+WasmInterpreter::State WasmInterpreter::Thread::state() {
+  return impl_->state();
+}
+void WasmInterpreter::Thread::PushFrame(const WasmFunction* function,
+                                        WasmVal* args) {
+  return impl_->PushFrame(function, args);
+}
+WasmInterpreter::State WasmInterpreter::Thread::Run() { return impl_->Run(); }
+WasmInterpreter::State WasmInterpreter::Thread::Step() { return impl_->Step(); }
+void WasmInterpreter::Thread::Pause() { return impl_->Pause(); }
+void WasmInterpreter::Thread::Reset() { return impl_->Reset(); }
+pc_t WasmInterpreter::Thread::GetBreakpointPc() {
+  return impl_->GetBreakpointPc();
+}
+int WasmInterpreter::Thread::GetFrameCount() { return impl_->GetFrameCount(); }
+const WasmFrame* WasmInterpreter::Thread::GetFrame(int index) {
+  return impl_->GetFrame(index);
+}
+WasmFrame* WasmInterpreter::Thread::GetMutableFrame(int index) {
+  return impl_->GetMutableFrame(index);
+}
+WasmVal WasmInterpreter::Thread::GetReturnValue(int index) {
+  return impl_->GetReturnValue(index);
+}
+bool WasmInterpreter::Thread::PossibleNondeterminism() {
+  return impl_->PossibleNondeterminism();
+}
+
+//============================================================================
 // The implementation details of the interpreter.
 //============================================================================
 class WasmInterpreterInternals : public ZoneObject {
  public:
   WasmInstance* instance_;
   // Create a copy of the module bytes for the interpreter, since the passed
   // pointer might be invalidated after constructing the interpreter.
   const ZoneVector<uint8_t> module_bytes_;
   CodeMap codemap_;
-  ZoneVector<ThreadImpl*> threads_;
+  ZoneVector<WasmInterpreter::Thread> threads_;
 
   WasmInterpreterInternals(Zone* zone, const ModuleBytesEnv& env)
       : instance_(env.instance),
         module_bytes_(env.module_bytes.start(), env.module_bytes.end(), zone),
         codemap_(env.instance ? env.instance->module : nullptr,
                  module_bytes_.data(), zone),
         threads_(zone) {
-    threads_.push_back(new ThreadImpl(zone, &codemap_, env.instance));
+    threads_.push_back(WasmInterpreter::Thread(
+        new (zone) WasmInterpreter::ThreadImpl(zone, &codemap_, env.instance)));
   }
 
-  void Delete() {
-    // TODO(titzer): CFI doesn't like threads in the ZoneVector.
-    for (auto t : threads_) delete t;
-    threads_.resize(0);
-  }
+  void Delete() { threads_.clear(); }
 };
 
 //============================================================================
 // Implementation of the public interface of the interpreter.
 //============================================================================
 WasmInterpreter::WasmInterpreter(const ModuleBytesEnv& env,
                                  AccountingAllocator* allocator)
     : zone_(allocator, ZONE_NAME),
       internals_(new (&zone_) WasmInterpreterInternals(&zone_, env)) {}
 
 WasmInterpreter::~WasmInterpreter() { internals_->Delete(); }
 
-void WasmInterpreter::Run() { internals_->threads_[0]->Run(); }
+void WasmInterpreter::Run() { internals_->threads_[0].Run(); }
 
-void WasmInterpreter::Pause() { internals_->threads_[0]->Pause(); }
+void WasmInterpreter::Pause() { internals_->threads_[0].Pause(); }
 
 bool WasmInterpreter::SetBreakpoint(const WasmFunction* function, pc_t pc,
                                     bool enabled) {
   InterpreterCode* code = internals_->codemap_.FindCode(function);
   if (!code) return false;
   size_t size = static_cast<size_t>(code->end - code->start);
   // Check bounds for {pc}.
   if (pc < code->locals.encoded_size || pc >= size) return false;
   // Make a copy of the code before enabling a breakpoint.
   if (enabled && code->orig_start == code->start) {
@@ skipping 24 matching lines @@
   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];
+  return &internals_->threads_[id];
 }
 
 WasmVal WasmInterpreter::GetLocalVal(const WasmFrame* frame, int index) {
   CHECK_GE(index, 0);
   UNIMPLEMENTED();
   WasmVal none;
   none.type = kWasmStmt;
   return none;
 }
 
@@ skipping 37 matching lines @@
 
 ControlTransferMap WasmInterpreter::ComputeControlTransfersForTesting(
     Zone* zone, const byte* start, const byte* end) {
   ControlTransfers targets(zone, nullptr, start, end);
   return targets.map_;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8