module.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_MODULE_HH
#define WASMTIME_MODULE_HH
 
#include <memory>
#include <string_view>
#include <wasmtime/engine.hh>
#include <wasmtime/module.h>
#include <wasmtime/span.hh>
#include <wasmtime/types/export.hh>
#include <wasmtime/types/import.hh>
#include <wasmtime/wat.hh>
 
namespace wasmtime {
 
class Module {
  friend class Store;
  friend class Instance;
  friend class Linker;
 
  struct deleter {
    void operator()(wasmtime_module_t *p) const { wasmtime_module_delete(p); }
  };
 
  std::unique_ptr<wasmtime_module_t, deleter> ptr;
 
  Module(wasmtime_module_t *raw) : ptr(raw) {}
 
public:
  Module(const Module &other) : ptr(wasmtime_module_clone(other.ptr.get())) {}
  Module &operator=(const Module &other) {
    ptr.reset(wasmtime_module_clone(other.ptr.get()));
    return *this;
  }
  ~Module() = default;
  Module(Module &&other) = default;
  Module &operator=(Module &&other) = default;
 
#ifdef WASMTIME_FEATURE_COMPILER
  static Result<Module> compile(Engine &engine, std::string_view wat) {
    auto wasm = wat2wasm(wat);
    if (!wasm) {
      return wasm.err();
    }
    auto bytes = wasm.ok();
    return compile(engine, bytes);
  }
 
  static Result<Module> compile(Engine &engine, Span<uint8_t> wasm) {
    wasmtime_module_t *ret = nullptr;
    auto *error =
        wasmtime_module_new(engine.ptr.get(), wasm.data(), wasm.size(), &ret);
    if (error != nullptr) {
      return Error(error);
    }
    return Module(ret);
  }
 
  static Result<std::monostate> validate(Engine &engine, Span<uint8_t> wasm) {
    auto *error =
        wasmtime_module_validate(engine.ptr.get(), wasm.data(), wasm.size());
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
#endif // WASMTIME_FEATURE_COMPILER
 
  static Result<Module> deserialize(Engine &engine, Span<uint8_t> wasm) {
    wasmtime_module_t *ret = nullptr;
    auto *error = wasmtime_module_deserialize(engine.ptr.get(), wasm.data(),
                                              wasm.size(), &ret);
    if (error != nullptr) {
      return Error(error);
    }
    return Module(ret);
  }
 
  static Result<Module> deserialize_file(Engine &engine,
                                         const std::string &path) {
    wasmtime_module_t *ret = nullptr;
    auto *error =
        wasmtime_module_deserialize_file(engine.ptr.get(), path.c_str(), &ret);
    if (error != nullptr) {
      return Error(error);
    }
    return Module(ret);
  }
 
  ImportType::List imports() const {
    ImportType::List list;
    wasmtime_module_imports(ptr.get(), &list.list);
    return list;
  }
 
  ExportType::List exports() const {
    ExportType::List list;
    wasmtime_module_exports(ptr.get(), &list.list);
    return list;
  }
 
#ifdef WASMTIME_FEATURE_COMPILER
  Result<std::vector<uint8_t>> serialize() const {
    wasm_byte_vec_t bytes;
    auto *error = wasmtime_module_serialize(ptr.get(), &bytes);
    if (error != nullptr) {
      return Error(error);
    }
    std::vector<uint8_t> ret;
    // NOLINTNEXTLINE TODO can this be done without triggering lints?
    Span<uint8_t> raw(reinterpret_cast<uint8_t *>(bytes.data), bytes.size);
    ret.assign(raw.begin(), raw.end());
    wasm_byte_vec_delete(&bytes);
    return ret;
  }
#endif // WASMTIME_FEATURE_COMPILER
 
  const wasmtime_module_t *capi() const { return ptr.get(); }
 
  wasmtime_module_t *capi() { return ptr.get(); }
};
 
} // namespace wasmtime
 
#endif // WASMTIME_MODULE_HH