wasmtime_c_api/
linker.rs

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

wasmtime_c_api/
linker.rs
