Changes in mod.rs

b112bb85 - Migrate winch-codegen to `wasmtime_environ::error` (#12297)

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

Migrate winch-codegen to `wasmtime_environ::error` (#12297) List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.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/winch/codegen/src/isa/mod.rs

7a66c39a - Remove some `#![expect(clippy::allow_attributes_without_reason)]` (#10661)

Wed, 23 Apr 2025 21:07:33 +0000

Remove some `#![expect(clippy::allow_attributes_without_reason)]` (#10661)Clean up some crates by migrating from `#[allow]` to `#[expect]`(ideally) or `#[allow]`-with-reason List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

792cccce - winch: Track the callee calling convention (#9757)

Fri, 06 Dec 2024 19:49:33 +0000

winch: Track the callee calling convention (#9757)* winch: Track the callee calling conventionThis commit aims to improve the consistency of call emission in Winch.Prior to this commit, the calling convention at Winch's assembler layerwas hardcoded. Even though the calling convention invariants arecorrectly handled early on in the code generation process and this hasno effect on the generated code, it could lead to subtle bugs ifCranelift's emission infrastructure changes. It could also be confusingwhen trying to implement call instrutions for other backends.This change is motivated by some of the questions in https://github.com/bytecodealliance/wasmtime/pull/9751* Clippy fixes List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

194b4803 - Remove the use of `MemoryStyle` in Winch (#9581)

Thu, 07 Nov 2024 16:28:36 +0000

Remove the use of `MemoryStyle` in Winch (#9581)This applies a similar change as #9576 but to Winch. Similar to theprevious PR one case needed some reshuffling, but otherwise all currentbehavior is maintained and this should otherwise be a refactoring. List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

2f684ba1 - winch: Implement Fuel-Based Interruption (#9472)

Tue, 22 Oct 2024 19:14:23 +0000

winch: Implement Fuel-Based Interruption (#9472)* winch: Implement Fuel-Based InterruptionCloses: https://github.com/bytecodealliance/wasmtime/issues/8090This commit introduces the initial implementation of fuel-basedinterruption in Winch.To maintain consistency with existing fuel semantics, thisimplementation closely follows the Wasmtime/Cranelift approach, with thefollowing exception:* Local Fuel Cache: Given Winch's emphasis on compilation speed, this implementation does not optimize for minimizing loads and stores. As a result, checking and incrementing fuel currently requires explicit loads and stores. Future optimizations may be considered to improve this aspect.This commit also includes a small refactoring in the visitor, whichintroduces more generic "visitor hook" which enable handling the invariants that needto happen before and after emitting machine code for each Wasm operator.* Use the vmruntime limits directly* Remove unsupported fuel warning List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

a659b5a9 - Couple of cleanups to the ABI computation (#9253)

Mon, 16 Sep 2024 16:20:47 +0000

Couple of cleanups to the ABI computation (#9253)* Remove WasmtimeSystemV call convIt is no longer used by Wasmtime* Remove CallConv::extends_* methodsThey all match only a single call conv anyway.* Avoid isa:: prefix for referencing CallConv where possible* Update callconv list in the clif ir reference* Use push_non_formal where expected List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

721600ca - winch: Improve result handling for Aarch64 (#9171)

Tue, 27 Aug 2024 15:20:07 +0000

winch: Improve result handling for Aarch64 (#9171)* winch: Improve result handling for Aarch64This commit introduces missing tests for Aarch64's ABI implementation.Compared to the x64 counterpart, the aarch64 implementation was missingtests for multi-value.Additionally, this commit fixes an issue with how multi-value returnsare handlded in Winch's default calling convention, which only allows1 register result, independent of the register class.This commit also refactors the register indexing environment so that itcan be easily shared across the existing backends.* Keep comments on Aarch64 register assignment List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

5036bb0b - Fix: 4 typos (#8291)

Tue, 02 Apr 2024 19:35:50 +0000

Fix: 4 typos (#8291)Signed-off-by: RoboSchmied List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

d38d387a - Fix rustdoc warnings on Nightly (#8258)

Thu, 28 Mar 2024 19:19:22 +0000

Fix rustdoc warnings on Nightly (#8258)* Fix rustdoc warnings on NightlyI noticed during a failed doc build of another PR we've got a number ofwarnings being emitted, so resolve all those here.* Fix more warnings* Fix rebase conflicts List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

355990b4 - Exit through Cranelift-generated trampolines for builtins (#8152)

Fri, 22 Mar 2024 20:34:26 +0000

Exit through Cranelift-generated trampolines for builtins (#8152)* Exit through Cranelift-generated trampolines for builtinsThis commit changes how builtin functions in Wasmtime (think`memory.grow`) are implemented. These functions are required to exitthrough some manner of trampoline to handle runtime requirements forbacktracing right now. Currently this is done via inline assembly foreach architecture (or external assembly for s390x). This is a bitunfortunate as it's a lot of hand-coding and making sure everything isright, and it's not easy to update as it's multiple platforms to update.The change in this commit is to instead use Cranelift-generatedtrampolines for this purpose instead. The path for invoking a builtinfunction now looks like:* Wasm code calls a statically known symbol for each builtin.* The statically known symbol will perform exit trampoline duties (e.g. pc/fp/etc) and then load a function pointer to the host implementation.* The host implementation is invoked and then proceeds as usual.The main new piece for this PR is that all wasm modules and functionsare compiled in parallel but an output of this compilation phase is whatbuiltin functions are required. All builtin functions are then unionedtogether into one set and then anything required is generated justafterwards. That means that only one builtin-trampoline per-module isgenerated per-builtin.This work is inspired by #8135 and my own personal desire to have asmuch about our ABI details flowing through Cranelift as we can. This intheory makes it more flexible to deal with future improvements to ourABI.prtest:full* Fix some build issues* Update winch test expectations* Update Winch to use new builtin shims.This commit refactors the Winch compiler to use the new trampolines forall Wasmtime builtins created in the previous commits. This required afair bit of refactoring to handle plumbing through a new kind ofrelocation and function call.Winch's `FuncEnv` now contains a `PrimaryMap` from `UserExternalNameRef`to `UserExternalName`. This is because there's now more than one kind ofname than just wasm function relocations, so the raw index space of`UserExternalNameRef` is no longer applicable. This required threading`FuncEnv` to more locations along with some refactorings to ensure thatlifetimes work out ok.The `CompiledFunction` no longer stores a trait object of how to mapname refs to names and now directly has a `Primarymap`. This also meansthat Winch's return value from its `TargetIsa` is a `CompiledFunction`as opposed to the previous just-a-`MachBuffer` so it can also package upall the relocation information. This ends up having `winch-codegen`depend on `wasmtime-cranelift-shared` as a new dependency.* Review feedback List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

d69ba34e - winch: Switch to using cranelift for all trampolines (#8109)

Thu, 21 Mar 2024 17:59:43 +0000

winch: Switch to using cranelift for all trampolines (#8109)* Switch winch over to using cranelift for all trampolines* Fix unused code warnings* Fix unused code warningsprtest:full List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

0bcceda3 - winch: Emit unwind info in the x64 backend (#7798)

Thu, 25 Jan 2024 23:11:48 +0000

winch: Emit unwind info in the x64 backend (#7798)* Enable all winch tests on windowsprtest:mingw-x64* Plumb through x64 unwind info creation* Add the frame regs unwind info* Emit UnwindInfo::SaveReg instructions* Review feedback* Comment the offset_downward_to_clobbers value List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

ef07f40f - Update the wasm-tools family of crates (#7587)

Mon, 27 Nov 2023 18:32:03 +0000

Update the wasm-tools family of crates (#7587)This commit updates to the latest wasm-tools and `wit-bindgen` to bringthe family of crates forward. This update notably includes Nick's workon packed indices in the `wasmparser` crate for validation for theupcoming implementation of GC types. This meant that translation from`wasmparser` types to Wasmtime types now may work with a "type id"instead of just a type index which required plumbing not only Wasmtime'sown type information but additionally `wasmparser`'s type informationthroughout translation.This required a fair bit of refactoring to get this working but nochange in functionality is intended, only a different way of doingeverything prior. List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

f0162a40 - winch: Multi-Value Part 1 (#7535)

Tue, 14 Nov 2023 21:54:00 +0000

winch: Multi-Value Part 1 (#7535)* winch: Introduce `ABIParams` and `ABIResults`This commit prepares Winch to support WebAssembly Multi-Value.The most notorious piece of this change is the introduction of the`ABIParams` and `ABIResults` structs which are type wrappers around theconcept of an `ABIOperand`, which is the underlying main representationof a param or result.This change also consolidates how the size for WebAssembly types isderived by introducing `ABI::sizeof`, as well as introducing`ABI::stack_slot_size` to concretely indicate the stack slot size inbytes for stack params, which is ABI dependent.* winch: Add the necessary ABI building blocks for multi-valueThis change adds the necessary changes at the ABI level in order tohandle multi-value.The most notable modifications in this change are:* Modifying Winch's default ABI to reverse the order of results, ensuring that results that go in the stack should always come first; this makes it easier to respect the following two stack invariants: * Spilled memory values always precede register values * Spilled values are stored from oldest to newest, matching their respective locations on the machine stack.* Modify all calling conventions supported by Winch so that only one result, the first one is stored in registers. This differs from their vanilla counterparts in that these ABIs can handle multiple results in registers. Given that Winch is not a generic code generator, keeping the ABI close to what Wasmtime expects makes it easier to pass multiple results at trampolines.* Add more multi-value testsThis commit adds more tests for multi-value and improves documentation.prtest:full* Address review feedback List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

4f47f3ec - winch: Add a subset of known libcalls and improve call emission (#7228)

Fri, 13 Oct 2023 18:57:49 +0000

winch: Add a subset of known libcalls and improve call emission (#7228)* winch: Add known a subset of known libcalls and improve call emissionThis change is a follow up to:- https://github.com/bytecodealliance/wasmtime/pull/7155- https://github.com/bytecodealliance/wasmtime/pull/7035One of the objectives of this change is to make it easy to emitfunction calls at the MacroAssembler layer, for cases in which it'schallenging to know ahead-of-time if a particular functionality can beachieved natively (e.g. rounding and SSE4.2). The original implementationof function call emission, made this objective difficult to achieve andit was also difficult to reason about.I decided to simplify the overall approach to function calls as part ofthis PR; in essence, the `call` module now exposes a single function`FnCall::emit` which is reponsible of gathtering the dependencies andorchestrating the emission of the call. This new approach deliberatelyavoids holding any state regarding the function call for simplicity.This change also standardizes the usage of `Callee` as the mainentrypoint for function call emission, as of this change 4 `Callee`types exist (`Local`, `Builtin`, `Import`, `FuncRef`), each callee kindis mappable to a `CalleeKind` which is the materialized version ofa callee which Cranelift understands.This change also moves the creation of the `BuiltinFunctions` to the`ISA` level given that they can be safely used accross multiple functioncompilations.Finally, this change also introduces support for some of the"well-known" libcalls and hooks those libcalls at the`MacroAssembler::float_round` callsite.--prtest:full* Review comments* Remove unnecessary `into_iter`* Fix remaining lifetime parameter names List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

4b288ba8 - winch(x64): Call indirect (#7100)

Fri, 29 Sep 2023 16:59:40 +0000

winch(x64): Call indirect (#7100)* winch(x64): Call indirectThis change adds support for the `call_indirect` instruction to Winch.Libcalls are a pre-requisite for supporting `call_indirect` in order tolazily initialy funcrefs. This change adds support for libcalls toWinch by introducing a `BuiltinFunctions` struct similar to Cranelift's`BuiltinFunctionSignatures` struct.In general, libcalls are handled like any other function call, with theonly difference that given that not all the information to fulfill thefunction call might be known up-front, control is given to the callerfor finalizing the call.The introduction of function references also involves dealing withpointer-sized loads and stores, so this change also adds the requiredfunctionality to `FuncEnv` and `MacroAssembler` to be pointer aware,making it straight forward to derive an `OperandSize` or `WasmType` fromthe target's pointer size.Finally, given the complexity of the call_indirect instrunction, thischange bundles an improvement to the register allocator, allowing it totrack the allocatable vs non-allocatable registers, this is done toavoid any mistakes when allocating/de-allocating registers that are notalloctable.--prtest:full* Address review comments* Fix typos* Better documentation for `new_unchecked`* Introduce `max` for `BitSet`* Make allocatable property `u64`* winch(calls): Overhaul `FnCall`This commit simplifies `FnCall`'s interface making its usage moreuniform throughout the compiler. In summary, this change:* Avoids side effects in the `FnCall::new` constructor, and also makes it the only constructor.* Exposes `FnCall::save_live_registers` and `FnCall::calculate_call_stack_space` to calculate the stack space consumed by the call and so that the caller can decide which one to use at callsites depending on their use-case.* tests: Fix regset tests List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

39c96c7a - Remove Wasmtime ABIs from Cranelift (#6649)

Wed, 28 Jun 2023 18:53:19 +0000

Remove Wasmtime ABIs from Cranelift (#6649)* Remove Wasmtime ABIs from CraneliftThis commit removes the `Wasmtime*` family of ABIs from Cranelift. Thesewere originally added to support multi-value in Wasmtime via the`TypedFunc` API, but they should now no longer be necessary. In generalthis is a higher-level Wasmtime concern than something all backends ofCranelift should have to deal with.Today with recent refactorings it's possible to remove the reliance onABI details for multi-value and instead codify it directly into theCranelift IR generated. For example wasm calls are able to have a"purely internal" ABI which Wasmtime's Rust code doesn't see at all, andthe Rust code only interacts with the native ABI. The native ABI isredefined to be what the previous Wasmtime ABIs were, which is to returnthe first of a 2+ value return through a register (native return value)and everything else through a return pointer.* Remove some wasmtime_system_v usage in tests* Add back WasmtimeSystemV for s390x* Fix some docs and references in winch* Fix another doc link List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

92024ad1 - Function references (#5288)

Fri, 26 May 2023 15:26:00 +0000

Function references (#5288)* Make wasmtime-types type check* Make wasmtime-environ type check.* Make wasmtime-runtime type check* Make cranelift-wasm type check* Make wasmtime-cranelift type check* Make wasmtime type check* Make wasmtime-wast type check* Make testsuite compile* Address Luna's comments* Restore compatibility with effect-handlers/wasm-tools#func-ref-2* Add function refs feature flag; support testing* Provide function references support in helpers- Always support Index in blocktypes- Support Index as table type by pretending to be Func- Etc* Implement ref.as_non_null* Add br_on_null* Update Cargo.lock to use wasm-tools with peekThis will ultimately be reverted when we refer towasm-tools#function-references, which doesn't have peek, but does have typeannotations on CallRef* Add call_ref* Support typed function references in ref.null* Implement br_on_non_null* Remove extraneous flag; default func refs false* Use IndirectCallToNull trap code for call_ref* Factor common call_indirect / call_ref into a fn* Remove copypasta clippy attribute / format* Add a some more tests for typed table instructionsThere certainly need to be many more, but this at least catches the bugs fixedin the next commit* Fix missing typed cases for table_grow, table_fill* Document trap code; remove answered question* Mark wasm-tools to wasmtime reftype infallible* Fix reversed conditional* Scope externref/funcref shorthands within WasmRefType* Merge with upstream* Make wasmtime compile again* Fix warnings* Remove Bot from the type algebra* Fix table tests.`wast::Cranelift::spec::function_references::table``wast::Cranelift::spec::function_references::table_pooling`* Fix table{get,set} tests.```wast::Cranelift::misc::function_references::table_getwast::Cranelift::misc::function_references::table_get_poolingwast::Cranelift::misc::function_references::table_setwast::Cranelift::misc::function_references::table_set_pooling```* Insert subtype check to fix local_get tests.```wast::Cranelift::spec::function_references::local_getwast::Cranelift::spec::function_references::local_get_pooling```* Fix compilation of `br_on_non_null`.The branch destinations were the other way round... :-)Fixes the following test failures:```wast::Cranelift::spec::function_references::br_on_non_nullwast::Cranelift::spec::function_references::br_on_non_null_pooling```* Fix ref_as_non_null tests.The test was failing due to the wrong error message being printed. Asper upstream folks' suggest we were using the trap code`IndirectCallToNull`, but it produces an unexpected error message.This commit reinstates the `NullReference` trap code. It produces theexpected error message. We will have to chat with the maintainersupstream about how to handle these "test failures".Fixes the following test failures:```wast::Cranelift::spec::function_references::ref_as_non_nullwast::Cranelift::spec::function_references::ref_as_non_null_pooling```* Fix a call_ref regression.* Fix global tests.Extend `is_matching_assert_invalid_error_message` to circumvent the textual error message failure.Fixes the following test failures:```wast::Cranelift::spec::function_references::globalwast::Cranelift::spec::function_references::global_pooling```* Cargo update* Update* Spell out some cases in match_val* Disgusting hack to subvert limitations of type reconstruction.In the function `wasmtime::values::Val::ty()` attempts to reconstructthe type of its underlying value purely based on the shape of thevalue. With function references proposal this sort of reconstructionis no longer complete as a source reference type may have beennullable. Nullability is not inferrable by looking at the shape of theruntime object alone.Consequently, the runtime cannot reconstruct the type for`Val::FuncRef` and `Val::ExternRef` by looking at their respectiveshapes.* Address workflows comments.* null reference => null_reference for CLIF parsing compliance.* Delete duplicate-loads-dynamic-memory-egraph (again)* Idiomatic code change.* Nullability subtyping + fix non-null storage check.This commit removes the `hacky_eq` check in `func.rs`. Instead it isreplaced by a subtype check. This subtype check occurs in`externals.rs` too.This commit also fixes a bug. Previously, it was possible to store anull reference into a non-null table cell. I have added to new testcases for this bug: one for funcrefs and another for externrefs.* Trigger unimplemented for typed function references. Format values.rs* run cargo fmt* Explicitly match on HeapType::Extern.* Address cranelift-related feedback* Remove PartialEq,Eq from ValType, RefType, HeapType.* Pin wasmparser to a fairly recent commit.* Run cargo fmt* Ignore tail call tests.* Remove garbage* Revert changes to wasmtime public API.* Run cargo fmt* Get more CI passing (#19)* Undo Cargo.lock changes * Fix build of cranelift tests* Implement link-time matches relation. Disable tests failing due to lack of public API support.* Run cargo fmt* Run cargo fmt* Initial implementation of eager table initialization* Tidy up eager table initialisation* Cargo fmt* Ignore type-equivalence test* Replace TODOs with descriptive comments.* Various changes found during review (#21)* Clarify a comment This isn't only used for null references * Resolve a TODO in local init Don't initialize non-nullable locals to null, instead skip initialization entirely and wasm validation will ensure it's always initialized in the scope where it's used. * Clarify a comment and skipping the null check. * Remove a stray comment * Change representation of `WasmHeapType` Use a `SignatureIndex` instead of a `u32` which while not 100% correct should be more correct. This additionally renames the `Index` variant to `TypedFunc` to leave space for future types which aren't functions to not all go into an `Index` variant. This required updates to Winch because `wasmtime_environ` types can no longer be converted back to their `wasmparser` equivalents. Additionally this means that all type translation needs to go through some form of context to resolve indices which is now encapsulated in a `TypeConvert` trait implemented in various locations. * Refactor table initialization Reduce some duplication and simplify some data structures to have a more direct form of table initialization and a bit more graceful handling of element-initialized tables. Additionally element-initialize tables are now treated the same as if there's a large element segment initializing them. * Clean up some unrelated chagnes * Simplify Table bindings slightly * Remove a no-longer-needed TODO * Add a FIXME for `SignatureIndex` in `WasmHeapType` * Add a FIXME for panicking on exposing function-references types * Fix a warning on nightly * Fix tests for winch and cranelift* Cargo fmt* Fix arity mismatch in aarch64/abi---------Co-authored-by: Daniel Hillerström Co-authored-by: Daniel Hillerström Co-authored-by: Alex Crichton List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs

afde47c2 - winch: Drop `FuncEnv` trait (#6443)

Wed, 24 May 2023 17:32:20 +0000

winch: Drop `FuncEnv` trait (#6443)This commit is a small cleanup to drop the usage of the `FuncEnv` trait.In https://github.com/bytecodealliance/wasmtime/pull/6358, we agreed onmaking `winch-codegen` directly depend on `wasmtime-environ`.Introducing a direct relatioship between `winch-codegen` and`wasmtime-environ` means that the `FuncEnv` trait is no longer servingits original purpose, and we can drop the usage of the trait and use thetypes exposed from `winch-codegen` directly instead.Even though this change drops the `FuncEnv` trait, it still keepsa `FuncEnv` struct, which is used during code generation. List of files: /wasmtime-44.0.1/winch/codegen/src/isa/mod.rs