[wasm] Rename WasmModuleInstance to WasmInstance.

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/ast-decoder.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/wasm-external-refs.h"
@@ skipping 637 matching lines @@
 
 static inline int32_t ExecuteI32ReinterpretF32(float a, TrapReason* trap) {
   return bit_cast<int32_t>(a);
 }
 
 static inline int64_t ExecuteI64ReinterpretF64(double a, TrapReason* trap) {
   return bit_cast<int64_t>(a);
 }
 
 static inline int32_t ExecuteGrowMemory(uint32_t delta_pages,
-                                        WasmModuleInstance* instance) {
+                                        WasmInstance* instance) {
   // TODO(ahaas): Move memory allocation to wasm-module.cc for better
   // encapsulation.
   if (delta_pages > wasm::WasmModule::kMaxMemPages) {
     return -1;
   }
   uint32_t old_size = instance->mem_size;
   uint32_t new_size;
   byte* new_mem_start;
   if (instance->mem_size == 0) {
     if (delta_pages > wasm::WasmModule::kMaxMemPages) {
@@ skipping 291 matching lines @@
     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 {
  public:
-  ThreadImpl(Zone* zone, CodeMap* codemap, WasmModuleInstance* instance)
+  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) {}
 
   virtual ~ThreadImpl() {}
@@ skipping 92 matching lines @@
   };
 
   struct Block {
     pc_t pc;
     sp_t sp;
     size_t fp;
     unsigned arity;
   };
 
   CodeMap* codemap_;
-  WasmModuleInstance* instance_;
+  WasmInstance* instance_;
   ZoneVector<WasmVal> stack_;
   ZoneVector<Frame> frames_;
   ZoneVector<Block> blocks_;
   WasmInterpreter::State state_;
   pc_t break_pc_;
   TrapReason trap_reason_;
 
   CodeMap* codemap() { return codemap_; }
-  WasmModuleInstance* instance() { return instance_; }
+  WasmInstance* instance() { return instance_; }
   const WasmModule* module() { return instance_->module; }
 
   void DoTrap(TrapReason trap, pc_t pc) {
     state_ = WasmInterpreter::TRAPPED;
     trap_reason_ = trap;
     CommitPc(pc);
   }
 
   // Push a frame with arguments already on the stack.
   void PushFrame(InterpreterCode* code, pc_t call_pc, pc_t ret_pc) {
@@ skipping 608 matching lines @@
       }
     }
   }
 };
 
 //============================================================================
 // The implementation details of the interpreter.
 //============================================================================
 class WasmInterpreterInternals : public ZoneObject {
  public:
-  WasmModuleInstance* instance_;
+  WasmInstance* instance_;
   CodeMap codemap_;
   ZoneVector<ThreadImpl*> threads_;
 
-  WasmInterpreterInternals(Zone* zone, WasmModuleInstance* instance)
+  WasmInterpreterInternals(Zone* zone, WasmInstance* 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,
+WasmInterpreter::WasmInterpreter(WasmInstance* instance,
                                  AccountingAllocator* allocator)
     : zone_(allocator),
       internals_(new (&zone_) WasmInterpreterInternals(&zone_, instance)) {}
 
 WasmInterpreter::~WasmInterpreter() { internals_->Delete(); }
 
 void WasmInterpreter::Run() { internals_->threads_[0]->Run(); }
 
 void WasmInterpreter::Pause() { internals_->threads_[0]->Pause(); }
 
@@ skipping 91 matching lines @@
 
 ControlTransferMap WasmInterpreter::ComputeControlTransfersForTesting(
     Zone* zone, const byte* start, const byte* end) {
   ControlTransfers targets(zone, nullptr, nullptr, start, end);
   return targets.map_;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8