/src/WasmEdge/lib/vm/vm.cpp

Source
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright The WasmEdge Authors

#include "vm/vm.h"

#include "plugin_modules.h"

#include "ast/module.h"
#include "common/errcode.h"
#include "common/types.h"
#include "executor/coredump.h"
#include "host/wasi/wasimodule.h"
#include "plugin/plugin.h"
#include "llvm/compiler.h"
#include "llvm/jit.h"

#include "validator/validator.h"
#include <algorithm>
#include <memory>
#include <variant>

namespace WasmEdge {
namespace VM {

std::vector<Runtime::Instance::ModuleInstance *> VM::collectModuleInstances() {
  std::vector<Runtime::Instance::ModuleInstance *> Modules;
  auto Add = [&Modules](auto *Module) {
    if (Module != nullptr &&
        std::find(Modules.begin(), Modules.end(), Module) == Modules.end()) {
      Modules.push_back(Module);
    }
  };
  Add(ActiveModInst.get());
  for (auto &Module : RegModInsts) {
    Add(Module.get());
  }
  std::vector<HostRegistration> Hosts;
  for (const auto &Entry : BuiltInModInsts) {
    Hosts.push_back(Entry.first);
  }
  std::sort(Hosts.begin(), Hosts.end());
  for (auto Host : Hosts) {
    Add(BuiltInModInsts.at(Host).get());
  }
  for (auto &Module : PlugInModInsts) {
    Add(Module.get());
  }
  return Modules;
}

Expect<std::filesystem::path> VM::snapshot(const std::filesystem::path &Path) {
  std::unique_lock Lock(Mutex);
  if (ActiveCompInst) {
    return Unexpect(ErrCode::Value::CoredumpUnsupported);
  }
  const auto Modules = collectModuleInstances();
  const std::vector<const Runtime::Instance::ModuleInstance *> Sources(
      Modules.begin(), Modules.end());
  Coredump::Request Req;
  Req.Modules = Sources;
  Req.Path = Path;
  return Coredump::generate(Req);
}

Expect<void> VM::restore(const std::filesystem::path &Path) {
  std::unique_lock Lock(Mutex);
  if (ActiveCompInst) {
    return Unexpect(ErrCode::Value::CoredumpUnsupported);
  }
  const auto Modules = collectModuleInstances();
  return Coredump::restore({Modules, Path});
}

VM::VM(const Configure &Conf)
    : Conf(Conf), Stage(VMStage::Inited),
      LoaderEngine(Conf, &Executor::Executor::Intrinsics),
      ValidatorEngine(Conf), ExecutorEngine(Conf, &Stat),
      Store(std::make_unique<Runtime::StoreManager>()), StoreRef(*Store.get()) {
  unsafeInitVM();
}

VM::VM(const Configure &Conf, Runtime::StoreManager &S)
    : Conf(Conf), Stage(VMStage::Inited),
      LoaderEngine(Conf, &Executor::Executor::Intrinsics),
      ValidatorEngine(Conf), ExecutorEngine(Conf, &Stat), StoreRef(S) {
  unsafeInitVM();
}

void VM::unsafeInitVM() {
  // Load the built-in modules and the plug-ins.
  unsafeLoadBuiltInHosts();
  unsafeLoadPlugInHosts();

  // Set up the lazy JIT engine if lazy JIT mode is enabled.
#ifdef WASMEDGE_USE_LLVM
  if (Conf.getRuntimeConfigure().getRunMode() == RunMode::LazyJIT) {
    spdlog::warn(
        "Lazy JIT is an alpha and experimental feature, which is not ready for production use."sv);
    LazyEngine = std::make_unique<LLVM::LazyJITEngine>(Conf);
    ExecutorEngine.registerLazyCompilationCallback(
        [this](const Runtime::Instance::FunctionInstance *FuncInst)
            -> Expect<void> { return LazyEngine->compileOnDemand(FuncInst); });
  }
#endif

  // Register all module instances.
  unsafeRegisterBuiltInHosts();
  unsafeRegisterPlugInHosts();
}

void VM::unsafeLoadBuiltInHosts() {
  // Load the built-in host modules from configuration.
  // TODO: This will be extended for versioned WASI in the future.
  cleanupModInstContainer(BuiltInModInsts);
  if (Conf.hasHostRegistration(HostRegistration::Wasi)) {
    std::unique_ptr<Runtime::Instance::ModuleInstance> WasiMod =
        std::make_unique<Host::WasiModule>();
    BuiltInModInsts.insert({HostRegistration::Wasi, std::move(WasiMod)});
  }
}

void VM::unsafeLoadPlugInHosts() {
  // Load the official plugin modules and mock them if not found.
  cleanupModInstContainer(PlugInModInsts);
  PlugInModInsts = loadOfficialPluginModules();

  // Load the other non-official plugins.
  for (const auto &Plugin : Plugin::Plugin::plugins()) {
    if (Conf.isForbiddenPlugins(Plugin.name())) {
      continue;
    }
    if (isOfficialPlugin(Plugin.name())) {
      continue;
    }
    for (const auto &Module : Plugin.modules()) {
      PlugInModInsts.push_back(Module.create());
    }
    for (const auto &Component : Plugin.components()) {
      PlugInCompInsts.push_back(Component.create());
    }
  }
}

void VM::unsafeRegisterBuiltInHosts() {
  // Register all created WASI host modules.
  for (auto &It : BuiltInModInsts) {
    ExecutorEngine.registerModule(StoreRef, *(It.second.get()));
  }
}

void VM::unsafeRegisterPlugInHosts() {
  // Register all created module instances from plugins.
  for (auto &It : PlugInModInsts) {
    ExecutorEngine.registerModule(StoreRef, *(It.get()));
  }
  for (auto &It : PlugInCompInsts) {
    ExecutorEngine.registerComponent(StoreRef, *(It.get()));
  }
}

Expect<void> VM::unsafeRegisterModule(std::string_view Name,
                                      const std::filesystem::path &Path) {
  // Load module.
  EXPECTED_TRY(std::shared_ptr<AST::Module> Module,
               LoaderEngine.parseModule(Path));
  return unsafeRegisterModule(Name, std::move(Module));
}

Expect<void> VM::unsafeRegisterModule(std::string_view Name,
                                      Span<const Byte> Code) {
  // Load module.
  EXPECTED_TRY(std::shared_ptr<AST::Module> Module,
               LoaderEngine.parseModule(Code));
  return unsafeRegisterModule(Name, std::move(Module));
}

Expect<void> VM::unsafeRegisterModule(std::string_view Name,
                                      const AST::Module &Module) {
#ifdef WASMEDGE_USE_LLVM
  if (LazyEngine) {
    // The lazy JIT engine needs to own the AST module and hook the compiled
    // executable into it, so register an owned copy instead of mutating the
    // caller's module.
    return unsafeRegisterModule(Name, std::make_shared<AST::Module>(Module));
  }
#endif
  unsafeRevertStageToValidated();
  // Validate module.
  EXPECTED_TRY(ValidatorEngine.validate(Module));
  // Instantiate and register module.
  EXPECTED_TRY(auto ModInst,
               ExecutorEngine.registerModule(StoreRef, Module, Name));
  RegModInsts.push_back(std::move(ModInst));
  return {};
}

Expect<void> VM::unsafeRegisterModule(std::string_view Name,
                                      std::shared_ptr<AST::Module> Module) {
  unsafeRevertStageToValidated();
  // Validate module.
  EXPECTED_TRY(ValidatorEngine.validate(*Module));

#ifdef WASMEDGE_USE_LLVM
  if (LazyEngine && !Module->getSymbol()) {
    EXPECTED_TRY(auto Exec, LazyEngine->prepare(Module));
    EXPECTED_TRY(LoaderEngine.loadExecutable(*Module, std::move(Exec)));
  }
#endif

  // Instantiate and register module.
  EXPECTED_TRY(auto ModInst,
               ExecutorEngine.registerModule(StoreRef, *Module, Name));

#ifdef WASMEDGE_USE_LLVM
  if (LazyEngine) {
    LazyEngine->registerInstance(*ModInst, std::move(Module));
  }
#endif

  RegModInsts.push_back(std::move(ModInst));
  return {};
}

Expect<void>
VM::unsafeRegisterModule(std::string_view Name,
                         const Runtime::Instance::ModuleInstance &ModInst) {
  unsafeRevertStageToValidated();
  return ExecutorEngine.registerModule(StoreRef, ModInst, Name);
}

Expect<void> VM::unsafeUnregisterModule(std::string_view Name) {
  auto InstIt = std::find_if(
      RegModInsts.begin(), RegModInsts.end(),
      [&Name](const std::unique_ptr<Runtime::Instance::ModuleInstance> &Inst) {
        return Inst && Inst->getModuleName() == Name;
      });
  if (InstIt != RegModInsts.end()) {
    auto *ModInst = (*InstIt).release();

    if (ModInst) {
#ifdef WASMEDGE_USE_LLVM
      if (LazyEngine) {
        LazyEngine->unregisterInstance(*ModInst);
      }
#endif
      ModInst->terminate();
    }
    return {};
  }
  for (auto It = BuiltInModInsts.begin(); It != BuiltInModInsts.end(); ++It) {
    if (It->second && It->second->getModuleName() == Name) {
      auto *ModInst = It->second.release();
      BuiltInModInsts.erase(It);

      if (ModInst) {
        ModInst->terminate();
      }
      return {};
    }
  }
  for (auto It = PlugInModInsts.begin(); It != PlugInModInsts.end(); ++It) {
    if (*It && (*It)->getModuleName() == Name) {
      auto *ModInst = It->release();
      PlugInModInsts.erase(It);

      if (ModInst) {
        ModInst->terminate();
      }
      return {};
    }
  }

  return {};
}

VM::WasmUnitKind
VM::unsafeStoreWasmUnit(std::variant<std::unique_ptr<AST::Component::Component>,
                                     std::unique_ptr<AST::Module>> &&Unit) {
  if (auto *M = std::get_if<std::unique_ptr<AST::Module>>(&Unit)) {
    Mod = std::move(*M);
    return WasmUnitKind::Module;
  }
  Comp = std::move(std::get<std::unique_ptr<AST::Component::Component>>(Unit));
  return WasmUnitKind::Component;
}

Expect<std::vector<std::pair<ValVariant, ValType>>>
VM::unsafeRunWasmFile(const std::filesystem::path &Path, std::string_view Func,
                      Span<const ValVariant> Params,
                      Span<const ValType> ParamTypes) {
  unsafeRevertStageToValidated();
  // Load wasm unit.
  EXPECTED_TRY(auto ComponentOrModule, LoaderEngine.parseWasmUnit(Path));
  if (unsafeStoreWasmUnit(std::move(ComponentOrModule)) ==
      WasmUnitKind::Component) {
    return unsafeRunWasmFile(*Comp, Func, Params, ParamTypes);
  }
  return unsafeRunWasmFile(*Mod, Func, Params, ParamTypes);
}

Expect<std::vector<std::pair<ValVariant, ValType>>>
VM::unsafeRunWasmFile(Span<const Byte> Code, std::string_view Func,
                      Span<const ValVariant> Params,
                      Span<const ValType> ParamTypes) {
  unsafeRevertStageToValidated();
  // Load wasm unit.
  EXPECTED_TRY(auto ComponentOrModule, LoaderEngine.parseWasmUnit(Code));
  if (unsafeStoreWasmUnit(std::move(ComponentOrModule)) ==
      WasmUnitKind::Component) {
    return unsafeRunWasmFile(*Comp, Func, Params, ParamTypes);
  }
  return unsafeRunWasmFile(*Mod, Func, Params, ParamTypes);
}

Expect<std::vector<std::pair<ValVariant, ValType>>>
VM::unsafeRunWasmFile(const AST::Component::Component &Component,
                      std::string_view, Span<const ValVariant>,
                      Span<const ValType>) {
  unsafeRevertStageToValidated();
  EXPECTED_TRY(ValidatorEngine.validate(Component));
  spdlog::error("component execution is not done yet."sv);
  return Unexpect(ErrCode::Value::RuntimeError);
}

Expect<std::vector<std::pair<ValVariant, ValType>>>
VM::unsafeRunWasmFile(const AST::Module &Module, std::string_view Func,
                      Span<const ValVariant> Params,
                      Span<const ValType> ParamTypes) {
  unsafeRevertStageToValidated();
  EXPECTED_TRY(ValidatorEngine.validate(Module));
#ifdef WASMEDGE_USE_LLVM
  if (LazyEngine) {
    // This one-shot path takes no shared ownership of the module, so it is
    // not bound to the lazy JIT engine and executes in the interpreter.
    spdlog::debug("[lazy-jit]: runWasmFile executes in interpreter mode"sv);
  }
#endif
  EXPECTED_TRY(auto NewModInst,
               ExecutorEngine.instantiateModule(StoreRef, Module));
#ifdef WASMEDGE_USE_LLVM
  // Drop the lazy binding of the replaced instance only after the new
  // instantiation succeeds, so a failed run keeps the current instance bound.
  if (LazyEngine && ActiveModInst) {
    LazyEngine->unregisterInstance(*ActiveModInst);
  }
#endif
  ActiveModInst = std::move(NewModInst);

  // Get module instance.
  if (ActiveModInst) {
    // Execute function and return values using the module instance.
    return unsafeExecute(ActiveModInst.get(), Func, Params, ParamTypes);
  }
  spdlog::error(ErrCode::Value::WrongInstanceAddress);
  spdlog::error(ErrInfo::InfoExecuting(""sv, Func));
  return Unexpect(ErrCode::Value::WrongInstanceAddress);
}

Async<Expect<std::vector<std::pair<ValVariant, ValType>>>>
VM::asyncRunWasmFile(const std::filesystem::path &Path, std::string_view Func,
                     Span<const ValVariant> Params,
                     Span<const ValType> ParamTypes) {
  Expect<std::vector<std::pair<ValVariant, ValType>>> (VM::*FPtr)(
      const std::filesystem::path &, std::string_view, Span<const ValVariant>,
      Span<const ValType>) = &VM::runWasmFile;
  return {FPtr,
          *this,
          std::filesystem::path(Path),
          std::string(Func),
          std::vector(Params.begin(), Params.end()),
          std::vector(ParamTypes.begin(), ParamTypes.end())};
}

Async<Expect<std::vector<std::pair<ValVariant, ValType>>>>
VM::asyncRunWasmFile(Span<const Byte> Code, std::string_view Func,
                     Span<const ValVariant> Params,
                     Span<const ValType> ParamTypes) {
  Expect<std::vector<std::pair<ValVariant, ValType>>> (VM::*FPtr)(
      Span<const Byte>, std::string_view, Span<const ValVariant>,
      Span<const ValType>) = &VM::runWasmFile;
  return {FPtr,
          *this,
          Code,
          std::string(Func),
          std::vector(Params.begin(), Params.end()),
          std::vector(ParamTypes.begin(), ParamTypes.end())};
}

Async<Expect<std::vector<std::pair<ValVariant, ValType>>>>
VM::asyncRunWasmFile(const AST::Module &Module, std::string_view Func,
                     Span<const ValVariant> Params,
                     Span<const ValType> ParamTypes) {
  Expect<std::vector<std::pair<ValVariant, ValType>>> (VM::*FPtr)(
      const AST::Module &, std::string_view, Span<const ValVariant>,
      Span<const ValType>) = &VM::runWasmFile;
  return {FPtr,
          *this,
          Module,
          std::string(Func),
          std::vector(Params.begin(), Params.end()),
          std::vector(ParamTypes.begin(), ParamTypes.end())};
}

Expect<void> VM::unsafeLoadWasm(const std::filesystem::path &Path) {
  // If loading does not succeed, the previous status will be preserved.
  EXPECTED_TRY(auto ComponentOrModule, LoaderEngine.parseWasmUnit(Path));
  unsafeStoreWasmUnit(std::move(ComponentOrModule));
  Stage = VMStage::Loaded;
  return {};
}

Expect<void> VM::unsafeLoadWasm(Span<const Byte> Code) {
  // If loading does not succeed, the previous status will be preserved.
  EXPECTED_TRY(auto ComponentOrModule, LoaderEngine.parseWasmUnit(Code));
  unsafeStoreWasmUnit(std::move(ComponentOrModule));
  Stage = VMStage::Loaded;
  return {};
}

Expect<void> VM::unsafeLoadWasm(const AST::Module &Module) {
  Mod = std::make_shared<AST::Module>(Module);
  Stage = VMStage::Loaded;
  return {};
}

Expect<void> VM::unsafeValidate() {
  if (Stage < VMStage::Loaded) {
    // Do not validate when the module is not loaded.
    spdlog::error(ErrCode::Value::WrongVMWorkflow);
    return Unexpect(ErrCode::Value::WrongVMWorkflow);
  }

  if (Mod) {
    EXPECTED_TRY(ValidatorEngine.validate(*Mod.get()));
  } else if (Comp) {
    EXPECTED_TRY(ValidatorEngine.validate(*Comp.get()));
  } else {
    spdlog::error(ErrCode::Value::WrongVMWorkflow);
    return Unexpect(ErrCode::Value::WrongVMWorkflow);
  }
  Stage = VMStage::Validated;
  return {};
}

Expect<void> VM::unsafeLoadJITExecutable() {
  if ((Conf.getRuntimeConfigure().getRunMode() != RunMode::JIT &&
       Conf.getRuntimeConfigure().getRunMode() != RunMode::LazyJIT) ||
      Mod->getSymbol()) {
    return {};
  }
#ifdef WASMEDGE_USE_LLVM
  if (LazyEngine) {
    EXPECTED_TRY(auto Exec, LazyEngine->prepare(Mod));
    EXPECTED_TRY(LoaderEngine.loadExecutable(*Mod, std::move(Exec)));
    return {};
  }
  LLVM::Compiler Compiler(Conf);
  Compiler.checkConfigure()
      .map_error([](uint32_t Err) {
        if (Err != ErrCode::Value::Success) {
          spdlog::error("Compiler Configure failed. Error code: {}, use "
                        "interpreter mode instead."sv,
                        Err);
        }
        return ErrCode::Value::Success;
      })
      .and_then([&]() { return Compiler.compile(*Mod); })
      .map_error([](uint32_t Err) {
        if (Err != ErrCode::Value::Success) {
          spdlog::error("Compilation failed. Error code: {}, use "
                        "interpreter mode instead."sv,
                        Err);
        }
        return ErrCode::Value::Success;
      })
      .and_then([&](auto LLModule) {
        LLVM::JIT JIT(Conf);
        return JIT.load(std::move(LLModule));
      })
      .map_error([](uint32_t Err) {
        if (Err != ErrCode::Value::Success) {
          spdlog::warn(
              "JIT failed. Error code: {}, use interpreter mode instead."sv,
              Err);
        }
        return ErrCode::Value::Success;
      })
      .and_then([&](auto Module) {
        return LoaderEngine.loadExecutable(*Mod, std::move(Module));
      })
      .map_error([](uint32_t Err) {
        if (Err != ErrCode::Value::Success) {
          spdlog::warn("Loader failed. Error code: {}, use interpreter "
                       "mode instead."sv,
                       Err);
        }
        return ErrCode::Value::Success;
      });
  return {};
#else
  spdlog::warn("JIT was requested but WasmEdge was built without LLVM, "
               "falling back to interpreter."sv);
  return {};
#endif
}

Expect<void> VM::unsafeInstantiate() {
  if (Stage < VMStage::Validated) {
    // Do not instantiate when the module is not validated.
    spdlog::error(ErrCode::Value::WrongVMWorkflow);
    return Unexpect(ErrCode::Value::WrongVMWorkflow);
  }
  if (Mod) {
    EXPECTED_TRY(unsafeLoadJITExecutable());
    EXPECTED_TRY(auto NewModInst,
                 ExecutorEngine.instantiateModule(StoreRef, *Mod));

#ifdef WASMEDGE_USE_LLVM
    if (LazyEngine) {
      // Rebind the lazy JIT state only after instantiation succeeds, so a
      // failed re-instantiation keeps the current instance bound.
      if (ActiveModInst) {
        LazyEngine->unregisterInstance(*ActiveModInst);
      }
      LazyEngine->registerInstance(*NewModInst, Mod);
    }
#endif
    ActiveModInst = std::move(NewModInst);

    Stage = VMStage::Instantiated;
    return {};
  }
  if (Comp) {
    EXPECTED_TRY(ActiveCompInst,
                 ExecutorEngine.instantiateComponent(StoreRef, *Comp));
    Stage = VMStage::Instantiated;
    return {};
  }
  spdlog::error(ErrCode::Value::WrongVMWorkflow);
  return Unexpect(ErrCode::Value::WrongVMWorkflow);
}

Expect<std::vector<std::pair<ValVariant, ValType>>>
VM::unsafeExecute(std::string_view Func, Span<const ValVariant> Params,
                  Span<const ValType> ParamTypes) {
  if (unlikely(!ActiveModInst)) {
    spdlog::error(ErrCode::Value::WrongInstanceAddress);
    spdlog::error(ErrInfo::InfoExecuting("When invoking"sv, Func));
    return Unexpect(ErrCode::Value::WrongInstanceAddress);
  }
  // Execute function and return values using the module instance.
  return unsafeExecute(ActiveModInst.get(), Func, Params, ParamTypes);
}

Expect<std::vector<std::pair<ValVariant, ValType>>>
VM::unsafeExecute(std::string_view ModName, std::string_view Func,
                  Span<const ValVariant> Params,
                  Span<const ValType> ParamTypes) {
  // Find module instance by name.
  const auto *FindModInst = StoreRef.findModule(ModName);
  if (unlikely(!FindModInst)) {
    spdlog::error(ErrCode::Value::WrongInstanceAddress);
    spdlog::error(ErrInfo::InfoExecuting(ModName, Func));
    return Unexpect(ErrCode::Value::WrongInstanceAddress);
  }
  // Execute function and return values using the module instance.
  return unsafeExecute(FindModInst, Func, Params, ParamTypes);
}

Expect<std::vector<std::pair<ComponentValVariant, ComponentValType>>>
VM::unsafeExecuteComponent(std::string_view Func,
                           Span<const ComponentValVariant> Params,
                           Span<const ComponentValType> ParamTypes) {
  if (unlikely(!ActiveCompInst)) {
    spdlog::error(ErrCode::Value::WrongInstanceAddress);
    spdlog::error(ErrInfo::InfoExecuting("When invoking"sv, Func));
    return Unexpect(ErrCode::Value::WrongInstanceAddress);
  }
  return unsafeExecuteComponent(ActiveCompInst.get(), Func, Params, ParamTypes);
}

Expect<std::vector<std::pair<ComponentValVariant, ComponentValType>>>
VM::unsafeExecuteComponent(std::string_view CompName, std::string_view Func,
                           Span<const ComponentValVariant> Params,
                           Span<const ComponentValType> ParamTypes) {
  // Find module instance by name.
  const auto *FindCompInst = StoreRef.findComponent(CompName);
  if (unlikely(!FindCompInst)) {
    spdlog::error(ErrCode::Value::WrongInstanceAddress);
    spdlog::error(ErrInfo::InfoExecuting(CompName, Func));
    return Unexpect(ErrCode::Value::WrongInstanceAddress);
  }
  // Execute function and return values using the component instance.
  return unsafeExecuteComponent(FindCompInst, Func, Params, ParamTypes);
}

Expect<std::vector<std::pair<ValVariant, ValType>>>
VM::unsafeExecute(const Runtime::Instance::ModuleInstance *ModInst,
                  std::string_view Func, Span<const ValVariant> Params,
                  Span<const ValType> ParamTypes) {
  // Find exported function by name.
  Runtime::Instance::FunctionInstance *FuncInst =
      ModInst->findFuncExports(Func);

#ifdef WASMEDGE_USE_LLVM
  // Lazy JIT: compile the function on-demand if needed.
  if (LazyEngine) {
    EXPECTED_TRY(LazyEngine->compileOnDemand(FuncInst));
  }
#endif

  // Execute function.
  return ExecutorEngine.invoke(FuncInst, Params, ParamTypes)
      .map_error([&ModInst, &Func](auto E) {
        if (E != ErrCode::Value::Terminated) {
          spdlog::error(ErrInfo::InfoExecuting(ModInst->getModuleName(), Func));
        }
        return E;
      });
}

Expect<std::vector<std::pair<ComponentValVariant, ComponentValType>>>
VM::unsafeExecuteComponent(const Runtime::Instance::ComponentInstance *CompInst,
                           std::string_view Func,
                           Span<const ComponentValVariant> Params,
                           Span<const ComponentValType> ParamTypes) {
  // Find exported function by name.
  Runtime::Instance::Component::FunctionInstance *FuncInst =
      CompInst->findFunction(Func);

  // Execute function.
  return ExecutorEngine.invoke(FuncInst, Params, ParamTypes)
      .map_error([&CompInst, &Func](auto E) {
        if (E != ErrCode::Value::Terminated) {
          spdlog::error(
              ErrInfo::InfoExecuting(CompInst->getComponentName(), Func));
        }
        return E;
      });
}

Async<Expect<std::vector<std::pair<ValVariant, ValType>>>>
VM::asyncExecute(std::string_view Func, Span<const ValVariant> Params,
                 Span<const ValType> ParamTypes) {
  Expect<std::vector<std::pair<ValVariant, ValType>>> (VM::*FPtr)(
      std::string_view, Span<const ValVariant>, Span<const ValType>) =
      &VM::execute;
  return {FPtr, *this, std::string(Func),
          std::vector(Params.begin(), Params.end()),
          std::vector(ParamTypes.begin(), ParamTypes.end())};
}

Async<Expect<std::vector<std::pair<ValVariant, ValType>>>>
VM::asyncExecute(std::string_view ModName, std::string_view Func,
                 Span<const ValVariant> Params,
                 Span<const ValType> ParamTypes) {
  Expect<std::vector<std::pair<ValVariant, ValType>>> (VM::*FPtr)(
      std::string_view, std::string_view, Span<const ValVariant>,
      Span<const ValType>) = &VM::execute;
  return {FPtr,
          *this,
          std::string(ModName),
          std::string(Func),
          std::vector(Params.begin(), Params.end()),
          std::vector(ParamTypes.begin(), ParamTypes.end())};
}

Async<Expect<std::vector<std::pair<ComponentValVariant, ComponentValType>>>>
VM::asyncExecuteComponent(std::string_view Func,
                          Span<const ComponentValVariant> Params,
                          Span<const ComponentValType> ParamTypes) {
  Expect<std::vector<std::pair<ComponentValVariant, ComponentValType>>> (
      VM::*FPtr)(std::string_view, Span<const ComponentValVariant>,
                 Span<const ComponentValType>) = &VM::executeComponent;
  return {FPtr, *this, std::string(Func),
          std::vector(Params.begin(), Params.end()),
          std::vector(ParamTypes.begin(), ParamTypes.end())};
}

Async<Expect<std::vector<std::pair<ComponentValVariant, ComponentValType>>>>
VM::asyncExecuteComponent(std::string_view CompName, std::string_view Func,
                          Span<const ComponentValVariant> Params,
                          Span<const ComponentValType> ParamTypes) {
  Expect<std::vector<std::pair<ComponentValVariant, ComponentValType>>> (
      VM::*FPtr)(std::string_view, std::string_view,
                 Span<const ComponentValVariant>,
                 Span<const ComponentValType>) = &VM::executeComponent;
  return {FPtr,
          *this,
          std::string(CompName),
          std::string(Func),
          std::vector(Params.begin(), Params.end()),
          std::vector(ParamTypes.begin(), ParamTypes.end())};
}

void VM::unsafeCleanup() {
  if (Mod) {
    Mod.reset();
  }
  if (Comp) {
    Comp.reset();
  }
  if (ActiveModInst) {
    auto *RawMod = ActiveModInst.release();
    if (RawMod) {
      RawMod->terminate();
    }
  }
  if (ActiveCompInst) {
    ActiveCompInst.reset();
  }
  StoreRef.reset();
  cleanupModInstContainer(RegModInsts);
  Stat.clear();
  unsafeLoadBuiltInHosts();
  unsafeLoadPlugInHosts();
  unsafeRegisterBuiltInHosts();
  unsafeRegisterPlugInHosts();
  LoaderEngine.reset();
  Stage = VMStage::Inited;
#ifdef WASMEDGE_USE_LLVM
  if (LazyEngine) {
    LazyEngine->clear();
  }
#endif
}

std::vector<std::pair<std::string, const AST::FunctionType &>>
VM::unsafeGetFunctionList() const {
  std::vector<std::pair<std::string, const AST::FunctionType &>> Map;
  if (ActiveModInst) {
    ActiveModInst->getFuncExports([&](const auto &FuncExports) {
      Map.reserve(FuncExports.size());
      for (auto &&Func : FuncExports) {
        const auto &FuncType = (Func.second)->getFuncType();
        Map.emplace_back(Func.first, FuncType);
      }
    });
  }
  return Map;
}

std::vector<std::pair<std::string, const AST::Component::FuncType &>>
VM::unsafeGetComponentFunctionList() const {
  std::vector<std::pair<std::string, const AST::Component::FuncType &>> Map;
  if (ActiveCompInst) {
    ActiveCompInst->getFuncExports([&](const auto &FuncExports) {
      Map.reserve(FuncExports.size());
      for (auto &&Func : FuncExports) {
        const auto &FuncType = (Func.second)->getFuncType();
        Map.emplace_back(Func.first, FuncType);
      }
    });
  }
  return Map;
}

Runtime::Instance::ModuleInstance *
VM::unsafeGetImportModule(const HostRegistration Type) const {
  if (auto Iter = BuiltInModInsts.find(Type); Iter != BuiltInModInsts.cend()) {
    return Iter->second.get();
  }
  return nullptr;
}

const Runtime::Instance::ModuleInstance *VM::unsafeGetActiveModule() const {
  if (ActiveModInst) {
    return ActiveModInst.get();
  }
  return nullptr;
};

} // namespace VM
} // namespace WasmEdge

Coverage Report

Created: 2026-11-12 06:35