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/conf.h>
#include <wasmtime/extern.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
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
 
#ifdef WASMTIME_FEATURE_GC
#define WASMTIME_EXTERNREF 6
#define WASMTIME_ANYREF 7
#define WASMTIME_EXNREF 8
#endif // WASMTIME_FEATURE_GC
 
typedef uint8_t wasmtime_v128[16];
 
#ifdef WASMTIME_FEATURE_GC
typedef struct wasmtime_anyref {
  uint64_t store_id;
  uint32_t __private1;
  uint32_t __private2;
  void *__private3;
} wasmtime_anyref_t;
 
typedef struct wasmtime_exnref {
  uint64_t store_id;
  uint32_t __private1;
  uint32_t __private2;
  void *__private3;
} wasmtime_exnref_t;
 
typedef struct wasmtime_externref {
  uint64_t store_id;
  uint32_t __private1;
  uint32_t __private2;
  void *__private3;
} wasmtime_externref_t;
 
typedef struct wasmtime_eqref {
  uint64_t store_id;
  uint32_t __private1;
  uint32_t __private2;
  void *__private3;
} wasmtime_eqref_t;
 
typedef struct wasmtime_structref {
  uint64_t store_id;
  uint32_t __private1;
  uint32_t __private2;
  void *__private3;
} wasmtime_structref_t;
 
typedef struct wasmtime_arrayref {
  uint64_t store_id;
  uint32_t __private1;
  uint32_t __private2;
  void *__private3;
} wasmtime_arrayref_t;
 
#endif // WASMTIME_FEATURE_GC
 
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;
#endif // WASMTIME_FEATURE_GC
  wasmtime_func_t funcref;
  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;
#ifdef WASMTIME_FEATURE_GC
  uint32_t anyref;
  uint32_t externref;
  uint32_t exnref;
#endif // WASMTIME_FEATURE_GC
  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