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/frame/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/frame/mod.rs

366f320d - Update wasm spec test suite, add exception feature flags (#10553)

Tue, 08 Apr 2025 22:00:49 +0000

Update wasm spec test suite, add exception feature flags (#10553)* Update wasm spec test suite, add exception feature flagsThis commit performs an update of the spec test suite submodule to thenext-to-latest commit. The latest commit will require updating the`wast` dependency which isn't published yet.This update brings in the `wasm-3.0` folder of tests since it's beenawhile since the last update. That update notably means that theexception-handling proposal is mixed in with all the others with varioustests. Getting tests as flagged as passing or failing as a result wasunexpectedly difficult.The solution I ended up settling on was to preemptively implement someinfrastructure for the exceptions proposal:* `wasmtime::Config` methods* `wasmtime` CLI flags* integration with wast testing* various updates to `should_fail`It turns out we can run a few tests with the exception proposal, notablydue to tags being implemented for stack switching. That meant that thiscouldn't blanket ignore the exceptions proposal and say it's expected tofail. Instead the proposal is said "this passes!" and tests areindividually listed as "this is expected to fail".This then required changing an `unsupported!` panic to plumbing errorsaround to avoid actually implementing the exceptions proposal here.* Review comments List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

b93e1bc0 - winch: Gracefully handle compilation errors (#9851)

Wed, 01 Jan 2025 18:11:39 +0000

winch: Gracefully handle compilation errors (#9851)* winch: Gracefully handle compilation errorsCloses: https://github.com/bytecodealliance/wasmtime/issues/8096This commit threads `anyhow::Result` through most of Winch'scompilation process in order to gracefully handle compilation errorsgracefully instead of panicking.The error classification is intentionally very granular, to avoid stringallocation which could impact compilation performance.The errors are largely fit in two categories:* Unimplemented/Unsupported* InternalThe firs category signals partial or no support for Wasmtime featuresand or Wasm proposals. These errors are meant to be temporary whilesuch features or proposals are in development.The second category signals that a compilation invariant was not met.These errors are considered internal and their presence usually meansa bug in the compiler.* Include `Result` in the MacroAssemblerThis commit updates the MacroAssembler trait to require returning`Result` on every method in the interface, making it easier todetect partial support for Masm instructions. List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

7ef8f2e2 - winch: Improve frame handling (#9708)

Wed, 04 Dec 2024 19:12:09 +0000

winch: Improve frame handling (#9708)This commit addresses issues identified while working on issue #8091. Itimproves the frame handling in Winch to prevent subtle bugs and enhancethe robustness of the code generation process.Previously, there was no clear mechanism to verify when the frame wasfully set up and safe to access the local slots allocated for registerarguments, including the special slots used for the `VMContext`. Asa result, it was possible to inadvertently read from uninitializedmemory if calls were made before the frame was properly set up andsealed.This commit introduces two main changes with the objective to helpreduce the risk of introducing bugs related to the above:* A `CodeGenPhase` trait, used via the type state pattern to clearly gate the operations allowed during each phase of the code generation process.* Improve the semantics of locals, by clearly separating the notion of Wasm locals and special locals used by the compiler. This specialization allows a more accurate representation of the semantics of Wasm locals and their index space. List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

5393c2bf - Reduce typo count (#8951)

Mon, 15 Jul 2024 14:26:59 +0000

Reduce typo count (#8951) List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

0e9121da - Fix some typos (#8641)

Thu, 16 May 2024 23:21:22 +0000

Fix some typos (#8641)* occurred* winch typos* tests typos* cli typos* fuzz typos* examples typos* docs typos* crates/wasmtime typos* crates/environ typos* crates/cranelift typos* crates/test-programs typos* crates/c-api typos* crates/cache typos* crates other typos* cranelift/codegen/src/isa typos* cranelift/codegen/src other typos* cranelift/codegen other typos* cranelift other typos* ci js typo* .github workflows typo* RELEASES typo* Fix clang-format documentation line---------Co-authored-by: Andrew Brown List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

0e98a8d5 - winch: Overhaul the internal ABI (#7974)

Wed, 21 Feb 2024 22:48:02 +0000

winch: Overhaul the internal ABI (#7974)* winch: Overhaul the internal ABIThis change overhauls Winch's ABI. This means that as part of this change, the default ABI now closely resembles Cranelift's ABI, particularly on the treatment of the VMContext. This change also fixes many wrong assumptions about trampolines, which are tied to how the previous ABI operated.The main motivation behind this change is:* To make it easier to integrate Winch-generated functions with Wasmtime* Fix fuzz bugs related to imports* Solidify the implementation regarding the usage of a pinned register to hold the VMContext value throughout the lifetime of a function.The previous implementation had the following characteristics, and wrong assumptions):* Assumed that nternal functions don't receive a caller or callee VMContexts as parameters.* Worked correctly in the following scenarios: * `Wasm -> Native`: since we can explicitly load the caller and callee `VMContext`, because we're calling a native import. * `(Native, Array) -> Wasm`: because the native signatures define a tuple of `VMContext` as arguments.* It didn't work in the following scenario: * `Wasm->Wasm`: When calling imports from another WebAssembly instance (via direct call or `call_indirect`. The previous implementation wrongly assumes that there should be a trampoline in this case, but there isn't. The code was generated by the same compiler, so the same ABI should be used in both functions, but it doesn't. This change introduces the following changes, which fix the previous assumptions and bugs:* All internal functions declare a two extra pointer-sized parameters, which will hold the callee and caller `VMContext`s* Use a pinned register that will be considered live through the lifetime of the function instead of pinning it at the trampoline level. The pinning explicitlly happens when entering the function body and no other assumptions are made from there on.* Introduce the concept of special `ContextArgs` for function calls. This enum holds metadata about which context arguments are needed depending on the callee. The previous implementation of introducing register values at arbitrary locations in the value stack conflicts with the stack ordering principle which states that older values must *always* precede newer values. So we can't insert a register, because if a spill happens the order of the values will be wrong. Finally, given that this change also enables the `imports.wast` test suite, it also includes a fix to `global.{get, set}` instructions which didn't account entirely for imported globals. Resolved conflictsUpdate Winch filetests* Fix typos* Use `get_wasm_local` and `get_frame_local` instead of `get_local` and `get_local_unchecked`* Introduce `MAX_CONTEXT_ARGS` and use it in the trampoline to skip context arguments. List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

83cf7438 - winch: Add support for WebAssembly loads/stores (#7894)

Fri, 09 Feb 2024 15:28:33 +0000

winch: Add support for WebAssembly loads/stores (#7894)* winch: Add support for WebAssembly loads/storesCloses https://github.com/bytecodealliance/wasmtime/issues/6529This patch adds support for all the instructions involving WebAssemblyloads and stores for 32-bit memories. Given that the `memory64` proposalis not enabled by default, this patch doesn't include animplementation/tests for it; in theory minimal tweaks to thecurrrent implementation will be needed in order to support 64-bitmemories.Implemenation-wise, this change, follows a similar pattern as Craneliftin order to calculate addresses for dynamic/static heaps, the maindifference being that in some cases, doing less work at compile time ispreferred; the current implemenation only checks for the general case ofout-of-bounds access for dynamic heaps for example.Another important detail regarding the implementation, is theintroduction of `MacroAssembler::wasm_load` and`MacroAssembler::wasm_store`, which internally use a commonimplemenation for loads and stores, with the only difference that the`wasm_*` variants set the right flags in order to signal that theseoperations are not trusted and might trap.Finally, given that this change introduces support for the last set ofinstructions missing for a Wasm MVP, it removes most of Winch's copy ofthe spectest suite, and switches over to using the official test suitewhere possible (for tests that don't use SIMD or Reference Types).Follow-up items:* Before doing any deep benchmarking I'm planning on landing a couple of improvements regarding compile times that I've identified in parallel to this change.* The `imports.wast` tests are disabled because I've identified a bug with `call_indirect`, which is not related to this change and exists in main.* Find a way to run the `tests/all/memory.rs` (or perhaps most of integration tests) with Winch.--prtest:full* Review comments List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

496237c2 - Rename `WasmType` to `WasmValType` (#7838)

Mon, 29 Jan 2024 20:26:46 +0000

Rename `WasmType` to `WasmValType` (#7838)Purely mechanical, no functional changes.This is to help differentiate between value types (i32, i64, reference types,etc...) and defined types (function signatures, struct definitions, arraydefinitions). List of files: /wasmtime-44.0.1/winch/codegen/src/frame/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/frame/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/frame/mod.rs

db946cd5 - Fix Winch bug for funcs with params and locals (#7443)

Wed, 01 Nov 2023 16:23:23 +0000

Fix Winch bug for funcs with params and locals (#7443) List of files: /wasmtime-44.0.1/winch/codegen/src/frame/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/frame/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/frame/mod.rs

f70b0f39 - winch: Refactor the Masm associated types (#6451)

Thu, 25 May 2023 15:49:17 +0000

winch: Refactor the Masm associated types (#6451)This commit is a follow up to https://github.com/bytecodealliance/wasmtime/pull/6443,in which we discussed potentially having `PtrSize` and `ABI` asassociated types to the `MacroAssembler` trait.I considered having `PtrSize` associated to the `ABI`, but given theamount of ABI details needed at the `MacroAssembler` level, I decided togo with the approach in this change.The chosen approach ended up cutting a decent amount of boilerplate fromthe `MacroAssembler` itself, but also from each of the touchpoints wherethe `MacroAssembler` is used.This change also standardizes the signatures of the `ABI` trait. Some ofthem borrowed `&self` and some didn't, but in practice, there's no needto have any of them borrow `&self`. List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

20c58362 - winch: Implement new trampolines (#6358)

Tue, 16 May 2023 17:32:04 +0000

winch: Implement new trampolines (#6358)* winch: Implement new trampolinesThis change is a follow-up tohttps://github.com/bytecodealliance/wasmtime/pull/6262, in which the newtrampolines, described [here](https://github.com/bytecodealliance/rfcs/blob/main/accepted/tail-calls.md#new-trampolines-and-vmcallercheckedanyfunc-changes),were introduced to Wasmtime.This change, focuses on the `array-to-wasm`,`native-to-wasm` and `wasm-to-native` trampolines to restore Winch'sworking state prior to the introduction of the new trampolines. It'sworth noting that the new approach for trampolines make it easier to supportthe `TypedFunc` API in Winch. Prior to the introduction of the newtrampolines, it was not obvious how to approach it.This change also introduces a pinned register that will hold the`VMContext` pointer, which is loaded in the `*-to-wasm` trampolines;the `VMContext` register is a pre-requisite to this change to supportthe `wasm-to-native` trampolines.Lastly, with the introduction of the `VMContext` register and the`wasm-to-native` trampolines, this change also introduces support forcalling function imports, which is a variation of the already existingcalls to locally defined functions.The other notable piece of this change aside from the trampolines is`winch-codegen`'s dependency on `wasmtime-environ`. Winch is so closelytied to the concepts exposed by the wasmtime crates that it makes senseto tie them together, even though the separation provides someadvantages like easier testing in some cases, in the long run, there'sprobably going to be less need to test Winch in isolation and ratherwe'd rely more on integration style tests which require all of Wasmtimepieces anyway (fuzzing, spec tests, etc).This change doesn't update the existing implmenetation of`winch_codegen::FuncEnv`, but the intention is to update that part afterthis change.prtest:full* tests: Ignore miri in Winch integration tests* Remove hardcoded alignment and addend List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

3a92aa3d - winch: Initial integration with wasmtime (#6119)

Wed, 05 Apr 2023 00:32:40 +0000

winch: Initial integration with wasmtime (#6119)* Adding in trampoline compiling method for ISA* Adding support for indirect call to memory address* Refactoring frame to externalize defined locals, so it removes WASM depedencies in trampoline case* Adding initial version of trampoline for testing* Refactoring trampoline to be re-used by other architectures* Initial wiring for winch with wasmtime* Add a Wasmtime CLI option to select `winch`This is effectively an option to select the `Strategy` enumeration.* Implement `Compiler::compile_function` for WinchHook this into the `TargetIsa::compile_function` hook as well. Currentlythis doesn't take into account `Tunables`, but that's left as a TODO forlater.* Filling out Winch append_code method* Adding back in changes from previous branchMost of these are a WIP. It's missing trampolines for x64, but a basicone exists for aarch64. It's missing the handling of arguments thatexist on the stack.It currently imports `cranelift_wasm::WasmFuncType` since it's what'spassed to the `Compiler` trait. It's a bit awkward to use in the`winch_codegen` crate since it mostly operates on `wasmparser` types.I've had to hack in a conversion to get things working. Long term, I'mnot sure it's wise to rely on this type but it seems like it's easier onthe Cranelift side when creating the stub IR.* Small API changes to make integration easier* Adding in new FuncEnv, only a stub for now* Removing unneeded parts of the old PoC, and refactoring trampoline code* Moving FuncEnv into a separate file* More comments for trampolines* Adding in winch integration tests for first pass* Using new addressing method to fix stack pointer error* Adding test for stack arguments* Only run tests on x86 for now, it's more complete for winch* Add in missing documentation after rebase* Updating based on feedback in draft PR* Fixing formatting on doc comment for argv register* Running formatting* Lock updates, and turning on winch feature flags during tests* Updating configuration with comments to no longer gate Strategy enum* Using the winch-environ FuncEnv, but it required changing the sig* Proper comment formatting* Removing wasmtime-winch from dev-dependencies, adding the winch feature makes this not necessary* Update doc attr to include winch check* Adding winch feature to doc generation, which seems to fix the feature error in CI* Add the `component-model` feature to the cargo doc invocation in CITo match the metadata used by the docs.rs invocation when building docs.* Add a comment clarifying the usage of `component-model` for docs.rs* Correctly order wasmtime-winch and winch-environ in the publish script* Ensure x86 test dependencies are included in cfg(target_arch)* Further constrain Winch tests to x86_64 _and_ unix---------Co-authored-by: Alex Crichton Co-authored-by: Saúl Cabrera List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

94b51cdb - winch: Use cranelift-codegen x64 backend for emission. (#5581)

Wed, 18 Jan 2023 11:58:13 +0000

winch: Use cranelift-codegen x64 backend for emission. (#5581)This change substitutes the string based emission mechanism with cranelift-codegen's x64 backend. This change _does not_: * Introduce new functionality in terms of supported instructions. * Change the semantics of the assembler/macroassembler in terms of the logic to emit instructions. The most notable differences between this change and the previous version are: * Handling of shared flags and ISA-specific flags, which for now are left with the default value. * Simplification of instruction emission per operand size: previously the assembler defined different methods depending on the operand size (e.g. `mov` for 64 bits, and `movl` for 32 bits). This change updates such approach so that each assembler method takes an operand size as a parameter, reducing duplication and making the code more concise and easier to integrate with the x64's `Inst` enum. * Introduction of a disassembler for testing purposes. As of this change, Winch generates the following code for the following test programs: ```wat (module (export "main" (func $main)) (func $main (result i32) (i32.const 10) (i32.const 20) i32.add )) ``` ```asm 0: 55 push rbp 1: 48 89 e5 mov rbp, rsp 4: b8 0a 00 00 00 mov eax, 0xa 9: 83 c0 14 add eax, 0x14 c: 5d pop rbp d: c3 ret ``` ```wat (module (export "main" (func $main)) (func $main (result i32) (local $foo i32) (local $bar i32) (i32.const 10) (local.set $foo) (i32.const 20) (local.set $bar) (local.get $foo) (local.get $bar) i32.add )) ``` ```asm 0: 55 push rbp 1: 48 89 e5 mov rbp, rsp 4: 48 83 ec 08 sub rsp, 8 8: 48 c7 04 24 00 00 00 00 mov qword ptr [rsp], 0 10: b8 0a 00 00 00 mov eax, 0xa 15: 89 44 24 04 mov dword ptr [rsp + 4], eax 19: b8 14 00 00 00 mov eax, 0x14 1e: 89 04 24 mov dword ptr [rsp], eax 21: 8b 04 24 mov eax, dword ptr [rsp] 24: 8b 4c 24 04 mov ecx, dword ptr [rsp + 4] 28: 01 c1 add ecx, eax 2a: 48 89 c8 mov rax, rcx 2d: 48 83 c4 08 add rsp, 8 31: 5d pop rbp 32: c3 ret ``` ```wat (module (export "main" (func $main)) (func $main (param i32) (param i32) (result i32) (local.get 0) (local.get 1) i32.add )) ``` ```asm 0: 55 push rbp 1: 48 89 e5 mov rbp, rsp 4: 48 83 ec 08 sub rsp, 8 8: 89 7c 24 04 mov dword ptr [rsp + 4], edi c: 89 34 24 mov dword ptr [rsp], esi f: 8b 04 24 mov eax, dword ptr [rsp] 12: 8b 4c 24 04 mov ecx, dword ptr [rsp + 4] 16: 01 c1 add ecx, eax 18: 48 89 c8 mov rax, rcx 1b: 48 83 c4 08 add rsp, 8 1f: 5d pop rbp 20: c3 ret ``` List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs

3861f667 - Update some wasm-tools crates (#5422)

Tue, 13 Dec 2022 00:34:29 +0000

Update some wasm-tools crates (#5422)Notably this pulls in https://github.com/bytecodealliance/wasm-tools/pull/862 which should fix some fuzz bugs on oss-fuzz. List of files: /wasmtime-44.0.1/winch/codegen/src/frame/mod.rs