Add importing logic

Author: stevenfontanella

src/ir/import-utils.h

@@ -18,6 +18,7 @@
 #define wasm_ir_import_h
 
 #include "ir/import-names.h"
+#include "ir/runtime-memory.h"
 #include "ir/runtime-table.h"
 #include "literal.h"
 #include "wasm-type.h"
@@ -137,12 +138,19 @@ class ImportResolver {
   virtual Literals*
   getGlobalOrNull(ImportNames name, Type type, bool mut) const = 0;
 
-  // Returns null if the imported table does not exist. The returned
-  // RuntimeTable* lives as long as the ImportResolver instance.
+  // Returns null if the `name` wasn't found. The returned RuntimeTable lives
+  // as long as the ImportResolver instance.
   virtual RuntimeTable* getTableOrNull(ImportNames name,
                                        const Table& type) const = 0;
 
+  // Returns null if the `name` wasn't found. The returned Tag lives
+  // as long as the ImportResolver instance.
   virtual Tag* getTagOrNull(ImportNames name, const Signature& type) const = 0;
+
+  // Returns null if the `name` wasn't found. The returned RuntimeMemory lives
+  // as long as the ImportResolver instance.
+  virtual RuntimeMemory* getMemoryOrNull(ImportNames name,
+                                         const Memory& type) const = 0;
 };
 
 // Looks up imports from the given `linkedInstances`.
@@ -185,6 +193,17 @@ class LinkedInstancesImportResolver : public ImportResolver {
     return instance->getExportedTagOrNull(name.name);
   }
 
+  RuntimeMemory* getMemoryOrNull(ImportNames name,
+                                 const Memory& type) const override {
+    auto it = linkedInstances.find(name.module);
+    if (it == linkedInstances.end()) {
+      return nullptr;
+    }
+
+    ModuleRunnerType* instance = it->second.get();
+    return instance->getExportedMemoryOrNull(name.name);
+  }
+
 private:
   const std::map<Name, std::shared_ptr<ModuleRunnerType>> linkedInstances;
 };

src/ir/runtime-memory.h

@@ -23,18 +23,23 @@ namespace wasm {
 
 // TODO split into pure virtual class
 class RuntimeMemory {
+public:
   RuntimeMemory(Memory memory) : memoryDefinition(memory) {}
 
+  virtual ~RuntimeMemory() = default;
+
   // variants for load8 etc?
   // Do we care about the order here?
-  Literal load(Address addr) const { return {}; }
+  virtual Literal load(Address addr) const { return {}; }
 
   const Memory* getDefinition() const { return &memoryDefinition; }
 
-private:
+protected:
   const Memory memoryDefinition;
 };
 
+class RealRuntimeMemory : public RuntimeMemory {};
+
 } // namespace wasm
 
 #endif // wasm_ir_runtime_memory_h

src/ir/runtime-table.h

@@ -30,7 +30,6 @@ namespace wasm {
 // out-of-bounds access.
 class RuntimeTable {
 public:
-  RuntimeTable(Table table) : tableDefinition(table) {}
   virtual ~RuntimeTable() = default;
 
   virtual void set(Address i, Literal l) = 0;
@@ -54,6 +53,8 @@ class RuntimeTable {
   const Table* getDefinition() const { return &tableDefinition; }
 
 protected:
+  RuntimeTable(Table table) : tableDefinition(table) {}
+
   const Table tableDefinition;
 };
 

src/tools/wasm-ctor-eval.cpp

@@ -95,6 +95,12 @@ class EvallingImportResolver : public ImportResolver {
     return &it->second;
   }
 
+  RuntimeMemory* getMemoryOrNull(ImportNames name,
+                                 const Memory& memory) const override {
+    Fatal() << "todo";
+    return nullptr;
+  }
+
 private:
   mutable Literals stubLiteral;
   mutable std::unordered_map<ImportNames, Tag> importedTags;

src/wasm-interpreter.h

@@ -3208,6 +3208,8 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
 
   std::unordered_map<Name, Tag*> allTags;
 
+  std::unordered_map<Name, RuntimeMemory*> allMemories;
+
   using CreateTableFunc = std::unique_ptr<RuntimeTable>(Literal, Table);
 
   ModuleRunnerBase(
@@ -3321,6 +3323,19 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
     return iter->second;
   }
 
+  RuntimeMemory* getExportedMemoryOrNull(Name name) {
+    Export* export_ = wasm.getExportOrNull(name);
+    if (!export_ || export_->kind != ExternalKind::Memory) {
+      return nullptr;
+    }
+    Name internalName = *export_->getInternalName();
+    auto iter = allMemories.find(internalName);
+    if (iter == allMemories.end()) {
+      return nullptr;
+    }
+    return iter->second;
+  }
+
   Literals& getExportedGlobalOrTrap(Name name) {
     auto* global = getExportedGlobalOrNull(name);
     if (!global) {
@@ -3372,6 +3387,7 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
   std::vector<Literals> definedGlobals;
   std::vector<std::unique_ptr<RuntimeTable>> definedTables;
   std::vector<Tag> definedTags;
+  std::vector<std::unique_ptr<RuntimeMemory>> definedMemories;
 
   // Keep a record of call depth, to guard against excessive recursion.
   size_t callDepth = 0;
@@ -3595,6 +3611,37 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
     });
   }
 
+  void initializeMemories() {
+    int definedMemoryCount = 0;
+    ModuleUtils::iterDefinedMemories(
+      wasm, [&definedMemoryCount](auto&& _) { ++definedMemoryCount; });
+    definedMemories.reserve(definedMemoryCount);
+
+    for (auto& memory : wasm.memories) {
+      if (memory->imported()) {
+        auto importNames = memory->importNames();
+        auto* importedMemory =
+          importResolver->getMemoryOrNull(importNames, *memory);
+        if (!importedMemory) {
+          externalInterface->trap((std::stringstream()
+                                   << "Imported memory " << importNames
+                                   << " not found.")
+                                    .str());
+        }
+        [[maybe_unused]] auto [_, inserted] =
+          allMemories.try_emplace(memory->name, importedMemory);
+        // parsing/validation checked this already.
+        assert(inserted && "Unexpected repeated memory name");
+      } else {
+        auto& runtimeMemory = definedMemories.emplace_back(
+          std::make_unique<RealRuntimeMemory>(memory));
+        [[maybe_unused]] auto [_, inserted] =
+          allMemories.try_emplace(memory->name, runtimeMemory.get());
+        assert(inserted && "Unexpected repeated memory name");
+      }
+    }
+  }
+
   struct MemoryInstanceInfo {
     // The ModuleRunner instance in which the memory is defined.
     SubType* instance;