Changes in extern.h

0dbb6f3d - Exceptions: implement C API. (#12861)

Tue, 31 Mar 2026 22:56:28 +0000

Exceptions: implement C API. (#12861)* Exceptions: implement C API.This PR implements C (and C++) API support for Wasm exceptions, onefinal remaining hurdle (aside from fuzz-testing) for making exceptionstier-1 and on-by-default.* Review feedback, and add exnref case to `wasmtime_val_t`.* Review feedback: GC feature guard.* clang-format* add docs to exn.hh.* Remove tag size asserts: broken on 32-bit platforms, but not needed for correctness wrt C struct. List of files: /wasmtime-44.0.1/crates/c-api/include/wasmtime/extern.h

5603ee7b - Change component/instance maps to `PrimaryMap` (#10916)

Tue, 03 Jun 2025 22:11:29 +0000

Change component/instance maps to `PrimaryMap` (#10916)* Change component/instance maps to `PrimaryMap`This switches to using typed keys for these maps to be more idiomaticwith the rest of Wasmtime and this has the additional benefit ofcompressing indices to 32-bits instead of the previouspointer-sized-bits.* Fix an unused import List of files: /wasmtime-44.0.1/crates/c-api/include/wasmtime/extern.h

a30e7299 - Update the definition of `wasmtime::Table` (#10903)

Tue, 03 Jun 2025 05:04:01 +0000

Update the definition of `wasmtime::Table` (#10903)This commit is similar to a prior commit modifying memories whichrefactors the internals of `wasmtime::Table` to not longer use a`Stored` index. Instead a `StoreInstanceId` and a `DefinedTableIndex` isused instead. This enables construction of external-facing types to betrivial and zero-cost.This additionally notably fixes an issue where triggering a GC in astore would unconditionally create a `Table`, pushing onto an internalvector in the store. This then would never be deallocated because theinternal table lived as long as the `Store`. In effect this meant thattriggering a GC would end up leaking memory by pushing more items ontointernal `Store` table. This is fixed through this commit becausecreating a `wasmtime::Table` is now "free" and no longer requires anyallocations. List of files: /wasmtime-44.0.1/crates/c-api/include/wasmtime/extern.h

4fcfe17a - Refactor the representation of `Func` (#10897)

Mon, 02 Jun 2025 23:55:52 +0000

Refactor the representation of `Func` (#10897)* Refactor the representation of `Func`This commit rewrites the internals of `wasmtime::Func`. The `Stored`type is no longer used meaning that it's now free to create a`wasmtime::Func` at any time. It is effectively a store-tagged`NonNull`. This required a few internal changes to howfunctions are passed around:* Previously the insertion of a `wasm_call`-less `VMFuncRef` was deferred until the raw pointer was loaded. Now the insertion happens immediately as soon as the function is placed within a store. This is done to ensure that a `Func` corresponds to one exact `VMFuncRef` and that's it, and lazily filled in versions within the store are still lazily filled in but they're more eagerly allocated. This isn't expected to have much of an impact perf-wise since all these lazily allocated functions were already almost guaranteed to get lazily allocated anyway.* Filling in "holes" in `VMFuncRef`, notably the `wasm_call` field, no longer happens lazily when the `VMFuncRef` is demanded. Instead during instantiation a pass is made to fill in holes with the new module being instantiated (after registration). Additionally when a lazily-allocated `VMFuncRef` is created the module registry is checked immediately. This means that all store-local `VMFuncRef` values are either filled in immediately or filled in during instantiation. This notably means that the previous logic in `Func::vmimport` is now "just" an `.unwrap()` with a lot of comments saying why the unwrap shouldn't panic.* To implement this commit a previous optimization for the `Func` API was removed as well, namely `Func::call` will become slower after this commit. The `Func::call` API is a dynamically-typed API which requires run-time type-checking of arguments. Previously a `FuncType` was loaded into a cache once-per-`Func` which helped amortize the cost of using `Func::call` repeatedly. Now, though, there's no natural place to put such a cache since `Func` no longer has dedicated storage within a `Store`. Historically this optimization was added for the C API before the `*_call_unchecked` APIs existed, but nowadays the `*_call_unchecked` APIs should suffice for performance-critical applications where needed. In the future it might also be possible to have a hash map in the `Store` of a `VMSharedTypeIndex` to `FuncType` which is lazily populated based on calls to `Func::call`, but that feels a bit overkill nowadays for a possibly rarely-used map.* The no-longer-necessary `RootedHostFunc` type is now gone as its unsafety and various contracts are subsumed by other preexisting `unsafe` blocks.* The specific drop order between `StoreOpaque::store_data` and `StoreOpaque::rooted_host_funcs` is removed. The `rooted_host_funcs` field now lives in the `func_refs` field and the `FuncKind` type, where the destructors came from before, is no more.* The `func_refs` field has grown storage locations for a variety of "keep this thing alive as long as the store" related to functions and such.Closes #10868* Remove mutability from locations that no longer need it* Update crates/wasmtime/src/runtime/func.rsCo-authored-by: Nick Fitzgerald * Update crates/wasmtime/src/runtime/store/func_refs.rsCo-authored-by: Nick Fitzgerald ---------Co-authored-by: Nick Fitzgerald List of files: /wasmtime-44.0.1/crates/c-api/include/wasmtime/extern.h

c4fd2f7b - Refactor globals to no longer use `Stored` (#10902)

Mon, 02 Jun 2025 23:23:47 +0000

Refactor globals to no longer use `Stored` (#10902)This commit refactors the `wasmtime::Global` to avoid the usage of`Stored` internally. This makes conversion from internal global stateto external global state a noop along the lines of previous commits. Theend goal is to remove `Stored` entirely and enable more pervasively usingexternal types internally within Wasmtime as well.Globals were different than the prior iterations of memories, tags, andtables. Globals have three different ways of defining them: wasminstances, the host embedder, and component flags. Representing thesein all the various locations required a bit of finesse in how everythingis represented and stored at rest and such. In the end there's a smallamount of "type punning" in a few instance/vmctx fields related toglobals now since everything is squeezed into one slot. This is requiredbecause the `VMGlobalImport` structure must have a size known towasm-compiled code and `wasmtime::Global` must have a known layout for Ccode.In the end while this is more code to manage globals my hope is that theend result will be a net negative in terms of complexity by ensuringthat the embedder API is additionally suitable for use internally withinWasmtime as well. List of files: /wasmtime-44.0.1/crates/c-api/include/wasmtime/extern.h

0e9a691d - Update the definition of `wasmtime::Memory` (#10877)

Fri, 30 May 2025 22:34:21 +0000

Update the definition of `wasmtime::Memory` (#10877)Powered by the previous commit this change updates the internalimplementation details of `wasmtime::Memory` to avoid the need for theuse of `Stored`. This means that converting from a Wasmtime-internalrepresentation of a memory to an external representation of a memory islargely a noop and no longer requires an allocation. This is intended tobe more useful in the future to use the public types more pervasivelyinside of Wasmtime itself, but for now this is mostly the scaffoldingnecessary for such a change. List of files: /wasmtime-44.0.1/crates/c-api/include/wasmtime/extern.h

c6e4a502 - c-api: Tidy up some `wasmtime_func_t` usage (#8461)

Wed, 24 Apr 2024 18:49:36 +0000

c-api: Tidy up some `wasmtime_func_t` usage (#8461)* c-api: Tidy up some `wasmtime_func_t` usageTry to avoid using a `transmute` in the implementation of the C API andinstead use a `union` like is being done in #8451. Additionally add somehelper functions to the header to work with null funcref values insteadof only documenting the implementation.* Try to fix doxygen List of files: /wasmtime-44.0.1/crates/c-api/include/wasmtime/extern.h

ca5f1bb6 - Tidy up some headers related to shared memory (#8366)

Sun, 14 Apr 2024 20:02:43 +0000

Tidy up some headers related to shared memory (#8366)* Tidy up some headers related to shared memory* Don't declare an anonymous `struct wasmtime_sharedmemory`, instead `#include` the actual definition.* Fix an issue where a header in `sharedmemory.h` referred to a type in `extern.h` which wasn't `#include`'d. This function, `wasmtime_sharedmemory_into_extern`, additionally isn't necessary as it's no different than manually constructing it. Fix this by removing this function.* Run clang-format List of files: /wasmtime-44.0.1/crates/c-api/include/wasmtime/extern.h

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/include/wasmtime/extern.h

f8fee938 - add clang format (#7601)

Wed, 29 Nov 2023 18:39:04 +0000

add clang format (#7601)* add clang-formatWe chose WebKit style because out of all the builtin styles it seems theclosest to what already exists in wasmtime.Signed-off-by: Tyler Rockwood * c-api: don't reorder headersThe order here mattersSigned-off-by: Tyler Rockwood * c-api: apply clang-formatSigned-off-by: Tyler Rockwood * fiber: apply clang-formatSigned-off-by: Tyler Rockwood * runtime: apply clang-formatSigned-off-by: Tyler Rockwood * examples: apply clang formatSigned-off-by: Tyler Rockwood * tests: apply clang-formatSigned-off-by: Tyler Rockwood * ci: add clang-format checksSigned-off-by: Tyler Rockwood * clang-format: keep braces on the same lineThis is more the existing styleSigned-off-by: Tyler Rockwood * remove clang-formatJust use the tool defaults (LLVM)Signed-off-by: Tyler Rockwood * Fix ci nameSigned-off-by: Tyler Rockwood * manually reformat a couple of commentsprtest:fullSigned-off-by: Tyler Rockwood * disable formatting for doc-wasm.hSigned-off-by: Tyler Rockwood * manually reformat wasmtime.hSigned-off-by: Tyler Rockwood * disable formattingTo prevent a link from being brokenSigned-off-by: Tyler Rockwood * examples: fixing build commandsSigned-off-by: Tyler Rockwood * fix parameter commentSigned-off-by: Tyler Rockwood ---------Signed-off-by: Tyler Rockwood List of files: /wasmtime-44.0.1/crates/c-api/include/wasmtime/extern.h

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/include/wasmtime/extern.h

f3b80ece - c-api: add wasmtime_trap_code (#3086)

Thu, 15 Jul 2021 15:31:03 +0000

c-api: add wasmtime_trap_code (#3086)Eventually this should be added to the wasmtime-go binding, addressing https://github.com/bytecodealliance/wasmtime-go/issues/63. Added a snippet to examples/interrupt.c to verify that this works as expected in manual testing. Signed-off-by: Stephan Renatus List of files: /wasmtime-44.0.1/crates/c-api/include/wasmtime/extern.h

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/include/wasmtime/extern.h