WebAssembly · tDwtp · Sep 28, 2022 · Sep 28, 2022 · Sep 28, 2022 · Sep 28, 2022
diff --git a/src/tools/wasm-interp.cc b/src/tools/wasm-interp.cc
@@ -18,6 +18,7 @@
 #include <cassert>
 #include <cstdio>
 #include <cstdlib>
+#include <map>
 #include <memory>
 #include <string>
 #include <vector>
@@ -39,6 +40,9 @@
 using namespace wabt;
 using namespace wabt::interp;
 
+using ExportMap = std::map<std::string, Extern::Ptr>;
+using Registry = std::map<std::string, ExportMap>;
+
 static int s_verbose;
 static const char* s_infile;
 static Thread::Options s_thread_options;
@@ -48,6 +52,7 @@ static bool s_host_print;
 static bool s_dummy_import_func;
 static Features s_features;
 static bool s_wasi;
+static std::vector<std::string> s_modules;
 static std::vector<std::string> s_wasi_env;
 static std::vector<std::string> s_wasi_argv;
 static std::vector<std::string> s_wasi_dirs;
@@ -56,6 +61,8 @@ static std::unique_ptr<FileStream> s_log_stream;
 static std::unique_ptr<FileStream> s_stdout_stream;
 static std::unique_ptr<FileStream> s_stderr_stream;
 
+static Registry s_registry;
+
 static Store s_store;
 
 static const char s_description[] =
