Wasmtime bindings for Zig
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

214 lines
9.6 KiB

const Error = @import("./error.zig").Error;
/// Global configuration options used to create an `Engine` and customize its
/// behavior. This is exposed as a builder-like interface and is primarily
/// consumed by `Engine.init`.
///
/// The validation of `Config` is deferred until the engine is being built,
/// thus a problematic config may cause `Engine.init` to fail.
///
/// For more information on what each of these settings do and their default
/// values, see https://docs.rs/wasmtime/11.0.1/wasmtime/struct.Config.html.
pub const Config = opaque {
/// Creates a new empty configuration object.
///
/// The object returned is owned by the caller and will need to be deleted with `deinit`.
///
/// May return `error.ConfigInit` if a configuration object could not be allocated.
pub fn init() !*Config {
return wasm_config_new() orelse error.ConfigInit;
}
/// Deletes a configuration object.
pub fn deinit(self: *Config) void {
wasm_config_delete(self);
}
/// Configures whether DWARF debug information will be emitted during compilation.
pub fn debugInfo(self: *Config, enabled: bool) void {
wasmtime_config_debug_info_set(self, enabled);
}
/// Configures whether execution of WebAssembly will “consume fuel” to
/// either halt or yield execution as desired.
pub fn comsumeFuel(self: *Config, enabled: bool) void {
wasmtime_config_consume_fuel_set(self, enabled);
}
/// Configures whether to enable epoch-based interruption.
pub fn epochInterruption(self: *Config, enabled: bool) void {
wasmtime_config_epoch_interruption_set(self, enabled);
}
/// Configures the maximum amount of stack space available for executing WebAssembly code.
pub fn maxWasmStack(self: *Config, value: usize) void {
wasmtime_config_max_wasm_stack_set(self, value);
}
/// Configures whether the WebAssembly threads proposal will be enabled for compilation.
pub fn wasmThreads(self: *Config, enabled: bool) void {
wasmtime_config_wasm_threads_set(self, enabled);
}
/// Configures whether the WebAssembly reference types proposal will be enabled for compilation.
pub fn wasmReferenceTypes(self: *Config, enabled: bool) void {
wasmtime_config_wasm_reference_types_set(self, enabled);
}
/// Configures whether the WebAssembly SIMD proposal will be enabled for compilation.
pub fn wasmSimd(self: *Config, enabled: bool) void {
wasmtime_config_wasm_simd_set(self, enabled);
}
/// Configures whether the WebAssembly Relaxed SIMD proposal will be enabled for compilation.
pub fn wasmRelaxedSimd(self: *Config, enabled: bool) void {
wasmtime_config_wasm_relaxed_simd_set(self, enabled);
}
/// This option can be used to control the behavior of the relaxed SIMD proposal’s instructions.
pub fn wasmRelaxedSimdDeterministic(self: *Config, enabled: bool) void {
wasmtime_config_wasm_relaxed_simd_deterministic_set(self, enabled);
}
/// Configures whether the WebAssembly bulk memory operations proposal will be enabled for compilation.
pub fn wasmBulkMemory(self: *Config, enabled: bool) void {
wasmtime_config_wasm_bulk_memory_set(self, enabled);
}
/// Configures whether the WebAssembly multi-value proposal will be enabled for compilation.
pub fn wasmMultiValue(self: *Config, enabled: bool) void {
wasmtime_config_wasm_multi_value_set(self, enabled);
}
/// Configures whether the WebAssembly multi-memory proposal will be enabled for compilation.
pub fn wasmMultiMemory(self: *Config, enabled: bool) void {
wasmtime_config_wasm_multi_memory_set(self, enabled);
}
/// Configures whether the WebAssembly memory64 proposal will be enabled for compilation.
pub fn wasmMemory64(self: *Config, enabled: bool) void {
wasmtime_config_wasm_memory64_set(self, enabled);
}
/// Configures which compilation strategy will be used for wasm modules.
pub fn strategy(self: *Config, value: Strategy) void {
wasmtime_config_strategy_set(self, value);
}
/// Creates a default profiler based on the profiling strategy chosen.
pub fn profiler(self: *Config, value: ProfilingStrategy) void {
wasmtime_config_profiler_set(self, value);
}
/// Configures whether the debug verifier of Cranelift is enabled or not.
pub fn craneliftDebugVerifier(self: *Config, enabled: bool) void {
wasmtime_config_cranelift_debug_verifier_set(self, enabled);
}
/// Configures whether Cranelift should perform a NaN-canonicalization pass.
pub fn craneliftNanCanonicalization(self: *Config, enabled: bool) void {
wasmtime_config_cranelift_nan_canonicalization_set(self, enabled);
}
/// Configures the Cranelift code generator optimization level.
pub fn craneliftOptLevel(self: *Config, value: OptLevel) void {
wasmtime_config_cranelift_opt_level_set(self, value);
}
/// Configure wether wasmtime should compile a module using multiple threads.
pub fn parallelCompilation(self: *Config, enabled: bool) void {
wasmtime_config_parallel_compilation_set(self, enabled);
}
/// Indicates that the “static” style of memory should always be used.
pub fn staticMemoryForced(self: *Config, enabled: bool) void {
wasmtime_config_static_memory_forced_set(self, enabled);
}
/// Configures the maximum size, in bytes, where a linear memory is
/// considered static, above which it’ll be considered dynamic.
pub fn staticMemoryMaximumSize(self: *Config, value: u64) void {
wasmtime_config_static_memory_maximum_size_set(self, value);
}
/// Configures the size, in bytes, of the guard region used at the end of
/// a static memory’s address space reservation.
pub fn staticMemoryGuardMaximumSize(self: *Config, value: u64) void {
wasmtime_config_static_memory_guard_size_set(self, value);
}
/// Configures the size, in bytes, of the guard region used at the end of
/// a dynamic memory’s address space reservation.
pub fn dynamicMemoryGuardMaximumSize(self: *Config, value: u64) void {
wasmtime_config_dynamic_memory_guard_size_set(self, value);
}
extern "c" fn wasm_config_new() ?*Config;
extern "c" fn wasm_config_delete(*Config) void;
extern "c" fn wasmtime_config_debug_info_set(*Config, bool) void;
extern "c" fn wasmtime_config_consume_fuel_set(*Config, bool) void;
extern "c" fn wasmtime_config_epoch_interruption_set(*Config, bool) void;
extern "c" fn wasmtime_config_max_wasm_stack_set(*Config, usize) void;
extern "c" fn wasmtime_config_wasm_threads_set(*Config, bool) void;
extern "c" fn wasmtime_config_wasm_reference_types_set(*Config, bool) void;
extern "c" fn wasmtime_config_wasm_simd_set(*Config, bool) void;
extern "c" fn wasmtime_config_wasm_relaxed_simd_set(*Config, bool) void;
extern "c" fn wasmtime_config_wasm_relaxed_simd_deterministic_set(*Config, bool) void;
extern "c" fn wasmtime_config_wasm_bulk_memory_set(*Config, bool) void;
extern "c" fn wasmtime_config_wasm_multi_value_set(*Config, bool) void;
extern "c" fn wasmtime_config_wasm_multi_memory_set(*Config, bool) void;
extern "c" fn wasmtime_config_wasm_memory64_set(*Config, bool) void;
extern "c" fn wasmtime_config_strategy_set(*Config, Strategy) void;
extern "c" fn wasmtime_config_parallel_compilation_set(*Config, bool) void;
extern "c" fn wasmtime_config_cranelift_debug_verifier_set(*Config, bool) void;
extern "c" fn wasmtime_config_cranelift_nan_canonicalization_set(*Config, bool) void;
extern "c" fn wasmtime_config_cranelift_opt_level_set(*Config, OptLevel) void;
extern "c" fn wasmtime_config_profiler_set(*Config, ProfilingStrategy) void;
extern "c" fn wasmtime_config_static_memory_forced_set(*Config, bool) void;
extern "c" fn wasmtime_config_static_memory_maximum_size_set(*Config, u64) void;
extern "c" fn wasmtime_config_static_memory_guard_size_set(*Config, u64) void;
extern "c" fn wasmtime_config_dynamic_memory_guard_size_set(*Config, u64) void;
// extern "c" fn wasmtime_config_cache_config_load(*Config, [*:0]const u8) ?*Error;
};
/// Different ways that Wasmtime can compile WebAssembly.
/// The default value is `.auto`.
pub const Strategy = enum(u8) {
/// Automatically picks the compilation backend, currently always
/// defaulting to Cranelift.
auto,
/// Indicates that Wasmtime will unconditionally use Cranelift to compile
/// WebAssembly code.
cranelift,
};
/// Different ways Wasmtime can optimize generated code.
/// The default value is `.speed`.
pub const OptLevel = enum(u8) {
/// Generated code will not be optimized at all.
none,
/// Generated code will be optimized purely for speed.
speed,
/// Generated code will be optimized, but some speed optimizations are
/// disabled if they cause the generated code to be significantly larger.
speed_and_size,
};
/// Different ways to profile JIT code.
/// The default value is `.none`.
pub const ProfilingStrategy = enum(u8) {
/// No profiling is enabled at runtime.
none,
/// Linux's "jitdump" support in `perf` is enabled and when Wasmtime is
/// run under `perf` necessary calls will be made to profile generated JIT
/// code.
jitdump,
/// Support for VTune will be enabled and the VTune runtime will be
/// informed, at runtime, about JIT code. Note that this isn't always
/// enabled at build time.
vtune,
/// Linux's simple "perfmap" support in `perf` is enabled and when
/// Wasmtime is run under `perf` necessary calls will be made to profile
/// generated JIT code.
perfmap,
};