[Interpreter] Instance (#7343)

Adds an instance struct to encapsulate the runtime representation of a
module, as seen in the
[spec](https://webassembly.github.io/spec/core/exec/runtime.html#module-instances).
Also adds an instantiate method, which runs the initialization
expressions of globals in the module.

Author: ashleynh

src/interpreter/interpreter.cpp

@@ -47,11 +47,14 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   ExpressionInterpreter(Interpreter& parent) : parent(parent) {}
 
   WasmStore& store() { return InterpreterImpl::getStore(parent); }
+  Frame& frame() { return store().callStack.back(); }
+  Instance& instance() { return frame().instance; }
+
   void push(Literal val) { store().push(val); }
   Literal pop() { return store().pop(); }
 
   Flow visitNop(Nop* curr) { WASM_UNREACHABLE("TODO"); }
-  Flow visitBlock(Block* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitBlock(Block* curr) { return {}; }
   Flow visitIf(If* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitLoop(Loop* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitBreak(Break* curr) { WASM_UNREACHABLE("TODO"); }
@@ -60,8 +63,14 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   Flow visitCallIndirect(CallIndirect* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitLocalGet(LocalGet* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitLocalSet(LocalSet* curr) { WASM_UNREACHABLE("TODO"); }
-  Flow visitGlobalGet(GlobalGet* curr) { WASM_UNREACHABLE("TODO"); }
-  Flow visitGlobalSet(GlobalSet* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitGlobalGet(GlobalGet* curr) {
+    push(instance().globalValues[curr->name]);
+    return {};
+  }
+  Flow visitGlobalSet(GlobalSet* curr) {
+    instance().globalValues[curr->name] = pop();
+    return {};
+  }
   Flow visitLoad(Load* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStore(Store* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitAtomicRMW(AtomicRMW* curr) { WASM_UNREACHABLE("TODO"); }
@@ -272,13 +281,33 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
 
 } // anonymous namespace
 
-std::vector<Literal> Interpreter::run(Expression* root) {
-  // Create a fresh store and execution frame, then run the expression to
-  // completion.
-  store = WasmStore();
-  store.callStack.emplace_back();
-  store.callStack.back().exprs = ExpressionIterator(root);
+Result<> Interpreter::addInstance(std::shared_ptr<Module> wasm) {
+  return instantiate(store.instances.emplace_back(wasm));
+}
+
+Result<> Interpreter::instantiate(Instance& instance) {
+  for (auto& global : instance.wasm->globals) {
+    store.callStack.emplace_back(instance, ExpressionIterator(global->init));
+    auto results = run();
+    assert(results.size() == 1);
+    instance.globalValues[global->name] = results[0];
+  }
+  return Ok{};
+}
+
+// This is a temporary convenience while stil using gTests to validate this
+// interpreter. Once spec tests can run, this shall be deleted.
+std::vector<Literal> Interpreter::runTest(Expression* root) {
+  static std::shared_ptr<wasm::Module> dummyModule = std::make_shared<Module>();
+  if (store.instances.empty()) {
+    auto result = addInstance(dummyModule);
+  }
+  store.callStack.emplace_back(store.instances.back(),
+                               ExpressionIterator(root));
+  return run();
+}
 
+std::vector<Literal> Interpreter::run() {
   ExpressionInterpreter interpreter(*this);
   while (auto& it = store.callStack.back().exprs) {
     if (auto flow = interpreter.visit(*it)) {
@@ -288,7 +317,9 @@ std::vector<Literal> Interpreter::run(Expression* root) {
     }
   }
 
-  return store.callStack.back().valueStack;
+  auto valueStack = store.callStack.back().valueStack;
+  store.callStack.pop_back();
+  return valueStack;
 }
 
 } // namespace wasm

src/interpreter/interpreter.h

@@ -18,18 +18,24 @@
 #define interpreter_interpreter_h
 
 #include "store.h"
+#include "support/result.h"
 
 namespace wasm {
 
 class Interpreter {
 public:
   // TODO: Methods to instantiate modules.
   // TODO: Methods to run exported functions.
-  std::vector<Literal> run(Expression* root);
+
+  Result<> addInstance(std::shared_ptr<Module> wasm);
+  std::vector<Literal> runTest(Expression* root);
+  std::vector<Literal> run();
 
 private:
   interpreter::WasmStore store;
   friend class InterpreterImpl;
+
+  Result<> instantiate(interpreter::Instance& instance);
 };
 
 } // namespace wasm

src/interpreter/store.h

@@ -22,18 +22,28 @@
 
 #include "expression-iterator.h"
 #include "literal.h"
+#include "support/result.h"
 
 namespace wasm::interpreter {
 
+// Contains the runtime representation of an instance of a Wasm module.
+struct Instance {
+  std::shared_ptr<Module> wasm;
+  std::unordered_map<Name, Literal> globalValues;
+
+  Instance(std::shared_ptr<Module> wasm) : wasm(std::move(wasm)){};
+};
+
 // A frame of execution for a function call.
 struct Frame {
-  // TODO: Reference to current instance to find referenced functions, globals,
-  // tables, memories, etc.
-
+  Instance& instance;
   std::vector<Literal> locals;
   std::vector<Literal> valueStack;
   ExpressionIterator exprs;
 
+  Frame(Instance& instance, ExpressionIterator&& exprs)
+    : instance(instance), exprs(std::move(exprs)){};
+
   // TODO: Map loops to ExpressionIterators so we can branch backwards.
 
   // Helpers to push and pop the current value stack.
@@ -55,6 +65,7 @@ struct WasmStore {
   // TODO: Storage for memories, tables, globals, heap objects, etc.
   // TODO: Map instances and import names to other instances to find imports.
   std::vector<Frame> callStack;
+  std::vector<Instance> instances;
 
   Frame& getFrame() {
     assert(!callStack.empty());