wasmtime_c_api/
linker.rs

Help
1use crate::{
2    bad_utf8, handle_result, wasm_engine_t, wasm_functype_t, wasm_trap_t, wasmtime_error_t,
3    wasmtime_extern_t, wasmtime_instance_pre_t, wasmtime_module_t, WasmtimeStoreContext,
4    WasmtimeStoreContextMut,
5};
6use std::ffi::c_void;
7use std::mem::MaybeUninit;
8use std::str;
9use wasmtime::{Func, Instance, Linker};
10
11#[repr(C)]
12pub struct wasmtime_linker_t {
13    pub(crate) linker: Linker<crate::WasmtimeStoreData>,
14}
15
16wasmtime_c_api_macros::declare_own!(wasmtime_linker_t);
17
18#[unsafe(no_mangle)]
19pub extern "C" fn wasmtime_linker_new(engine: &wasm_engine_t) -> Box<wasmtime_linker_t> {
20    Box::new(wasmtime_linker_t {
21        linker: Linker::new(&engine.engine),
22    })
23}
24
25#[unsafe(no_mangle)]
26pub extern "C" fn wasmtime_linker_clone(linker: &wasmtime_linker_t) -> Box<wasmtime_linker_t> {
27    Box::new(wasmtime_linker_t {
28        linker: linker.linker.clone(),
29    })
30}
31
32#[unsafe(no_mangle)]
33pub extern "C" fn wasmtime_linker_allow_shadowing(
34    linker: &mut wasmtime_linker_t,
35    allow_shadowing: bool,
36) {
37    linker.linker.allow_shadowing(allow_shadowing);
38}
39
40macro_rules! to_str {
41    ($ptr:expr, $len:expr) => {
42        match str::from_utf8(crate::slice_from_raw_parts($ptr, $len)) {
43            Ok(s) => s,
44            Err(_) => return bad_utf8(),
45        }
46    };
47}
48
49pub(crate) use to_str;
50
51#[unsafe(no_mangle)]
52pub unsafe extern "C" fn wasmtime_linker_define(
53    linker: &mut wasmtime_linker_t,
54    store: WasmtimeStoreContext<'_>,
55    module: *const u8,
56    module_len: usize,
57    name: *const u8,
58    name_len: usize,
59    item: &wasmtime_extern_t,
60) -> Option<Box<wasmtime_error_t>> {
61    let linker = &mut linker.linker;
62    let module = to_str!(module, module_len);
63    let name = to_str!(name, name_len);
64    let item = item.to_extern();
65    handle_result(linker.define(&store, module, name, item), |_linker| ())
66}
67
68#[unsafe(no_mangle)]
69pub unsafe extern "C" fn wasmtime_linker_define_func(
70    linker: &mut wasmtime_linker_t,
71    module: *const u8,
72    module_len: usize,
73    name: *const u8,
74    name_len: usize,
75    ty: &wasm_functype_t,
76    callback: crate::wasmtime_func_callback_t,
77    data: *mut c_void,
78    finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
79) -> Option<Box<wasmtime_error_t>> {
80    let ty = ty.ty().ty(linker.linker.engine());
81    let module = to_str!(module, module_len);
82    let name = to_str!(name, name_len);
83    let cb = crate::func::c_callback_to_rust_fn(callback, data, finalizer);
84    handle_result(linker.linker.func_new(module, name, ty, cb), |_linker| ())
85}
86
87#[unsafe(no_mangle)]
88pub unsafe extern "C" fn wasmtime_linker_define_func_unchecked(
89    linker: &mut wasmtime_linker_t,
90    module: *const u8,
91    module_len: usize,
92    name: *const u8,
93    name_len: usize,
94    ty: &wasm_functype_t,
95    callback: crate::wasmtime_func_unchecked_callback_t,
96    data: *mut c_void,
97    finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
98) -> Option<Box<wasmtime_error_t>> {
99    let ty = ty.ty().ty(linker.linker.engine());
100    let module = to_str!(module, module_len);
101    let name = to_str!(name, name_len);
102    let cb = crate::func::c_unchecked_callback_to_rust_fn(callback, data, finalizer);
103    handle_result(
104        linker.linker.func_new_unchecked(module, name, ty, cb),
105        |_linker| (),
106    )
107}
108
109#[cfg(feature = "wasi")]
110#[unsafe(no_mangle)]
111pub extern "C" fn wasmtime_linker_define_wasi(
112    linker: &mut wasmtime_linker_t,
113) -> Option<Box<wasmtime_error_t>> {
114    handle_result(
115        wasmtime_wasi::preview1::add_to_linker_sync(&mut linker.linker, |ctx| {
116            ctx.wasi.as_mut().expect("wasi context must be populated")
117        }),
118        |_linker| (),
119    )
120}
121
122#[unsafe(no_mangle)]
123pub unsafe extern "C" fn wasmtime_linker_define_instance(
124    linker: &mut wasmtime_linker_t,
125    store: WasmtimeStoreContextMut<'_>,
126    name: *const u8,
127    name_len: usize,
128    instance: &Instance,
129) -> Option<Box<wasmtime_error_t>> {
130    let linker = &mut linker.linker;
131    let name = to_str!(name, name_len);
132    handle_result(linker.instance(store, name, *instance), |_linker| ())
133}
134
135#[unsafe(no_mangle)]
136pub extern "C" fn wasmtime_linker_instantiate(
137    linker: &wasmtime_linker_t,
138    store: WasmtimeStoreContextMut<'_>,
139    module: &wasmtime_module_t,
140    instance_ptr: &mut Instance,
141    trap_ptr: &mut *mut wasm_trap_t,
142) -> Option<Box<wasmtime_error_t>> {
143    let result = linker.linker.instantiate(store, &module.module);
144    super::instance::handle_instantiate(result, instance_ptr, trap_ptr)
145}
146
147#[unsafe(no_mangle)]
148pub unsafe extern "C" fn wasmtime_linker_instantiate_pre(
149    linker: &wasmtime_linker_t,
150    module: &wasmtime_module_t,
151    instance_ptr: &mut *mut wasmtime_instance_pre_t,
152) -> Option<Box<wasmtime_error_t>> {
153    let linker = &linker.linker;
154    handle_result(linker.instantiate_pre(&module.module), |i| {
155        let instance_pre = Box::new(wasmtime_instance_pre_t { underlying: i });
156        *instance_ptr = Box::into_raw(instance_pre)
157    })
158}
159
160#[unsafe(no_mangle)]
161pub unsafe extern "C" fn wasmtime_linker_module(
162    linker: &mut wasmtime_linker_t,
163    store: WasmtimeStoreContextMut<'_>,
164    name: *const u8,
165    name_len: usize,
166    module: &wasmtime_module_t,
167) -> Option<Box<wasmtime_error_t>> {
168    let linker = &mut linker.linker;
169    let name = to_str!(name, name_len);
170    handle_result(linker.module(store, name, &module.module), |_linker| ())
171}
172
173#[unsafe(no_mangle)]
174pub unsafe extern "C" fn wasmtime_linker_get_default(
175    linker: &wasmtime_linker_t,
176    store: WasmtimeStoreContextMut<'_>,
177    name: *const u8,
178    name_len: usize,
179    func: &mut Func,
180) -> Option<Box<wasmtime_error_t>> {
181    let linker = &linker.linker;
182    let name = to_str!(name, name_len);
183    handle_result(linker.get_default(store, name), |f| *func = f)
184}
185
186#[unsafe(no_mangle)]
187pub unsafe extern "C" fn wasmtime_linker_get(
188    linker: &wasmtime_linker_t,
189    store: WasmtimeStoreContextMut<'_>,
190    module: *const u8,
191    module_len: usize,
192    name: *const u8,
193    name_len: usize,
194    item_ptr: &mut MaybeUninit<wasmtime_extern_t>,
195) -> bool {
196    let linker = &linker.linker;
197    let module = match str::from_utf8(crate::slice_from_raw_parts(module, module_len)) {
198        Ok(s) => s,
199        Err(_) => return false,
200    };
201    let name = match str::from_utf8(crate::slice_from_raw_parts(name, name_len)) {
202        Ok(s) => s,
203        Err(_) => return false,
204    };
205    match linker.get(store, module, name) {
206        Some(which) => {
207            crate::initialize(item_ptr, which.into());
208            true
209        }
210        None => false,
211    }
212}
wasmtime_c_api/linker.rs

wasmtime_c_api/
linker.rs
