Changes in linker.rs

439de7fb - Handle OOM in the rest of Wasmtime's non-component, -async, -compilation APIs (#12858)

Mon, 30 Mar 2026 18:35:31 +0000

Handle OOM in the rest of Wasmtime's non-component, -async, -compilation APIs (#12858)* Handle OOM in more places in the public APIA bunch of random places:* Add: `Trap::try_new` to handle OOM while creating traps* Use: `TryVec` inside `Func::call_impl_do_call` and `wasm_val_raw_storage` to hold the args and rets* Add: `Instance::try_exports` for iterating over an instance's exports while handling OOM* `Linker:try_get`, like `Linker::get` but handling OOM* `Linker:try_get_by_import`, like `Linker::get_by_import` but handling OOM* Use `try_new` to box things in `SharedMemory::new`* Use `TryVec` instead of `Vec` in our dynamic tables* Add OOM tests for most of Wasmtime's public APIExcludes component-, async-, and compilation-related APIs.* address review feedback* fix test compilation* fix c-api List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

cde2e04f - Fill out more of the C++ API for components (#11889)

Tue, 21 Oct 2025 19:27:10 +0000

Fill out more of the C++ API for components (#11889)* capi: Add a C++ API for `component::Linker`Just a bare-bones API for now with functionality that's possible to fillout. Notably instantiation and defining functions is not yet possible inC++. Some more feature-parity is also added with the core linkers aswell.* capi: Add bindings for component instances* capi: Delete wasip2.h header fileUpon reflection I realize that this is not actually necessary and isotherwise a duplicate of the functionality in `wasi.h`. All of thefunctionality in `wasi.h` is already supported to power WASIp2-definedAPIs in a linker, which is enabled by the `WasiView` trait redirectingto the `WasiView for WasiP1Ctx` implementation. This is similar to howthe `wasmtime` CLI works where a P1 context is always created and thenit's conditionally used for either core wasm or components.Effectively this is a deletion of duplicate functionality in the C APIbut no underlying functionality is lost. Translating information topreexisting WASI calls will work the same as using the wasip2 APIs before.* capi: Start bindings for component functions* capi: Bind component values in the C++ API* capi: Finish bindings for component functions/linkersAll the pieces are now in place to use the C++ API in testing.* Fix compilation of CLI* Fix compile on MSVC* Try again to fix msvc compat* Fix `get_f32` and `get_f64` return values* Fix signed return values* Remove no-longer-needed `capi_transfer` function* Try to fix msvc again* Remove std::optional constructor of `Val`* Fix another namespace clash on msvc* One day I surely may understand a fraction of either C++ or MSVC, buttoday is not that day.* Document internal macro* Add other internal docs List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

4f2fa154 - Update nightly Rust used in CI (#11755)

Mon, 29 Sep 2025 18:12:14 +0000

Update nightly Rust used in CI (#11755)* Update nightly Rust used in CIKeeping it up-to-dateprtest:full* Fix unused warnings on nightly* Rename rustdoc feature* Adjust some removals List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

4ac219fd - Rename "preview{0,1}" in `wasmtime-wasi` to "p{0,1}" (#11380)

Tue, 05 Aug 2025 18:48:22 +0000

Rename "preview{0,1}" in `wasmtime-wasi` to "p{0,1}" (#11380)* Rename "preview{0,1}" in `wasmtime-wasi` to "p{0,1}"This commit renames the `preview1` module and features to `p1` and doesthe same for `preview0`. This additionally cleans up the test suite abit to share more code amongst all the implementaitons and to also movethe p1 tests out of the p2 folder.This additionally adds a `p2` feature to the `wasmtime-wasi` crate butit does not currently gate the `p2` module because that'll require somemore refactoring an annotations to get that working.* Fix build of the CLI* Fix build of the C API* Fix bench-api build* Fix build of examples* More renamings List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

90ac295e - Update Wasmtime to the 2024 Rust Edition (#10806)

Mon, 19 May 2025 16:40:55 +0000

Update Wasmtime to the 2024 Rust Edition (#10806)* Update Wasmtime to the 2024 Rust EditionNow that our MSRV supports the 2024 edition it's possible to make thisswitch. This commit moves Wasmtime to the 2024 Edition to keepup-to-date with Rust idioms and access many of the edition featuresexclusive to the 2024 edition.prtest:full* Reformat with the 2024 edition List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

ae84e6ed - Enable `unsafe-attr-outside-unsafe` 2024 edition lint (#9964)

Thu, 09 Jan 2025 21:05:55 +0000

Enable `unsafe-attr-outside-unsafe` 2024 edition lint (#9964)* Enable `unsafe-attr-outside-unsafe` 2024 edition lintThis commit enables the `unsafe-attr-outside-unsafe` lint in rustc usedin transitioning to the 2024 edition. This requires that the`#[no_mangle]` attribute is replaced in favor of `#[unsafe(no_mangle)]`.This mostly affects the C API of wasmtime and most of the changes hereare a simple search/replace.* Another attribute update* Fix command adapter build List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

0c62d931 - wasmtime-c-api: switch from wasi-common to wasmtime-wasi (#8066)

Fri, 12 Apr 2024 20:54:53 +0000

wasmtime-c-api: switch from wasi-common to wasmtime-wasi (#8066)* wasmtime-c-api: switch from using wasi-common to wasmtime-wasi* Fix WasiP1Ctx references, and stop eagerly opening dirs for preopens* Add OutputFile to skip async writes in stdout/stderr---------Co-authored-by: Trevor Elliott List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

420fc3d1 - c-api: Better differentiate between `wasm.h` and `wasmtime.h` APIs (#8344)

Fri, 12 Apr 2024 14:35:48 +0000

c-api: Better differentiate between `wasm.h` and `wasmtime.h` APIs (#8344)This renames some types and adds some type aliases to help us better distinguishbetween `wasm.h` APIs and `wasmtime.h` APIs, primarily for `Store`-relatedtypes. In general, `WasmFoo` is related to `wasm.h` and `WasmtimeFoo` is relatedto `wasmtime.h`.* `StoreRef` -> `WasmStoreRef`* Introduce the `WasmStore[Data]` and `WasmStoreContext[Mut]` aliases* `StoreData` -> `WasmtimeStoreData`* `CStoreContext[Mut]` -> `WasmtimeStoreContext[Mut]`* Introduce the `Wasmtime{Store,Caller}` aliases List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

55bd797a - Extend C API with interfaces needed to use threads (#7940)

Fri, 08 Mar 2024 01:55:34 +0000

Extend C API with interfaces needed to use threads (#7940) List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

a56bd5e4 - Promote wasmtime-wasi::preview2 to root of crate (#7933)

Wed, 21 Feb 2024 00:09:53 +0000

Promote wasmtime-wasi::preview2 to root of crate (#7933)* better top matter* eliminate wasi-common deprecations from wasmtime-wasi* wasmtime-wasi: preview2 feature always enabled, so just eliminate it* rename preview1-on-preview2 feature to just preview1* wasi-http fix* dep fixes. change some log::debug! to tracing::debug!* mv preview2 up to rootand `sed -i 's/crate::preview2/crate/g' **/*.rs`* fix tests too* fixes throughout wasmtime-wasi-http* cli: s/wasmtime_wasi::preview2/wasmtime_wasi* rustfmt* fix wasi-async example* fix docs build (needs wasi-common built to compile examples)* c-api: use wasi-common directlyi guess we didnt build the c-api in CI with deprecation warnings deniedprtest:full* fix example required-features* fix examples CMakeLists build List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

8652011f - Refactor `wasmtime::FuncType` to hold a handle to its registered type (#7892)

Fri, 09 Feb 2024 21:07:52 +0000

Refactor `wasmtime::FuncType` to hold a handle to its registered type (#7892)* Refactor `wasmtime::FuncType` to hold a handle to its registered typeRather than holding a copy of the type directly, it now holds a `RegisteredType`which internally is* A `VMSharedTypeIndex` pointing into the engine's types registry.* An `Arc` handle to the engine's type registry.* An `Arc` handle to the actual type.The last exists only to keep it so that accessing a `wasmtime::FuncType`'sparameters and results fast, avoiding any new locking on call hot paths.This is helping set the stage for further types and `TypeRegistry` refactorsneeded for Wasm GC.* Update the C API for the function types refactorprtest:full* rustfmt* Fix benches build List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

ec07c89b - c-api: Support InstancePre (#7140)

Tue, 03 Oct 2023 17:51:07 +0000

c-api: Support InstancePre (#7140)* c-api: Support InstancePreSigned-off-by: Tyler Rockwood * c-api: Consolidate all the instance_pre functionalitySigned-off-by: Tyler Rockwood * c-api: Add async instantiate support to pre instancesSigned-off-by: Tyler Rockwood * c-api: Add star to comment for doxygenprtest:fullSigned-off-by: Tyler Rockwood ---------Signed-off-by: Tyler Rockwood List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

37cf8e1e - Async support in the C API (#7106)

Tue, 03 Oct 2023 13:42:56 +0000

Async support in the C API (#7106)* c-api: Add a feature for asyncSigned-off-by: Tyler Rockwood * c-api: Add support for async configSigned-off-by: Tyler Rockwood * c-api: Add support for calling async functionsSigned-off-by: Tyler Rockwood * c-api: Add ability to yield execution of Wasm in a storeSigned-off-by: Tyler Rockwood * c-api: Introduce wasmtime_linker_instantiate_asyncSigned-off-by: Tyler Rockwood * c-api: Support defining async host functionsSigned-off-by: Tyler Rockwood * gitignore: ignore cmake cache for examplesSigned-off-by: Tyler Rockwood * examples: Add example of async API in CSigned-off-by: Tyler Rockwood * c-api: Consolidate async functionality into a single placePut all the async stuff in it's own header and own rust source fileAlso remove the wasmtime_async_continuation_new function, users can justallocate it directly.Signed-off-by: Tyler Rockwood * c-api: Make async function safeSigned-off-by: Tyler Rockwood * c-api: Remove wasmtime_call_future_get_resultsSigned-off-by: Tyler Rockwood * c-api: Simplify CHostCallFutureMove the result translation and hostcall_val_storage usage into an asyncfunctionSigned-off-by: Tyler Rockwood * c-api: Simplify C continuation implementationRemove the caller, which means that we don't need another struct for thefuture implementation.Signed-off-by: Tyler Rockwood * c-api: Improve async.h documentationSigned-off-by: Tyler Rockwood * c-api: Cleanup from previous changesSigned-off-by: Tyler Rockwood * examples: Fix exampleSigned-off-by: Tyler Rockwood * c-api: Simplify continuation callbackThis gives more duality with calling an async function and also meansthat the implementation can pretty much mirror the sync version.Signed-off-by: Tyler Rockwood * c-api: Fix async.h documentationSigned-off-by: Tyler Rockwood * c-api: Fix documentation for async.hSigned-off-by: Tyler Rockwood * c-api: Review feedbackSigned-off-by: Tyler Rockwood * examples: Downgrade async.cpp example to C++11Signed-off-by: Tyler Rockwood * c-api: initialize continuation with a panic callbackSigned-off-by: Tyler Rockwood * prtest:fullSigned-off-by: Tyler Rockwood ---------Signed-off-by: Tyler Rockwood List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

329a2baf - Change the call to unwrap to except with an error message (#6745)

Wed, 19 Jul 2023 20:57:57 +0000

Change the call to unwrap to except with an error message (#6745)* Change the call to unwrap to except with an error message* Update crates/c-api/src/linker.rs* Run rustfmt.---------Co-authored-by: Peter Huene List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

63d80fc5 - Remove the need to have a `Store` for an `InstancePre` (#5683)

Thu, 02 Feb 2023 17:54:20 +0000

Remove the need to have a `Store` for an `InstancePre` (#5683)* Remove the need to have a `Store` for an `InstancePre` This commit relaxes a requirement of the `InstancePre` API, notably its construction via `Linker::instantiate_pre`. Previously this function required a `Store` to be present to be able to perform type-checking on the contents of the linker, and now this requirement has been removed. Items stored within a linker are either a `HostFunc`, which has type information inside of it, or an `Extern`, which doesn't have type information inside of it. Due to the usage of `Extern` this is why a `Store` was required during the `InstancePre` construction process, it's used to extract the type of an `Extern`. This commit implements a solution where the type information of an `Extern` is stored alongside the `Extern` itself, meaning that the `InstancePre` construction process no longer requires a `Store`. One caveat of this implementation is that some items, such as tables and memories, technically have a "dynamic type" where during type checking their current size is consulted to match against the minimum size required of an import. This no longer works when using `Linker::instantiate_pre` as the current size used is the one when it was inserted into the linker rather than the one available at instantiation time. It's hoped, however, that this is a relatively esoteric use case that doesn't impact many real-world users. Additionally note that this is an API-breaking change. Not only is the `Store` argument removed from `Linker::instantiate_pre`, but some other methods such as `Linker::define` grew a `Store` argument as the type needs to be extracted when an item is inserted into a linker. Closes #5675 * Fix the C API * Fix benchmark compilation * Add C API docs * Update crates/wasmtime/src/linker.rs Co-authored-by: Andrew Brown --------- Co-authored-by: Andrew Brown List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

1d319c0e - c-api: refactor definitions with macroes (#4416)

Mon, 11 Jul 2022 14:10:41 +0000

c-api: refactor definitions with macroes (#4416)Signed-off-by: spacewander List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

76b82910 - Remove the module linking implementation in Wasmtime (#3958)

Wed, 23 Mar 2022 19:57:34 +0000

Remove the module linking implementation in Wasmtime (#3958)* Remove the module linking implementation in Wasmtime This commit removes the experimental implementation of the module linking WebAssembly proposal from Wasmtime. The module linking is no longer intended for core WebAssembly but is instead incorporated into the component model now at this point. This means that very large parts of Wasmtime's implementation of module linking are no longer applicable and would change greatly with an implementation of the component model. The main purpose of this is to remove Wasmtime's reliance on the support for module-linking in `wasmparser` and tooling crates. With this reliance removed we can move over to the `component-model` branch of `wasmparser` and use the updated support for the component model. Additionally given the trajectory of the component model proposal the embedding API of Wasmtime will not look like what it looks like today for WebAssembly. For example the core wasm `Instance` will not change and instead a `Component` is likely to be added instead. Some more rationale for this is in #3941, but the basic idea is that I feel that it's not going to be viable to develop support for the component model on a non-`main` branch of Wasmtime. Additionaly I don't think it's viable, for the same reasons as `wasm-tools`, to support the old module linking proposal and the new component model at the same time. This commit takes a moment to not only delete the existing module linking implementation but some abstractions are also simplified. For example module serialization is a bit simpler that there's only one module. Additionally instantiation is much simpler since the only initializer we have to deal with are imports and nothing else. Closes #3941 * Fix doc link * Update comments List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

bfdbd10a - Add `*_unchecked` variants of `Func` APIs for the C API (#3350)

Fri, 24 Sep 2021 19:05:45 +0000

Add `*_unchecked` variants of `Func` APIs for the C API (#3350)* Add `*_unchecked` variants of `Func` APIs for the C API This commit is what is hopefully going to be my last installment within the saga of optimizing function calls in/out of WebAssembly modules in the C API. This is yet another alternative approach to #3345 (sorry) but also contains everything necessary to make the C API fast. As in #3345 the general idea is just moving checks out of the call path in the same style of `TypedFunc`. This new strategy takes inspiration from previously learned attempts effectively "just" exposes how we previously passed `*mut u128` through trampolines for arguments/results. This storage format is formalized through a new `ValRaw` union that is exposed from the `wasmtime` crate. By doing this it made it relatively easy to expose two new APIs: * `Func::new_unchecked` * `Func::call_unchecked` These are the same as their checked equivalents except that they're `unsafe` and they work with `*mut ValRaw` rather than safe slices of `Val`. Working with these eschews type checks and such and requires callers/embedders to do the right thing. These two new functions are then exposed via the C API with new functions, enabling C to have a fast-path of calling/defining functions. This fast path is akin to `Func::wrap` in Rust, although that API can't be built in C due to C not having generics in the same way that Rust has. For some benchmarks, the benchmarks here are: * `nop` - Call a wasm function from the host that does nothing and returns nothing. * `i64` - Call a wasm function from the host, the wasm function calls a host function, and the host function returns an `i64` all the way out to the original caller. * `many` - Call a wasm function from the host, the wasm calls host function with 5 `i32` parameters, and then an `i64` result is returned back to the original host * `i64` host - just the overhead of the wasm calling the host, so the wasm calls the host function in a loop. * `many` host - same as `i64` host, but calling the `many` host function. All numbers in this table are in nanoseconds, and this is just one measurement as well so there's bound to be some variation in the precise numbers here. | Name | Rust | C (before) | C (after) | |-----------|------|------------|-----------| | nop | 19 | 112 | 25 | | i64 | 22 | 207 | 32 | | many | 27 | 189 | 34 | | i64 host | 2 | 38 | 5 | | many host | 7 | 75 | 8 | The main conclusion here is that the C API is significantly faster than before when using the `*_unchecked` variants of APIs. The Rust implementation is still the ceiling (or floor I guess?) for performance The main reason that C is slower than Rust is that a little bit more has to travel through memory where on the Rust side of things we can monomorphize and inline a bit more to get rid of that. Overall though the costs are way way down from where they were originally and I don't plan on doing a whole lot more myself at this time. There's various things we theoretically could do I've considered but implementation-wise I think they'll be much more weighty. * Tweak `wasmtime_externref_t` API comments List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

65378422 - Add a `wasmtime_linker_define_func` C API function (#3122)

Tue, 27 Jul 2021 23:56:52 +0000

Add a `wasmtime_linker_define_func` C API function (#3122)This exposes the functionality of the `Linker` type where a store-independent function can be created and inserted, allowing a linker's functions to be used across many stores (instead of requiring one linker-per-store). Closes #3110 List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs

7a1b7cdf - Implement RFC 11: Redesigning Wasmtime's APIs (#2897)

Thu, 03 Jun 2021 14:10:53 +0000

Implement RFC 11: Redesigning Wasmtime's APIs (#2897)Implement Wasmtime's new API as designed by RFC 11. This is quite a large commit which has had lots of discussion externally, so for more information it's best to read the RFC thread and the PR thread. List of files: /wasmtime-44.0.1/crates/c-api/src/linker.rs