Changes in component_model.rs

1b59b579 - Add support for map type (#12216)

Mon, 09 Mar 2026 23:34:21 +0000

Add support for map type (#12216)* Add support for map typeSigned-off-by: Yordis Prieto * Add Map and MapEntry classes to support key/value pairs in component modelThis commit introduces the Map and MapEntry classes, enabling the representation of map values in the component model. The Map class allows for the creation and iteration of key/value pairs, enhancing the functionality of the wasmtime component API. Additionally, the .gitignore file is updated to exclude build artifacts from the crates/c-api directory.* Add wasm_component_model_map configuration support* Format code* Format C code* Enhance component model to support HashMap typeThis commit introduces support for HashMap in the component model, allowing maps to be represented as list> in the canonical ABI. It includes implementations for the ComponentType, Lower, and Lift traits for HashMap, enabling type checking, lowering to flat representations, and lifting from memory. Additionally, the maximum depth for type generation in the fuzzing utility is updated to accommodate the new map type.* Refactor component configuration to introduce map supportThis commit removes the previous wasm features configuration and adds new functions for creating a map-configured engine. The `map_config` and `map_engine` functions are introduced to facilitate the use of the component model with maps in tests, ensuring that the engine is properly configured for map types in the component model.* Add new WAST test for map types and remove map type definitions from existing testsThis commit introduces a new WAST test file specifically for testing various map types in the component model. Additionally, it removes the redundant map type definitions from the existing types.wast file to streamline the test suite.* Update component fuzzing and dynamic tests to replace call_and_post_return with call* Format code* Refactor HashMap usage in typed.rs to use wasmtime_environ collections* Fix HashMap initialization and insertion to handle potential errors in typed.rs* Refactor HashMap handling in typed.rs to use lower_map_iter for improved iteration and memory management. Introduce new implementations for ComponentType, Lower, and Lift traits for std::collections::HashMap, enhancing support for map types in the component model.* Fix map adapter trampoline compilation and alignment bugsThe translate_map function had two categories of bugs preventing mapadapter trampolines from working:1. Wasm stack discipline: local_set_new_tmp emits LocalSet which pops from the stack, but was called when the stack was empty (to "pre-allocate" locals). Fixed by computing values first, then calling local_set_new_tmp to consume them—matching translate_list's pattern. Also removed an erroneous LocalTee that left an orphan value on the stack. Affected: src_byte_len, dst_byte_len, cur_src_ptr, cur_dst_ptr.2. Pointer advancement: after value translation, the pointer still points at the value start. The code only advanced by trailing padding instead of value_size + trailing_padding, causing every loop iteration to re-read the same memory.Also fixes entry layout to use proper record alignment rules (entryalign = max(key_align, value_align), value at aligned offset).* Refactor map entry layout calculations to use canonical ABI* Remove unnecessary clone of map pairs during loweringVal::Map already holds Vec<(Val, Val)> which derefs to &[(Val, Val)],matching lower_map's signature directly. The intermediate Vec allocationand deep clone of every key/value pair was redundant.* Deduplicate map lift logic between HashMap implementations* Deduplicate list and map sequence translation scaffolding* Fix cargo fmt formatting issues* Deduplicate map typecheck logic* Deduplicate map lowering with linear_lower_map_to_flat and linear_lower_map_to_memory helpers* Clean up lift_try_map: use drop, move TryHashMap import to module scope* Fix CI: arbtest overflow and no-std HashMap lift_map- component_fuzz: use saturating_sub in generate_hashable_key to prevent underflow when fuel is 0 and Enum variant is chosen- typed: remove incorrect ? operators in lift_map for hashbrown::HashMap (with_capacity and insert don't return Result)* Store map tuple layout in TypeMapCompute map entry ABI and value offsets once during type building, and reuse that metadata in runtime map lift/lower paths instead of recalculating tuple layout at each call site.* Refactor map ABI argument passingBundle map lift/lower layout and type metadata into a small MapAbi32 helper so map helper calls stay concise without changing behavior.* Fix CI: enable component_model_map in fuzzing and handle map in arbitrary_valThe fuzzer's component_api oracle was generating map types but the enginedidn't have the map feature enabled, and arbitrary_val had no arm forType::Map. Enable component_model_map in the store helper (matching howcomponent_model_async is forced on) and implement arbitrary value generationfor map types.---------Signed-off-by: Yordis Prieto List of files: /wasmtime-44.0.1/tests/all/component_model.rs

1e0b0b46 - Remove subtask reparenting (#12570)

Mon, 23 Feb 2026 21:00:21 +0000

Remove subtask reparenting (#12570)This commit updates the implementation of component-model-asyncprimitives to remove the manual subtask reparenting process. This isrequired to fix #12544 at a semantic level because a subtask isn't everactually reparented, even if its parent exits. The first part of thischange is to remove the `GuestTask::subtasks` field and all relevantmanipulations of it.This field, however, powered the `TaskExit` abstraction returned from`call_concurrent`. This commit then subsequently deletes `TaskExit` andall related infrastructure as it's no longer directly applicable as-is.The rest of this change is then updating tests/bindings/etc to accountfor these two changes.The main semantic changes related to tests are:* `wasmtime run`, with and without `--invoke`, no longer waits for all subtasks. This instead only waits for the main task returning before exiting. Whether or not this is the correct behavior is under discussion in WebAssembly/component-model#608* `wasmtime serve` has been updated to keep the store alive at least until the response body has been fully transmitted. This is also part of WebAssembly/component-model#608.* Some `component-async-tests`-related tests were updated to either avoid blocking the store as it wasn't needed or yield enough times to ensure that the test passes.Closes #12544prtest:full List of files: /wasmtime-44.0.1/tests/all/component_model.rs

c09aa380 - deprecate `[Typed]Func::post_return[_async]` and make them no-ops (#12498)

Tue, 03 Feb 2026 19:13:45 +0000

deprecate `[Typed]Func::post_return[_async]` and make them no-ops (#12498)* deprecate `[Typed]Func::post_return[_async]` and make them no-opsWith the advent of the Component Model concurrency ABI and it's `task.return`intrinsic, post-return functions have been informally deprecated and areexpected to be removed for WASI 1.0 and the corresponding stable edition of theComponent Model. Consequently, it does not make sense anymore to requireembedders to explicitly call the post-return function after using`[Typed]Func::call[_async]`.As of this commit, `[Typed]Func::post_return[_async]` are no-ops. Instead, thepost-return function is called automatically as part of`[Typed]Func::call[_async]` if present, which is how`[Typed]Func::call_concurrent` has worked all along. In addition, this commitfixes and tests a couple of cases where the task and/or thread was beingdisposed of before the post-return function was called.* address review feedback* test post-return function in more scenariosSpecifically, I've split the `invoke_post_return` test into multiple tests:- using `TypedFunc::call`- using `TypedFunc::call_async` with concurrency support enabled- using `TypedFunc::call_async` with concurrency support disabled- using `Func::call_async` with concurrency support disabled- using `TypedFunc::call_concurrent`* remove GCC/clang-specific deprecation attributeThis broke the MSVC build.* bless bindgen output* remove obsolete post-return functions and fieldsNow that post-return calls are handled internally without requiring explicitaction by the embedder, we can avoid unnecessary bookkeeping. List of files: /wasmtime-44.0.1/tests/all/component_model.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/tests/all/component_model.rs

cc8d04f4 - Remove need for explicit `Config::async_support` knob (#12371)

Fri, 23 Jan 2026 02:46:45 +0000

Remove need for explicit `Config::async_support` knob (#12371)* Refactor component model host function definitionsPush the `async`-ness down one layer.* Remove need for explicit `Config::async_support` knobThis commit is an attempt to step towards reconciling "old async" and"new async" in Wasmtime. The old async style is the original asyncsupport in Wasmtime with `call_async`, `func_wrap_async`, etc, where themain property is that the store is "locked" during an async operation.Put another way, a store can only execute at most one async operation ata time. This is in contrast to "new async" support in Wasmtime with thecomponent-model-async (WASIp3) support, where stores can have more thanone async operation in flight at once.This commit does not fully reconcile these differences, but it doesremove one hurdle along the way: `Config::async_support`. Since thebeginning of Wasmtime this configuration knob has existed to explicitlydemarcate a config/engine/store as "this thing requires `async` stuffinternally." This has started to make less and less sense over timewhere the line between sync and async has become more murky with WASIp3where the two worlds comingle. The goal of this commit is to deprecate`Config::async_support` and make the function not actually do anything.In isolation this can't simply be done, however, because there are manyload-bearing aspects of Wasmtime that rely on this `async_support` knob.For example once epochs + yielding are enabled it's required that allWasm is executed on a fiber lest it hit an epoch and not know how toyield. That means that this commit is not a simple removal of`async_support` but instead a refactoring/rearchitecting of how async isused internally within Wasmtime. The high-level ideas within Wasmtimenow are:* A `Store` has a "requires async" boolean stored within it.* All configuration options which end up requiring async, such as yielding with epochs, turn this boolean on.* Creation of host functions which use async (e.g. `func_wrap_{async,concurrent}`) will also turn this option on.* Synchronous API entrypoints into Wasmtime ensure that this boolean is disabled.* Asynchronous APIs are usable at any time.This means that the concept of an async store vs a sync store is nowgone. All stores are equally capable of executing sync/async, and thechange now is that dynamically some stores will require that async isused with certain configuration. Additionally all panicking conditionsaround `async_support` have been converted to errors instead. Allrelevant APIs already returned an error and things are murky enough nowthat it's not necessarily trivial to get this right at the embedderlevel. In the interest of avoiding panics all detected async mismatchesare now first-class `wasmtime::Error` values.The end result of this commit is that `Config::async_support` is adeprecated `#[doc(hidden)]` function that does nothing. While manyinternal changes happened as well as having new tests for all this sortof behavior this is not expected to have a great impact on externalconsumers. In general a deletion of `async_support(true)` is in theoryall that's required. This is intended to make it easier to think aboutasync/sync/etc in the future with WASIp3 and eventually reconcile`func_wrap_async` and `func_wrap_concurrent` for example. That's leftfor future refactorings however.prtest:full* Review comments* Fix CI failures List of files: /wasmtime-44.0.1/tests/all/component_model.rs

94740588 - Migrate the Wasmtime CLI to `wasmtime::error` (#12295)

Fri, 09 Jan 2026 19:15:48 +0000

Migrate the Wasmtime CLI to `wasmtime::error` (#12295)* Migrate wasmtime-cli to `wasmtime::error`* migrate benches to `wasmtime::error` as well* Remove new usage of anyhow that snuck in List of files: /wasmtime-44.0.1/tests/all/component_model.rs

f586be11 - cm-async: Start to fill out `{Future,Stream}Any` (#12142)

Tue, 09 Dec 2025 18:24:05 +0000

cm-async: Start to fill out `{Future,Stream}Any` (#12142)* cm-async: Start to fill out `{Future,Stream}Any`This commit is the first step down the road of filling out thepreexisting, but empty/buggy, `FutureAny` and `StreamAny` types. Theseare intended to behave similarly to `ResourceAny` where the embedderdoesn't have static knowledge ahead of time about the type of thefuture/stream in use. Changes made here are:* `ComponentType for {Stream,Future}Reader` now correctly typecheck the `T`.* Conversion to/from `*Any` types now properly typechecks the payload type against the expected type.* `{Future,Stream}Any` now live in their own file with the matrix of conversions to the typed variants.* A `close` method was added to `*Any` types.These types are not currently directly constructible but this willlikely be relaxed in the future. Additionally the host can't actuallyuse these values without knowing the type, which is another restrictionthat will be relaxed in the future (aka implemented).cc #11161* Fix tests* Skip a test on miri List of files: /wasmtime-44.0.1/tests/all/component_model.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/tests/all/component_model.rs

ca7081a2 - Consolidate "util" crates for testing (#10423)

Thu, 20 Mar 2025 15:08:47 +0000

Consolidate "util" crates for testing (#10423)* Consolidate "util" crates for testingThis commit consolidates all of the existing crates we have for testinginto a smaller set of crates. Specifically:* `crates/misc/component-fuzz-util` => `wasmtime-test-util` + `component-fuzz` feature* `crates/misc/component-test-util` => `wasmtime-test-util` + `component` feature* `crates/wast-util` => `wasmtime-test-util` + `wast` feature* `crates/misc/component-macro-test` => `wasmtime-test-macros`The goal is to have one location we put various test helpers/macrosrather than our current organically-grown many locations. This isinspired by the test failure on #10405 where I'd like to refactor moreinfrastructure to a "test util" location but it wasn't clear where toput it so I wanted to do this refactoring first.* Remove unused file List of files: /wasmtime-44.0.1/tests/all/component_model.rs

287e8fb5 - Update wasm-tools crates to 226 (#10235)

Wed, 19 Feb 2025 20:38:07 +0000

Update wasm-tools crates to 226 (#10235)* Update wasm-tools crates to 226This commit updates the wasm-tools crates to the 226 track of versions.The most notable change here is the removal and refactoring withinwasm-tools of support for multiple and named returns in the componentmodel along with the support for 33+ flags in the `flags` type. This hasbeen gated for some time now and it's just now being removed now thatit's been awhile an no issues have been raised.prtest:full* Fix some issues from CI* Fix benchmarks* Switch to crates.io-based crates List of files: /wasmtime-44.0.1/tests/all/component_model.rs

0ba29075 - Use the CallHook::CallingHost and ReturningFromHost with components (#9196)

Thu, 05 Sep 2024 18:47:57 +0000

Use the CallHook::CallingHost and ReturningFromHost with components (#9196)* Use the CallHook::CallingHost and ReturningFromHost with componentsWe never implemented calling the CallingHost and ReturningFromHost hooksfor component host calls.co-authored-by: Nick Fitzgerald * Add tests* Run hooks under `catch_unwind_and_longjmp`* Cleanup the imports* Remove todo* Ensure that returning hooks are run* Appease clippy* Suggestions from code review* Reuse infrastructure from the core-wasm call-hook test* Remove redundant test* Add a realloc test* Switch the realloc test to handle returning a string* Rework the realloc test to check that we're tracking host reallocs* Use the call hook in the realloc host call* Unnecessary pub mod* Add a post-return test* Remove unnecessary assertions* Format* Remove incorrect hook calls for realloc uses---------Co-authored-by: Nick Fitzgerald List of files: /wasmtime-44.0.1/tests/all/component_model.rs

868dfb95 - Make `component::Linker` semver-aware (#7994)

Tue, 27 Feb 2024 19:34:27 +0000

Make `component::Linker` semver-aware (#7994)This commit is an implementation of #7860 for Wasmtime where`wasmtime::component::Linker` is now "semver aware". This means that itassumes that hosts are always managing WIT interfaces in asemver-aare fashion meaning that semver-compatible upgrade exclusivelyadds functionality. This neatly fits into the idea of subtyping at theinstance-level where if a binary built against 0.2.0 only requests asubset of functionality from a runtime that provides 0.2.1, that shouldwork just fine.Specifically what this change does is:* For all names inserted into a `Linker` there might also be a "semver compatible name" which is registered as well. For example `..@1.0.0` is also registered as `..@1`.* Semver-compatible names are only provided for versions without a prerelease and with either a nonzero major or minor version number.* When looking up an item in the linker if no exact match is found then if a semver-compatible-name is available for the lookup key then that's consulted as well.This semantically means that if a components imports WASI 0.2.0 then aruntime which only provides WASI 0.2.1 will be able to instantiate thecomponent. Furthermore if a component imports WASI 0.2.1 but onlyimports the subset of WASI that was available in 0.2.0 then it will beinstantiable in a runtime that only supports 0.2.0.This implementation is intended to be a crucial part of the evolution toWASI to make it more seamless to upgrade WASI from both a host and guestperspective. This no longer requires everyone to upgrade to the sameversion all at the same time but instead decouples the upgradeschedules.Closes #7860 List of files: /wasmtime-44.0.1/tests/all/component_model.rs

5a6ed0fb - Implement component model resources in Wasmtime (#6691)

Fri, 21 Jul 2023 23:27:40 +0000

Implement component model resources in Wasmtime (#6691)* Fix signatures registered with modules-in-componentsThis commit fixes a minor issue in`FunctionIndices::link_and_append_code` which previously ended up onlyfilling out the `wasm_to_native_trampolines` field for the first modulerather than all the modules. Additionally the first module might havetoo many entries that encompass all modules instead of just its ownentries. The fix in this commit is to refactor this logic to ensure thatthe necessary maps are present for all translations.While technically a bug that can be surfaced through the embedder APIit's pretty obscure. The given test here panics beforehand but succeedsafterwards, but this is moreso prep for some future resource-relatedwork where this map will need persisting into the component metadataside of things.* Initial support for resourcesLots of bits and pieces squashed into this commit. Much to be donestill.* Start supporting destructors* Get some basic drop tests workingAlso add a test which requires host-defined drop to be called whichisn't working.* Fix rebase issue* Fix a failing test* I am zorthax, destroyer of resources* Remove a branch in compiled codeNo need to check for a null funcref when we already know ahead of timeif it's ever going to be null or not.* Fix the test suite* Add embedder API to destroy resources* Add TODO for factc* Fix a warning and leave a comment* Integrate resources into `Type`Plumb around dynamic information about resource types.* Implement `Val::Own`* Implement reentrance check for destructorsImplemented both in the raw wasm intrinsic as well as the host.* Use cast instead of transmute* Fill out some cranelift-shared comments* Update codegen for resource.drop shimThe MAY_ENTER flag must always be checked, regardless of whether there'san actual destructor or not.* Update wasm-tools crates to latest `main`* Update resource.drop binary format* Add some docs* Implement dynamic tracking for borrow resourcesNot actually hooked up anywhere but this should at least be a first stabat an implementation of the spec.* Remove git overrides* Remove no-longer-needed arms in wit-bindgen* Prepare for mutability in `LiftContext`* Change `&LiftContext` to `&mut LiftContext`* Remove `store: &'a StoreOpaque` from `LiftContext`, instead storing just `memory: &'a [u8]`* Refactor methods to avoid needing the entire `StoreOpaque`This'll enable `LiftContext` to store `&'a mut ResourceTable` in anupcoming commit to refer to the host's resources.* Lowering a borrow is infallible* Use `ResourceAny` for both own/borrowRename `Val::Own` to `Val::Resource` accordingly.* Initial implementation of borrowed resourcesLots of juggling of contexts here and there to try and get everythingworking but this is hopefully a faithful implementation. Tests notimplemented yet and will come next and additionally likely updateimplementation details as issues are weeded out.* Add a suite of tests for borrowing resourcesCode coverage was used to ensure that almost all of the various pathsthrough the code are taken to ensure all the basic bases are covered.There's probably still lurking bugs, but this should be a solid enoughbase to start from hopefully.* Fill in an issue for bindgen todo* Add docs, still more to go* Fill out more documentation* Fill out a test TODO* Update the host `Resource` type* Add docs everywhere* Don't require a `Store` for creating the resource or getting the representation.The latter point is the main refactoring in this commit. This is done inpreparation for `bindgen!` to use this type where host bindingsgenerally do not have access to the store.* Document `ResourceAny`* Debug assert dtor is non-null* Review comments on loading libcalls* Update some comments* Update a comment* Fix some typos* Add a test that host types are the same when guest types differ* Fix some typos* Thread things through a bit less* Undo CompileKey-related changes* Gate an async function on the async feature* Fix doc links* Skip resources tests in miriThey all involve compilation which takes too long and doesn't currentlywork List of files: /wasmtime-44.0.1/tests/all/component_model.rs

f928bf72 - Update to latest wasm-tools crates (#6378)

Tue, 16 May 2023 00:14:31 +0000

Update to latest wasm-tools crates (#6378)* Update to latest wasm-tools cratesThis commit pushes through the full update of the wasm-tools cratesthrough Wasmtime. There are two major features which changed, bothrelated to components, which required updates in Wasmtime:* Resource types are now implemented in wasm-tools and they're not yet implemented in Wasmtime so I've stubbed out the integration point with panics as reminders to come back and implement them.* There are new validation rules about how aggregate types must be named. This doesn't affect runtime internals at all but was done on behalf of code generators. This did however affect a number of tests which have to ensure that types are exported.* Fix more tests* Add vet entries List of files: /wasmtime-44.0.1/tests/all/component_model.rs

c0bb341d - Run some tests in MIRI on CI (#6332)

Wed, 03 May 2023 21:02:33 +0000

Run some tests in MIRI on CI (#6332)* Run some tests in MIRI on CIThis commit is an implementation of getting at least chunks of Wasmtimeto run in MIRI on CI. The full test suite is not possible to run in MIRIbecause MIRI cannot run Cranelift-produced code at runtime (aka itdoesn't support JITs). Running MIRI, however, is still quite valuable ifwe can manage it because it would have trivially detectedGHSA-ch89-5g45-qwc7, our most recent security advisory. The goal of thisPR is to select a subset of the test suite to execute in CI under MIRIand boost our confidence in the copious amount of `unsafe` code inWasmtime's runtime.Under MIRI's default settings, which is to use the [StackedBorrows][stacked] model, much of the code in `Instance` and `VMContext`is considered invalid. Under the optional [Tree Borrows][tree] model,however, this same code is accepted. After some [extremely helpfuldiscussion][discuss] on the Rust Zulip my current conclusion is thatwhat we're doing is not fundamentally un-sound but we need to model itin a different way. This PR, however, uses the Tree Borrows model forMIRI to get something onto CI sooner rather than later, and I hope tofollow this up with something that passed Stacked Borrows. Additionallythat'll hopefully make this diff smaller and easier to digest.Given all that, the end result of this PR is to get 131 separate unittests executing on CI. These unit tests largely exercise the embeddingAPI where wasm function compilation is not involved. Some tests compilewasm functions but don't run them, but compiling wasm through Craneliftin MIRI is so slow that it doesn't seem worth it at this time. This doesmean that there's a pretty big hole in MIRI's test coverage, but that'sto be expected as we're a JIT compiler after all.To get tests working in MIRI this PR uses a number of strategies:* When platform-specific code is involved there's now `#[cfg(miri)]` for MIRI's version. For example there's a custom-built "mmap" just for MIRI now. Many of these are simple noops, some are `unimplemented!()` as they shouldn't be reached, and some are slightly nontrivial implementations such as mmaps and trap handling (for native-to-native function calls).* Many test modules are simply excluded via `#![cfg(not(miri))]` at the top of the file. This excludes the entire module's worth of tests from MIRI. Other modules have `#[cfg_attr(miri, ignore)]` annotations to ignore tests by default on MIRI. The latter form is used in modules where some tests work and some don't. This means that all future test additions will need to be effectively annotated whether they work in MIRI or not. My hope though is that there's enough precedent in the test suite of what to do to not cause too much burden.* A number of locations are fixed with respect to MIRI's analysis. For example `ComponentInstance`, the component equivalent of `wasmtime_runtime::Instance`, was actually left out from the fix for the CVE by accident. MIRI dutifully highlighted the issues here and I've fixed them locally. Some locations fixed for MIRI are changed to something that looks similar but is subtly different. For example retaining items in a `Store` is now done with a Wasmtime-specific `StoreBox` type. This is because, with MIRI's analyses, moving a `Box` invalidates all pointers derived from this `Box`. We don't want these semantics, so we effectively have a custom `Box` to suit our needs in this regard.* Some default configuration is different under MIRI. For example most linear memories are dynamic with no guards and no space reserved for growth. Settings such as parallel compilation are disabled. These are applied to make MIRI "work by default" in more places ideally. Some tests which perform N iterations of something perform fewer iterations on MIRI to not take quite so long.This PR is not intended to be a one-and-done-we-never-look-at-it-againkind of thing. Instead this is intended to lay the groundwork tocontinuously run MIRI in CI to catch any soundness issues. This feels,to me, overdue given the amount of `unsafe` code inside of Wasmtime. Myhope is that over time we can figure out how to run Wasm in MIRI butthat may take quite some time. Regardless this will be adding nontrivialmaintenance work to contributors to Wasmtime. MIRI will be run on CI formerges, MIRI will have test failures when everything else passes,MIRI's errors will need to be deciphered by those who have probablynever run MIRI before, things like that. Despite all this to me it seemsworth the cost at this time. Just getting this running caught twopossible soundness bugs in the component implementation that could havehad a real-world impact in the future![stacked]: https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md[tree]: https://perso.crans.org/vanille/treebor/[discuss]: https://rust-lang.zulipchat.com/#narrow/stream/269128-miri/topic/Tree.20vs.20Stacked.20Borrows.20.26.20a.20debugging.20question* Update alignment comment List of files: /wasmtime-44.0.1/tests/all/component_model.rs

2329ecc3 - Add a `wasmtime::component::bindgen!` macro (#5317)

Tue, 06 Dec 2022 19:06:00 +0000

Add a `wasmtime::component::bindgen!` macro (#5317)* Import Wasmtime support from the `wit-bindgen` repo This commit imports the `wit-bindgen-gen-host-wasmtime-rust` crate from the `wit-bindgen` repository into the upstream Wasmtime repository. I've chosen to not import the full history here since the crate is relatively small and doesn't have a ton of complexity. While the history of the crate is quite long the current iteration of the crate's history is relatively short so there's not a ton of import there anyway. The thinking is that this can now continue to evolve in-tree. * Refactor `wasmtime-component-macro` a bit Make room for a `wit_bindgen` macro to slot in. * Add initial support for a `bindgen` macro * Add tests for `wasmtime::component::bindgen!` * Improve error forgetting `async` feature * Add end-to-end tests for bindgen * Add an audit of `unicase` * Add a license to the test-helpers crate * Add vet entry for `pulldown-cmark` * Update publish script with new crate * Try to fix publish script * Update audits * Update lock file List of files: /wasmtime-44.0.1/tests/all/component_model.rs

b305f251 - Update the wasm-tools family of crates (#5310)

Mon, 21 Nov 2022 21:37:16 +0000

Update the wasm-tools family of crates (#5310)Most of the changes here are the updates to the component model which includes optional URL fields in imports/exports. List of files: /wasmtime-44.0.1/tests/all/component_model.rs

cd53bed8 - Implement AOT compilation for components (#5160)

Wed, 02 Nov 2022 15:26:26 +0000

Implement AOT compilation for components (#5160)* Pull `Module` out of `ModuleTextBuilder` This commit is the first in what will likely be a number towards preparing for serializing a compiled component to bytes, a precompiled artifact. To that end my rough plan is to merge all of the compiled artifacts for a component into one large object file instead of having lots of separate object files and lots of separate mmaps to manage. To that end I plan on eventually using `ModuleTextBuilder` to build one large text section for all core wasm modules and trampolines, meaning that `ModuleTextBuilder` is no longer specific to one module. I've extracted out functionality such as function name calculation as well as relocation resolving (now a closure passed in) in preparation for this. For now this just keeps tests passing, and the trajectory for this should become more clear over the following commits. * Remove component-specific object emission This commit removes the `ComponentCompiler::emit_obj` function in favor of `Compiler::emit_obj`, now renamed `append_code`. This involved significantly refactoring code emission to take a flat list of functions into `append_code` and the caller is responsible for weaving together various "families" of functions and un-weaving them afterwards. * Consolidate ELF parsing in `CodeMemory` This commit moves the ELF file parsing and section iteration from `CompiledModule` into `CodeMemory` so one location keeps track of section ranges and such. This is in preparation for sharing much of this code with components which needs all the same sections to get tracked but won't be using `CompiledModule`. A small side benefit from this is that the section parsing done in `CodeMemory` and `CompiledModule` is no longer duplicated. * Remove separately tracked traps in components Previously components would generate an "always trapping" function and the metadata around which pc was allowed to trap was handled manually for components. With recent refactorings the Wasmtime-standard trap section in object files is now being generated for components as well which means that can be reused instead of custom-tracking this metadata. This commit removes the manual tracking for the `always_trap` functions and plumbs the necessary bits around to make components look more like modules. * Remove a now-unnecessary `Arc` in `Module` Not expected to have any measurable impact on performance, but complexity-wise this should make it a bit easier to understand the internals since there's no longer any need to store this somewhere else than its owner's location. * Merge compilation artifacts of components This commit is a large refactoring of the component compilation process to produce a single artifact instead of multiple binary artifacts. The core wasm compilation process is refactored as well to share as much code as necessary with the component compilation process. This method of representing a compiled component necessitated a few medium-sized changes internally within Wasmtime: * A new data structure was created, `CodeObject`, which represents metadata about a single compiled artifact. This is then stored as an `Arc` within a component and a module. For `Module` this is always uniquely owned and represents a shuffling around of data from one owner to another. For a `Component`, however, this is shared amongst all loaded modules and the top-level component. * The "module registry" which is used for symbolicating backtraces and for trap information has been updated to account for a single region of loaded code holding possibly multiple modules. This involved adding a second-level `BTreeMap` for now. This will likely slow down instantiation slightly but if it poses an issue in the future this should be able to be represented with a more clever data structure. This commit additionally solves a number of longstanding issues with components such as compiling only one host-to-wasm trampoline per signature instead of possibly once-per-module. Additionally the `SignatureCollection` registration now happens once-per-component instead of once-per-module-within-a-component. * Fix compile errors from prior commits * Support AOT-compiling components This commit adds support for AOT-compiled components in the same manner as `Module`, specifically adding: * `Engine::precompile_component` * `Component::serialize` * `Component::deserialize` * `Component::deserialize_file` Internally the support for components looks quite similar to `Module`. All the prior commits to this made adding the support here (unsurprisingly) easy. Components are represented as a single object file as are modules, and the functions for each module are all piled into the same object file next to each other (as are areas such as data sections). Support was also added here to quickly differentiate compiled components vs compiled modules via the `e_flags` field in the ELF header. * Prevent serializing exported modules on components The current representation of a module within a component means that the implementation of `Module::serialize` will not work if the module is exported from a component. The reason for this is that `serialize` doesn't actually do anything and simply returns the underlying mmap as a list of bytes. The mmap, however, has `.wasmtime.info` describing component metadata as opposed to this module's metadata. While rewriting this section could be implemented it's not so easy to do so and is otherwise seen as not super important of a feature right now anyway. * Fix windows build * Fix an unused function warning * Update crates/environ/src/compilation.rs Co-authored-by: Nick Fitzgerald Co-authored-by: Nick Fitzgerald List of files: /wasmtime-44.0.1/tests/all/component_model.rs

12e4a1ba - component model: async host function & embedding support (#5055)

Tue, 18 Oct 2022 20:40:57 +0000

component model: async host function & embedding support (#5055)* func_wrap_async typechecks * func call async * instantiate_async * fixes * async engine creation for tests * start adding a component model test for async * fix wrong check for async support, factor out Instance::new_started to an unchecked impl * tests: wibbles * component::Linker::func_wrap: replace IntoComponentFunc with directly accepting a closure We find that this makes the Linker::func_wrap type signature much easier to read. The IntoComponentFunc abstraction was adding a lot of weight to "splat" a set of arguments from a tuple of types into individual arguments to the closure. Additionally, making the StoreContextMut argument optional, or the Result optional, wasn't very worthwhile. * Fixes for the new style of closure required by component::Linker::func_wrap * future of result of return * add Linker::instantiate_async and {Typed}Func::post_return_async * fix fuzzing generator * note optimisation opportunity * simplify test List of files: /wasmtime-44.0.1/tests/all/component_model.rs

29c7de73 - Update wasm-tools dependencies (#4970)

Tue, 27 Sep 2022 18:12:34 +0000

Update wasm-tools dependencies (#4970)* Update wasm-tools dependencies This update brings in a number of features such as: * The component model binary format and AST has been slightly adjusted in a few locations. Names are dropped from parameters/results now in the internal representation since they were not used anyway. At this time the ability to bind a multi-return function has not been exposed. * The `wasmparser` validator pass will now share allocations with prior functions, providing what's probably a very minor speedup for Wasmtime itself. * The text format for many component-related tests now requires named parameters. * Some new relaxed-simd instructions are updated to be ignored. I hope to have a follow-up to expose the multi-return ability to the embedding API of components. * Update audit information for new crates List of files: /wasmtime-44.0.1/tests/all/component_model.rs