trap.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_TRAP_HH
#define WASMTIME_TRAP_HH
 
#include <wasmtime/error.hh>
#include <wasmtime/trap.h>
 
namespace wasmtime {
 
class FrameRef {
  wasm_frame_t *frame;
 
public:
  uint32_t func_index() const { return wasm_frame_func_index(frame); }
  size_t func_offset() const { return wasm_frame_func_offset(frame); }
  size_t module_offset() const { return wasm_frame_module_offset(frame); }
 
  std::optional<std::string_view> func_name() const {
    const auto *name = wasmtime_frame_func_name(frame);
    if (name != nullptr) {
      return std::string_view(name->data, name->size);
    }
    return std::nullopt;
  }
 
  std::optional<std::string_view> module_name() const {
    const auto *name = wasmtime_frame_module_name(frame);
    if (name != nullptr) {
      return std::string_view(name->data, name->size);
    }
    return std::nullopt;
  }
};
 
class Trace {
  friend class Trap;
  friend class Error;
 
  wasm_frame_vec_t vec;
 
  Trace(wasm_frame_vec_t vec) : vec(vec) {}
 
public:
  ~Trace() { wasm_frame_vec_delete(&vec); }
 
  Trace(const Trace &other) = delete;
  Trace(Trace &&other) = delete;
  Trace &operator=(const Trace &other) = delete;
  Trace &operator=(Trace &&other) = delete;
 
  typedef const FrameRef *iterator;
 
  iterator begin() const {
    return reinterpret_cast<FrameRef *>(&vec.data[0]); // NOLINT
  }
  iterator end() const {
    return reinterpret_cast<FrameRef *>(&vec.data[vec.size]); // NOLINT
  }
  size_t size() const { return vec.size; }
};
 
inline Trace Error::trace() const {
  wasm_frame_vec_t frames;
  wasmtime_error_wasm_trace(ptr.get(), &frames);
  return Trace(frames);
}
 
class Trap {
  friend class Linker;
  friend class Instance;
  friend class Func;
  template <typename Params, typename Results> friend class TypedFunc;
 
  struct deleter {
    void operator()(wasm_trap_t *p) const { wasm_trap_delete(p); }
  };
 
  std::unique_ptr<wasm_trap_t, deleter> ptr;
 
  Trap(wasm_trap_t *ptr) : ptr(ptr) {}
 
public:
  explicit Trap(std::string_view msg)
      : Trap(wasmtime_trap_new(msg.data(), msg.size())) {}
 
  std::string message() const {
    wasm_byte_vec_t msg;
    wasm_trap_message(ptr.get(), &msg);
    std::string ret(msg.data, msg.size - 1);
    wasm_byte_vec_delete(&msg);
    return ret;
  }
 
  Trace trace() const {
    wasm_frame_vec_t frames;
    wasm_trap_trace(ptr.get(), &frames);
    return Trace(frames);
  }
 
  std::optional<wasmtime_trap_code_t> code() const {
    wasmtime_trap_code_t code;
    bool present = wasmtime_trap_code(ptr.get(), &code);
    if (present)
      return code;
    return std::nullopt;
  }
};
 
struct TrapError {
  std::variant<Trap, Error> data;
 
  TrapError(Trap t) : data(std::move(t)) {}
  TrapError(Error e) : data(std::move(e)) {}
 
  std::string message() const {
    if (const auto *trap = std::get_if<Trap>(&data)) {
      return trap->message();
    }
    if (const auto *error = std::get_if<Error>(&data)) {
      return std::string(error->message());
    }
    std::abort();
  }
};
 
template <typename T> using TrapResult = Result<T, TrapError>;
 
} // namespace wasmtime
 
#endif // WASMTIME_TRAP_HH