@@ -110,6 +117,13 @@ static void ParseOptions(int argc, char** argv) {
   parser.AddOption(
       'd', "dir", "DIR", "Pass the given directory the the WASI runtime",
       [](const std::string& argument) { s_wasi_dirs.push_back(argument); });
+  parser.AddOption(
+      'm', "module", "[(@|$)NAME:]FILE",
+      "load module FILE and provide all exports under NAME for upcoming "
+      "imports. if NAME is empty, the preference will be used. "
+      /*"$ prefers the debug-name in the name section, "*/
+      "@ prefers file name (without extension).",
+      [](const std::string& argument) { s_modules.push_back(argument); });
   parser.AddOption(
       "run-all-exports",
       "Run all the exported functions, in order. Useful for testing",
@@ -161,33 +175,126 @@ Result RunAllExports(const Instance::Ptr& instance, Errors* errors) {
   return result;
 }
 
-static void BindImports(const Module::Ptr& module, RefVec& imports) {
+static bool IsHostPrint(const ImportDesc& import) {
+  return import.type.type->kind == ExternKind::Func &&
+         ((s_host_print && import.type.module == "host" &&
+           import.type.name == "print") ||
+          s_dummy_import_func);
+}
+
+static Ref GenerateHostPrint(const ImportDesc& import) {
   auto* stream = s_stdout_stream.get();
 
+  auto func_type = *cast<FuncType>(import.type.type.get());
+  auto import_name = StringPrintf("%s.%s", import.type.module.c_str(),
+                                  import.type.name.c_str());
+
+  auto host_func = HostFunc::New(
+      s_store, func_type,
+      [=](Thread& thread, const Values& params, Values& results,
+          Trap::Ptr* trap) -> Result {
+        printf("called host ");
+        WriteCall(stream, import_name, func_type, params, results, *trap);
+        return Result::Ok;
+      });
+
+  return host_func.ref();
+}
+
+static Extern::Ptr GetImport(const std::string& module,
+                             const std::string& name) {
+  auto mod_iter = s_registry.find(module);
+  if (mod_iter != s_registry.end()) {
+    auto extern_iter = mod_iter->second.find(name);
+    if (extern_iter != mod_iter->second.end()) {
+      return extern_iter->second;
+    }
+  }
+  return {};
+}
+
+static void PopulateExports(const Instance::Ptr& instance,
+                            Module::Ptr& module,
+                            ExportMap& map) {
+  map.clear();
+  // Module::Ptr module{s_store, instance->module()};
+  for (size_t i = 0; i < module->export_types().size(); ++i) {
+    const ExportType& export_type = module->export_types()[i];
+    auto export_ = s_store.UnsafeGet<Extern>(instance->exports()[i]);
+    map[export_type.name] = export_;
+  }
+}
+
+static std::string GetPathName(std::string module_arg) {
+  size_t path_at = module_arg.find_first_of(':');
+
+  path_at = path_at == std::string::npos ? 0 : path_at + 1;
+
+  return module_arg.substr(path_at);
+}
+
+static std::string FileNameOfPath(std::string path_name) {
+  // use file_name (without extension)
+  size_t fstart = path_name.find_last_of("/\\");
+  size_t fend = path_name.find_last_of(".");
+
+  fstart = fstart == std::string::npos ? 0 : fstart;
+  fend = fend < fstart ? std::string::npos : fend;
+
+  return path_name.substr(fstart, fend);
+}
+
+static std::string GetRegistryName(std::string module_arg,
+                                   const Module::Ptr& module) {
+  size_t split_pos = module_arg.find_first_of(':');
+  if (split_pos == std::string::npos) {
+    split_pos = 0;
+  }
+  std::string override_name = module_arg.substr(0, split_pos ? split_pos : 0);
+  std::string path_name = module_arg.substr(split_pos);
+  std::string debug_name = "";  // GetDebugName(module);
+
+  // check if override_name starts with @ and return override_name
+  if (override_name[0] == '@') {
+    if (override_name.size() > 1) {
+      return override_name.substr(1);
+    }
+    // ignore debug-name and use filename
+    return FileNameOfPath(path_name);
+  }
+
+  // if no override_name is provided -> use debug name or filename
+  if (override_name.empty()) {
+    // prefer debug_name, if no override_name is provided
+    if (!debug_name.empty()) {
+      return debug_name;
+    }
+    // use file_name (without extension)
+    return FileNameOfPath(path_name);
+  }
+
+  // prefer debug_name if override_name starts with '$'
+  if (override_name[0] == '$' && !debug_name.empty()) {
+    return debug_name;
+  }
+
+  // return the override_name (remove leading '$' if present)
+  bool leading_dollar = override_name[0] == '$';
+  return override_name.substr(leading_dollar ? 1 : 0);
+}
+
+static void BindImports(const Module::Ptr& module, RefVec& imports) {
   for (auto&& import : module->desc().imports) {
-    if (import.type.type->kind == ExternKind::Func &&
-        ((s_host_print && import.type.module == "host" &&
-          import.type.name == "print") ||
-         s_dummy_import_func)) {
-      auto func_type = *cast<FuncType>(import.type.type.get());
-      auto import_name = StringPrintf("%s.%s", import.type.module.c_str(),
-                                      import.type.name.c_str());
-
-      auto host_func = HostFunc::New(
-          s_store, func_type,
-          [=](Thread& thread, const Values& params, Values& results,
-              Trap::Ptr* trap) -> Result {
-            printf("called host ");
-            WriteCall(stream, import_name, func_type, params, results, *trap);
-            return Result::Ok;
-          });
-      imports.push_back(host_func.ref());
+    if (IsHostPrint(import)) {
+      imports.push_back(GenerateHostPrint(import));
       continue;
     }
 
     // By default, just push an null reference. This won't resolve, and
     // instantiation will fail.
-    imports.push_back(Ref::Null);
+
+    Extern::Ptr extern_ = GetImport(import.type.module, import.type.name);
+    imports.push_back(extern_ ? extern_.ref() : Ref::Null);
   }
 }
 
@@ -239,6 +346,37 @@ static Result ReadAndRunModule(const char* module_filename) {
 
   RefVec imports;
 
+  // if we only have dummy imports, we wont need to reghister anything
+  // but we still want to load them.
+  std::vector<Module::Ptr> modules_loaded(s_modules.size());
+  for (auto import_module : s_modules) {
+    ExportMap load_map;
+    std::string module_path = GetPathName(import_module);
+
+    Module::Ptr load_module;
+    result = ReadModule(module_path.c_str(), &errors, &load_module);
+    if (!Succeeded(result)) {
+      FormatErrorsToFile(errors, Location::Type::Binary);
+      return result;
+    }
+
+    RefVec load_imports;
+    BindImports(load_module, load_imports);
+
+    // this is how wasm-interp.exe does it
+    Instance::Ptr load_instance;
+    CHECK_RESULT(InstantiateModule(load_imports, load_module, &load_instance));
+
+    // we wont need to register anything, if we only have dummy imports anyway
+    if (!s_dummy_import_func) {
+      std::string reg_name = GetRegistryName(import_module, load_module);
+      PopulateExports(load_instance, load_module, load_map);
+      s_registry[reg_name] = std::move(load_map);
+    }
+
+    modules_loaded.push_back(load_module);
+  }
+
 #if WITH_WASI
   uvwasi_t uvwasi;
 #endif
@@ -327,6 +465,12 @@ int ProgramMain(int argc, char** argv) {
   s_store.setFeatures(s_features);
 
   wabt::Result result = ReadAndRunModule(s_infile);
+
+  for (auto& pair : s_registry) {
+    pair.second.clear();
+  }
+  s_registry.clear();
+
   return result != wabt::Result::Ok;
 }
 

diff --git a/test/help/wasm-interp.txt b/test/help/wasm-interp.txt
@@ -48,6 +48,7 @@ options:
       --wasi                                   Assume input module is WASI compliant (Export  WASI API the the module and invoke _start function)
   -e, --env=ENV                                Pass the given environment string in the WASI runtime
   -d, --dir=DIR                                Pass the given directory the the WASI runtime
+  -m, --module=[(@|$)NAME:]FILE                load module FILE and provide all exports under NAME for upcoming imports. if NAME is empty, the preference will be used. @ prefers file name (without extension).
       --run-all-exports                        Run all the exported functions, in order. Useful for testing
       --host-print                             Include an importable function named "host.print" for printing to stdout
       --dummy-import-func                      Provide a dummy implementation of all imported functions. The function will log the call and return an appropriate zero value.