Changes in component.rs

856fb272 - Debugging: add integration test with LLDB and some minor tweaks. (#12856)

Fri, 27 Mar 2026 19:38:06 +0000

Debugging: add integration test with LLDB and some minor tweaks. (#12856)This PR adds:- An integration-test that runs LLDB against the Wasmtime CLI to verify basic debugging functionality, similar to the existing native-debug tests.- A CI job that runs the above in CI.- Some minor tweaks to the gdbstub debugger design: - Rather than the initial single-step to get to the first Wasm instruction where module(s) will be instantiated into the store and visible to the debugger, we pre-register modules with the store eagerly. This avoids the slightly hacky flow and also is a preparation step for `wasmtime serve` debugging, where we can't single-step into execution eagerly (because execution doesn't start at all until an HTTP request arrives). - Add a separate message-printing path for "debugger info messages", allowing us to print the "debugger is listening on " message without inheriting stderr for the whole debugger component environment. This message is necessary for the above integration test (it parses the message to determine when the debuggee is ready). List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

6e0ded7c - Use `TryBTreeMap` in the store's `ModuleRegistry` (#12846)

Thu, 26 Mar 2026 16:46:22 +0000

Use `TryBTreeMap` in the store's `ModuleRegistry` (#12846) List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

b298f375 - RR #2: Sha256 checksum for components (#12576)

Fri, 13 Feb 2026 21:11:58 +0000

RR #2: Sha256 checksum for components (#12576)* Add sha256 checksum for component for record/replay consistency* Move sha2 crate as workspace dependency* Run checksum digest only on recording configs* Fix CI error and restructure from_binary List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

9e3b5ee5 - Refactor the `TypeRegistry` to partially handle OOM (#12500)

Tue, 03 Feb 2026 18:00:18 +0000

Refactor the `TypeRegistry` to partially handle OOM (#12500)* Refactor the `TypeRegistry` to partially handle OOMThis refactors the type registry to be more "columnar" when registering thetypes within a rec group, so that we* Add all the types themselves* Add the rec group metadata for all types in the rec group* Add the supertypes metadata for all types in the rec group* Etc...Instead of adding one type, its rec group metadata, its supertypes metadata,etc... and then moving on to the next type.This makes it easier to pre-reserve space and roll back changes on OOM errors.This is part of https://github.com/bytecodealliance/wasmtime/issues/12069 andthe OOM handling effort, but doesn't fully get the `TypeRegistry` to a placewhere it handles all OOMs yet. There are a couple places that need furtherwork (usage of hash sets and `Cow::into_owned`) which I have marked with `TODO`comments. In the meantime, I found this to be a nice refactoring of the existingfunctionality, so I think it can land as-is.* review feedback List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

b271e452 - consistently create thread and task when entering component instance (#12379)

Fri, 23 Jan 2026 17:51:19 +0000

consistently create thread and task when entering component instance (#12379)* consistently create thread and task when entering component instancePreviously, we weren't creating a new thread or task in all cases when enteringa component instance, even when component model async features were enabled. Inparticular, entering an instance via a sync-to-sync, guest-to-guest adapter, via`Linker::instantiate[_async]`, or via `[Typed]Func::call` all skipped creating athread or task, creating panics and/or instance mismatches in certain cases.This commit addresses all those cases and also adds assertions to all CM asyncintrinsics to verify that the caller instance matches the most-recently-pushedtask. Note that we still skip pushing and popping threads and tasks if no CMasync features are enabled in the `Config`.In order to populate the `GuestTask::instance` field for tasks created as partof `Linker::instantiate[_async]` calls, I had to add a`RuntimeComponentInstanceIndex` field to `GlobalInitializer::InstantiateModule`and friends so it would be available when needed.While testing this, I uncovered and fixed a couple of related issues:- We weren't checking the `may_leave` flag when guest-to-guest calling a resource destructor- We weren't checking whether a subtask was ready to delete (e.g. that no threads were still running) before attempting to delete it while deleting its supertask* fix warnings when component-model-async feature disabled* address review feedback* push a task when calling a resource dtor host-to-guest* add tests which call `thread.index` from realloc and post-return functions...and assert that the indexes match as expected.Getting the post-return test to pass required moving the call to`StoreOpaque::exit_sync_call` to after the post-return function is called. List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

5566d520 - Fix `Module::image_range` to include non-text part of module. (#12302)

Fri, 09 Jan 2026 19:05:54 +0000

Fix `Module::image_range` to include non-text part of module. (#12302)* Fix `Module::image_range` to include non-text part of module.This method is informational for embedders to be able to, for example,ensure an image in memory is `mlock`'d (not swapped out). In therefactors around the StoreCode/EngineCode split, I mistakenly redefinedthis to only the text section. This is not a Wasm execution correctnessissue but may lead to performance issues if an embedder relies on thisbehavior. This PR fixes the definition.* Components as well as core modules.* Ignore new tests in miri. List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

96e19700 - Migrate the `wasmtime` crate to `wasmtime_environ::error::*` (#12231)

Wed, 07 Jan 2026 17:08:11 +0000

Migrate the `wasmtime` crate to `wasmtime_environ::error::*` (#12231)* Migrate the `wasmtime` crate to `wasmtime_environ::error::*`Instead of `anyhow::Error`.This commit re-exports the `wasmtime_environ::error` as the `wasmtime::error`module, updates the prelude to include these new error-handling types, redirectsour top-level `wasmtime::{Error, Result}` re-exports to re-export`wasmtime::error::{Error, Result}`, and updates various use sites that weredirectly using `anyhow` to use the new `wasmtime` versions.This process also required updating the component macro and wit-bindgen macro touse the new error types instead of `anyhow`.Part of https://github.com/bytecodealliance/wasmtime/issues/12069* Replace wasmtime::error::Thing with wasmtime::Thing where it makes sense* cargo fmt* Move `crate::error::Thing` to `crate::Thing` where it makes sense List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

99ecf728 - Debug: create private code memories per store when debugging is enabled. (#12051)

Wed, 03 Dec 2025 01:18:00 +0000

Debug: create private code memories per store when debugging is enabled. (#12051)* Debug: create private code memories per store when debugging is enabled.This will allow patching code to implement e.g. breakpoints. (That is,for now the copies are redundant, but soon they will not be.)This change follows the discussion [here] and offline to define a fewtypes that better encapsulate the distinction we want to enforce.Basically, there is almost never a bare `CodeMemory`; they are alwayswrapped in an `EngineCode` or `StoreCode`, the latter being a per-storeinstance of the former. Accessors are moved to the relevant place sothat, for example, one cannot get a pointer to a Wasm function's bodywithout being in the context of a `Store` where the containing modulehas been registered. The registry then returns a `ModuleWithCode` thatboxes up a `Module` reference and `StoreCode` together for cases wherewe need both the metadata from the module and the raw code to derivesomething.The only case where we return raw code pointers to the `EngineCode`directly have to do with Wasm-to-array trampolines: in some cases, e.g.`InstancePre` pre-creating data structures with references to hostfunctions, it breaks our expected performance characteristics to makethe function pointers store-specific. This is fine as long as theWasm-to-array trampolines never bake in direct calls to Wasm functions;the strong invariant is that Wasm functions never execute from`EngineCode` directly. Some parts of the component runtime would alsohave to be substantially refactored if we wanted to do away with thisexception.The per-`Store` module registry is substantially refactored in this PR.I got rid of the modules-without-code distinction (the case where amodule only has trampolines and no defined functions still works fine),and organized the BTreeMaps to key on start address rather than endaddress, which I find a little more intuitive (one then queries with thedual to the range -- 0-up-to-PC and last entry found).[here]: https://github.com/bytecodealliance/wasmtime/pull/12051#pullrequestreview-3493711812* Review feedback: do not assume a reasonable code alignment; error when it cannot be known* Review feedback: fail properly in profiler when we are cloning code* Fix guest-profiler C API.* Review feedback: make private-code representation impossible in non-debugging-support builds.* Add TODO comment referencing issue for cloning only .text.* clang-format* Review feedback: add back Component::image_range.* Review feedback: error on registering profiling metadata when debug is enabled.* rustfmt* Remove early bail on profiling-data registration when debugging is enabled: this always happens so we cannot error out. List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

ad56ff98 - Implement unsafe intrinsics for compile-time builtins (#11825)

Fri, 17 Oct 2025 00:01:54 +0000

Implement unsafe intrinsics for compile-time builtins (#11825)* Implement unsafe intrinsics for compile-time builtinsThis commit adds the extremely unsafe`wasmtime::CodeBuilder::expose_unsafe_intrinsics` method. When enabled, the Wasmbeing compiled is given access to special imports that correspond to direct,unchecked and unsandboxed, native load and store operations. These intrinsicsare intended to be used for implementing fast, inline-able versions of WASIinterfaces that are special-cased to a particular host embedding, for example.Compile-time builtins, as originally described in [theRFC](https://github.com/bytecodealliance/rfcs/pull/43), are basically made up ofthree parts:1. A function inliner2. Unsafe intrinsics3. Component composition to encapsulate the usage of unsafe intrinsics in a safeinterfacePart (1) has been implemented in Wasmtime and Cranelift for a little whilenow (see `wasmtime::Config::compiler_inlining`). This commit is part (2). Afterthis commit lands, part (3) can be done with `wac` and `wasm-compose`, althoughfollow up work is required to make the developer experience nicer and moreintegrated into Wasmtime so that the APIs can look like those proposed in theRFC.* fill out some more docs* fix non component model builds* start filling out the doc example* Factor abi params/returns out; truncate/extend pointers* Compile unsafe intrinsics on winch as well* prtest:full* have the macro define the signature* ignore tests in MIRI because MIRI can't compile Wasm* juggle pointer provenance in `Store::data[_mut]`* add a test for store data provenance and also fix it* use `VmPtr` for the store data pointer* finish writing unsafe intrinsics example* fix up docs and rules around only accessing data from `T` in a `Store`* Only reserve space for the intrinsics' `VMFuncRef`s if they are in use* use dangling pointers instead of options* Rename `StoreInner::data` to `data_no_provenance` and fix some accesses to use the method accessors* Add comments about the provenance juggling inside `StoreInner::data[_mut]`* only compile intrinsics that are usedTurns out we don't need to add phases, we already have the info available to dothis.* fix duplicate symbol names List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

1806c265 - Lookup functions in the text section by `FuncKey` at runtime (#11630)

Mon, 15 Sep 2025 22:35:40 +0000

Lookup functions in the text section by `FuncKey` at runtime (#11630)This commit refactors our metadata, treating compiled functions homogeneouslyand removing the need to add new tables to places like `CompiledModuleInfo`whenever we add a new kind of function. This also simplifies the process ofconstructing the metadata for a final, linked compilation artifact. Finally, itpaves the way to doing gc-sections during our linking process (which would giveus smaller code sizes by removing functions that have been inlined into everycaller, for example) as we now allow holes in certain types of function indexspaces that were previously always densely populated.We have two kinds of index spaces:1. Mostly-dense index spaces, which take O(max_index) space and provide O(1)lookups.2. Sparse index spaces, which take O(num_members) space and provideO(log n) lookups.Most of our function index spaces are currently dense, but we can tweak that inthe future if necessary.Furthermore, code size of `.cwasm` binaries has shrunk very slightly with thisrefactoring. Consider `spidermonkey.wasm`'s compiled `.cwasm`:* Size before: 218756 `.wasmtime.info` section bytes, 20052632 total bytes* Size after: 213761 `.wasmtime.info` section bytes, 20047640 total bytesThat is a 2.28% reduction on the size of the `.wasmtime.info` section, or a0.025% reduction total.However, we previously did a single metadata lookup to get the location of botha Wasm function itself and its array-to-Wasm trampoline at the same time, and inthe new version of the code two lookups are performed. This is slightly slower,as shown in our call-indirect micro-benchmark that combines lazy tableinitialization (which delays looking up the function element's location untilruntime) with indirect-calling each table element exactly once (which defeatsthe amortization of that lookup). So this micro-benchmark is both synthetic andthe worst-case scenario for this commit's change: we are measuring, as much aswe can, *only* the force-initialization-of-a-lazy-funcref-table-slot path.Ultimately, I believe that the simplification is worth the regression in thismicro-benchmark.

call-indirect micro-benchmarks results

```call-indirect/same-callee/table-init-lazy/65536-calls time: [152.77 µs 154.92 µs 157.39 µs] thrpt: [416.40 Melem/s 423.04 Melem/s 428.99 Melem/s] change: time: [−13.749% −10.205% −6.2864%] (p = 0.00 < 0.05) thrpt: [+6.7081% +11.365% +15.941%] Performance has improved.Found 13 outliers among 100 measurements (13.00%) 8 (8.00%) high mild 5 (5.00%) high severecall-indirect/different-callees/table-init-lazy/65536-calls time: [4.3564 ms 4.4641 ms 4.5843 ms] thrpt: [14.296 Melem/s 14.681 Melem/s 15.044 Melem/s] change: time: [+38.134% +44.404% +50.927%] (p = 0.00 < 0.05) thrpt: [−33.743% −30.750% −27.606%] Performance has regressed.Found 5 outliers among 100 measurements (5.00%) 2 (2.00%) high mild 3 (3.00%) high severecall-indirect/same-callee/table-init-strict/65536-calls time: [144.91 µs 148.41 µs 152.02 µs] thrpt: [431.10 Melem/s 441.58 Melem/s 452.24 Melem/s] change: time: [−13.665% −10.470% −7.2626%] (p = 0.00 < 0.05) thrpt: [+7.8313% +11.694% +15.828%] Performance has improved.Found 4 outliers among 100 measurements (4.00%) 1 (1.00%) high mild 3 (3.00%) high severecall-indirect/different-callees/table-init-strict/65536-calls time: [195.18 µs 200.67 µs 206.49 µs] thrpt: [317.38 Melem/s 326.59 Melem/s 335.77 Melem/s] change: time: [−15.936% −11.568% −7.0835%] (p = 0.00 < 0.05) thrpt: [+7.6235% +13.081% +18.957%] Performance has improved.Found 5 outliers among 100 measurements (5.00%) 5 (5.00%) high mild```

List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

5245e1f8 - Remove `AllCallFunc` (#11694)

Fri, 12 Sep 2025 23:36:30 +0000

Remove `AllCallFunc` (#11694)* Remove `AllCallFunc`And add `FuncKeyKind` and `FuncKeyNamespace` types.Split out from https://github.com/bytecodealliance/wasmtime/pull/11630* fix warning and disriminant gap* add module arg to `Module::new()` calls in tests List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

815c10de - Package component model options in an index (#11324)

Fri, 25 Jul 2025 19:12:43 +0000

Package component model options in an index (#11324)* Package component model options in an indexThis commit is a refactoring of how canonical ABI options are handledduring compilation and runtime. Previously options were "exploded"meaning that options were all passed around as parameters but this was abummer for a few reasons:* This is `unsafe`-prone as options have raw pointers such as memory and functions. This meant that all functions/operations working with options were fundamentally `unsafe`.* This was unwieldy as the set of options continues to grow larger over time. The `VMLoweringCallee` function previously had 10+ parameters, most of which were canonical ABI options.To solve these two problems options are now intern'd at compile time toan `OptionsIndex`, a 32-bit value. This is stored as a new table incomponent metadata and consulted at runtime. This means that`OptionsIndex` can be passed around with an instance for a much safermeans of threading options around. Additionally there's no need to passaround all parameters individually and instead just one parameter,`OptionsIndex`, need be threaded through.This commit additionally overhauls trampoline generation for thecomponent compiler to avoid a function-per-intrinsic and instead have asingle function that all intrinsics use. I found this easier tounderstand and helps codify that all intrinsics are basically the samewith some minor details differing between them.The end result of this is (hopefully) a net simplification of thecomponent compiler in addition to a large amount of removal of `unsafe`code in the async implementation as only safe types are passed aroundnow instead of raw pointers.Closes #10143Closes #11188* Fill out some TODO comments List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

0f457fad - Raise `unsafe_op_in_unsafe_fn` further in Wasmtime (#11322)

Fri, 25 Jul 2025 18:22:03 +0000

Raise `unsafe_op_in_unsafe_fn` further in Wasmtime (#11322)* Raise `unsafe_op_in_unsafe_fn` further in WasmtimeNow it's at `wasmtime::runtime`, not just `wasmtime::runtime::vm`.* Review comments List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

838ed2d0 - Enable `allow_attributes_without_reason` (#11195)

Mon, 07 Jul 2025 21:52:03 +0000

Enable `allow_attributes_without_reason` (#11195)* Enable `allow_attributes_without_reason`This commit enables the `clippy::allow_attributes_without_reason` forthe `wasmtime` crate which previously forcibly allowed it. The reasonthis was allowed was that when the workspace was first migrated theWasmtime crate had too many instances that I was willing to fix. I'venow come back around and tried to fix everything.In short: ideally delete `#[allow]`, otherwise use `#[expect]`,otherwise use `#[allow]`.prtest:full* Adjust some directives* Fix some warnings* Fix stack switching size tests on unix* Don't have a conditional `Drop` impl* Force `testing_freelist` method to be usedToo lazy to write `#[cfg]`, but not too lazy to write a test. List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

a252f37e - Remove dead `callee` field of vmctx (#11014)

Wed, 11 Jun 2025 18:16:13 +0000

Remove dead `callee` field of vmctx (#11014)* Remove dead `callee` field of vmctxThis was used long ago but refactorings since then have removed the needfor its existence, so remove it outright.* Update test expectations* Shuffle around some imports List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

e33836c0 - Refactor the representation of component::Func (#10914)

Tue, 03 Jun 2025 21:23:21 +0000

Refactor the representation of component::Func (#10914)* Expand on FIXME commentsIn case it takes awhile to get to them...* Remove `FuncData::types`This can always be inferred from the instance itself.* Add an `ExportIndex` to `FuncData`This will soon be used to remove most other fields, but for now justhave it hanging out there.* Remove `FuncData::component_instance` field* Remove `FuncData::post_return`* Remove `FuncData::ty`* Remove `FuncData::export`* Remove `FuncData::options`* Remove `FuncData::post_return_arg`This field was moved to `ComponentInstance` as the stateful storage ofthe last function return value.* Refactor the representation of `component::Func`This commit updates the implementation of `component::Func` to beindex-based like all other exported items are now in Wasmtime. Thisnecessitated a new `StoreComponentInstanceId` abstraction similar to`StoreInstanceId`. Additionally the `component_instance_replace`function was entirely removed as it's no longer necessary. List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

8fb9d189 - Remove `Stored` usage from `wasmtime::component::Instance` (#10913)

Tue, 03 Jun 2025 20:21:59 +0000

Remove `Stored` usage from `wasmtime::component::Instance` (#10913)* Remove mutability required on a number of component methodsPowered by previous refactorings it's possible to just take`&StoreOpaque` in these locations.* Move core instance map into `ComponentInstance`This commit moves the mapping from a `RuntimeInstanceIndex` to a`wasmtime::Instance` from `wasmtime::component::InstanceData` into theinternal `ComponentInstance` structure. This is done in preparation toremove `InstanceData` eventually.* Move `Component` to live in `ComponentInstance`Previously this lived in `InstanceData` but that's just a historicalartifact of the old `wasmtime` and `wasmtime-runtime` split. Nowadaysit's possible to store `Component` directly to further move informationout of `InstanceData`.* Move `InstanceData::imports` to `ComponentInstance`More preparation for the removal of `InstanceData` entirely.* Move lookup functions from `InstanceData` to `ComponentInstance`More prep for the removal of `InstanceData`.* Reduce some more reliance on `InstanceState`Just removing it from some type signatures to make future removaleasier.* Remove an unused result from a helper functionNo caller needs it, so go ahead and remove it.* Make `ComponentInstance::imports` privateThis moves some methods around and documents preexisting `unsafe`contracts to get this field private and prevent external access to it.* Remove `InstanceData` from `Instantiator`.Use `OwnedComponentInstance` instead.* Remove `InstanceData`, refactor `Instance`This commit refactors the representation of `component::Instance` to bepurely index-based to data already within a store. This makes creationof an `Instance` free compared to before where auxiliary data needed tobe created. Note that this doesn't actually change storage within a`Store` as instances are still there, it's just that now the storagelives in a non-`Stored`-related location. List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.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/wasmtime/src/runtime/component/component.rs

95cc0297 - Component and Instance have corresponding get_export, get_export_index (#10597)

Wed, 16 Apr 2025 21:38:26 +0000

Component and Instance have corresponding get_export, get_export_index (#10597)* component::Instance: get_export gives a ComponentItem, ExportIndex pairjust like Component::export_index does* align Instance and Component with get_export and get_export_index* fix example* component macro expanded: bless output* fix component model tests* cli only needs get_export_index* code review: deduplicate export to typedef transformation into ComponentItem::from_export List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs

c3177fc4 - Guest Profiling suport for component model (#10507)

Wed, 02 Apr 2025 19:34:04 +0000

Guest Profiling suport for component model (#10507)* Guest Profiling suport for component modelThis change adds support for using guest profiling with thecomponent model. In addition to the core change to supportattributing stack frames to constituient modules within a component,the cli `run` and `serve` commands are also updated to supportusing the `--profile=guest` cli option with components.https://github.com/bytecodealliance/wasmtime/issues/8773https://github.com/bytecodealliance/wasmtime/issues/7669* fixup! Guest Profiling suport for component model List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/component.rs