val.h

Go to the documentation of this file.

 
#ifndef WASMTIME_VAL_H
#define WASMTIME_VAL_H
 
#include <stdalign.h>
#include <wasm.h>
#include <wasmtime/extern.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifdef WASMTIME_FEATURE_GC
typedef struct wasmtime_eqref wasmtime_eqref_t;
 
typedef struct wasmtime_anyref {
  uint64_t store_id;
  uint32_t __private1;
  uint32_t __private2;
  void *__private3;
} wasmtime_anyref_t;
 
static inline void wasmtime_anyref_set_null(wasmtime_anyref_t *ref) {
  ref->store_id = 0;
}
 
static inline bool wasmtime_anyref_is_null(const wasmtime_anyref_t *ref) {
  return ref->store_id == 0;
}
 
WASM_API_EXTERN void wasmtime_anyref_clone(const wasmtime_anyref_t *anyref,
                                           wasmtime_anyref_t *out);
 
WASM_API_EXTERN void wasmtime_anyref_unroot(wasmtime_anyref_t *ref);
 
WASM_API_EXTERN void wasmtime_anyref_from_raw(wasmtime_context_t *context,
                                              uint32_t raw,
                                              wasmtime_anyref_t *out);
 
WASM_API_EXTERN uint32_t wasmtime_anyref_to_raw(wasmtime_context_t *context,
                                                const wasmtime_anyref_t *ref);
 
WASM_API_EXTERN void wasmtime_anyref_from_i31(wasmtime_context_t *context,
                                              uint32_t i31val,
                                              wasmtime_anyref_t *out);
 
WASM_API_EXTERN bool wasmtime_anyref_is_i31(wasmtime_context_t *context,
                                            const wasmtime_anyref_t *anyref);
 
WASM_API_EXTERN bool wasmtime_anyref_i31_get_u(wasmtime_context_t *context,
                                               const wasmtime_anyref_t *anyref,
                                               uint32_t *dst);
 
WASM_API_EXTERN bool wasmtime_anyref_i31_get_s(wasmtime_context_t *context,
                                               const wasmtime_anyref_t *anyref,
                                               int32_t *dst);
 
typedef struct wasmtime_externref {
  uint64_t store_id;
  uint32_t __private1;
  uint32_t __private2;
  void *__private3;
} wasmtime_externref_t;
 
static inline void wasmtime_externref_set_null(wasmtime_externref_t *ref) {
  ref->store_id = 0;
}
 
static inline bool wasmtime_externref_is_null(const wasmtime_externref_t *ref) {
  return ref->store_id == 0;
}
 
WASM_API_EXTERN bool wasmtime_externref_new(wasmtime_context_t *context,
                                            void *data,
                                            void (*finalizer)(void *),
                                            wasmtime_externref_t *out);
 
WASM_API_EXTERN void *wasmtime_externref_data(wasmtime_context_t *context,
                                              const wasmtime_externref_t *data);
 
WASM_API_EXTERN void wasmtime_externref_clone(const wasmtime_externref_t *ref,
                                              wasmtime_externref_t *out);
 
WASM_API_EXTERN void wasmtime_externref_unroot(wasmtime_externref_t *ref);
 
WASM_API_EXTERN void wasmtime_externref_from_raw(wasmtime_context_t *context,
                                                 uint32_t raw,
                                                 wasmtime_externref_t *out);
 
WASM_API_EXTERN uint32_t wasmtime_externref_to_raw(
    wasmtime_context_t *context, const wasmtime_externref_t *ref);
 
typedef struct wasmtime_exnref {
  uint64_t store_id;
  uint32_t __private1;
  uint32_t __private2;
  void *__private3;
} wasmtime_exnref_t;
 
static inline void wasmtime_exnref_set_null(wasmtime_exnref_t *ref) {
  ref->store_id = 0;
}
 
static inline bool wasmtime_exnref_is_null(const wasmtime_exnref_t *ref) {
  return ref->store_id == 0;
}
 
WASM_API_EXTERN void wasmtime_exnref_clone(const wasmtime_exnref_t *ref,
                                           wasmtime_exnref_t *out);
 
WASM_API_EXTERN void wasmtime_exnref_unroot(wasmtime_exnref_t *ref);
#endif // WASMTIME_FEATURE_GC
 
typedef uint8_t wasmtime_valkind_t;
#define WASMTIME_I32 0
#define WASMTIME_I64 1
#define WASMTIME_F32 2
#define WASMTIME_F64 3
#define WASMTIME_V128 4
#define WASMTIME_FUNCREF 5
#define WASMTIME_EXTERNREF 6
#define WASMTIME_ANYREF 7
#define WASMTIME_EXNREF 8
 
typedef uint8_t wasmtime_v128[16];
 
typedef union wasmtime_valunion {
  int32_t i32;
  int64_t i64;
  float32_t f32;
  float64_t f64;
#ifdef WASMTIME_FEATURE_GC
  wasmtime_anyref_t anyref;
  wasmtime_externref_t externref;
  wasmtime_exnref_t exnref;
  wasmtime_func_t funcref;
#endif // WASMTIME_FEATURE_GC
  wasmtime_v128 v128;
} wasmtime_valunion_t;
 
static inline void wasmtime_funcref_set_null(wasmtime_func_t *func) {
  func->store_id = 0;
}
 
static inline bool wasmtime_funcref_is_null(const wasmtime_func_t *func) {
  return func->store_id == 0;
}
 
typedef union wasmtime_val_raw {
  int32_t i32;
  int64_t i64;
  float32_t f32;
  float64_t f64;
  wasmtime_v128 v128;
  uint32_t anyref;
  uint32_t externref;
  void *funcref;
} wasmtime_val_raw_t;
 
// Assert that the shape of this type is as expected since it needs to match
// Rust.
static inline void __wasmtime_val_assertions() {
  static_assert(sizeof(wasmtime_valunion_t) >= 16 &&
                    sizeof(wasmtime_valunion_t) <= 24,
                "should be 16 bytes plus a pointer large (plus alignment on "
                "some platforms)");
  static_assert(__alignof(wasmtime_valunion_t) == 8,
                "should be 8-byte aligned");
  static_assert(sizeof(wasmtime_val_raw_t) == 16, "should be 16 bytes large");
  static_assert(__alignof(wasmtime_val_raw_t) == 8, "should be 8-byte aligned");
}
 
typedef struct wasmtime_val {
  wasmtime_valkind_t kind;
  wasmtime_valunion_t of;
} wasmtime_val_t;
 
WASM_API_EXTERN void wasmtime_val_unroot(wasmtime_val_t *val);
 
WASM_API_EXTERN void wasmtime_val_clone(const wasmtime_val_t *src,
                                        wasmtime_val_t *dst);
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#endif // WASMTIME_VAL_H