Changes in instructions.rs

58633f35 - Fix doc typo, the behavior is actually selecting 'x' if the bit in 'c' is 1 (#12695)

Mon, 02 Mar 2026 21:21:27 +0000

Fix doc typo, the behavior is actually selecting 'x' if the bit in 'c' is 1 (#12695) List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

7ac4b818 - S390x: emit new instructions added in z17 (#12319)

Tue, 03 Feb 2026 18:51:07 +0000

S390x: emit new instructions added in z17 (#12319)* s390x: Emit instructions from MIE4 & VXRS_EXT3 on z17This emits & tests a bunch of instructions: * from Miscellaneous-Instruction-Extensions Facility 4: * CLZ, 64bit * CTZ, 64bit * from Vector-Enhancements Facility 3: * 32x4, 64x2 & 128x1 variants of the following: * Divide * Remainder * 64x2 & 128x1 multiply variants * 128x1 vaiants of: * Compare * CLZ * CTZ * Max * Min * Average * Negation * EvaluateCo-authored-by: Jimmy Brisson * s390x: Emit vector blend on z17* Rename x86_blendv to blendvNow that s390x implements blendv as well, we should refer tothe instruction without the x86 prefix.---------Co-authored-by: Ulrich Weigand List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

87ed3b60 - Cranelift: make all non-tail, non-indirect calls patchable, and rename patchable ABI to `preserve_all`. (#12160)

Mon, 15 Dec 2025 23:29:06 +0000

Cranelift: make all non-tail, non-indirect calls patchable, and rename patchable ABI to `preserve_all`. (#12160)* Cranelift: make all non-tail, non-indirect calls patchable, and rename patchable ABI to `preserve_all`.As discussed in this week's Cranelift meeting, we've discovered a needto generalize the `patchable_call` mechanism and corresponding`patchable` ABI slightly. In particular, we will need patchable`try_call` callsites as well in order to allow breakpoint handlers tothrow exceptions (desirable functionality eventually) and have this workin the presence of inlining. Also, it's just a nice generalization tosay that patchability is an orthogonal dimension to the call ABI and theother restrictions we initially imposed, and works as long as the basicrequirement (no return values) is met.This also renames the `patchable` ABI to `preserve_all`, to make itclear that its purpose is actually orthogonal, and it can be usedindependently of patchable callsites. It also deletes the `cold` ABI,which never actually did anything and is misleading in the presence ofan actual cold-ish (subzero temperature, actually) ABI like`preserve_all`.* Review feedback. List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

c00e9ea2 - Cranelift: add patchable call instructions. (#12101)

Tue, 02 Dec 2025 00:59:15 +0000

Cranelift: add patchable call instructions. (#12101)* Cranelift: add patchable call instructions.The new `patchable_call` CLIF instruction pairs with the `patchable`ABI, and emits a callsite with one new key property: the MachBuffercarries metadata that describes exactly which byte range to "NOP out"(overwrite with NOP instructions) to disable that callsite. Doing so issemantically valid and explicitly supported.This enables patching of code at runtime to dynamically turn on and offfeatures such as instrumentation or debugging hooks. We plan to use thisto implement breakpoints in Wasmtime's guest debugging support.As part of this change, I added a notion of "unit of NOP bytes" to theMachBuffer so that the consumer (e.g., Wasmtime's Cranelift-based codecompilation pipeline and metadata-producing logic) can handle patchablecallsites without any other special knowledge of the ISA.For the "real metal" ISAs there are perfectly well-defined NOPs to use,but for Pulley, where all opcodes are assigned at compile time by macromagic, I explicitly defined NOP as opcode byte 0 by moving `Nop`'sdefinition to the top of the list and adding a unit test asserting itsencoding.A design note: in principle it would be possible, as an alternative, totreat "patchability" as an orthogonal dimension of all callsites, andemit the metadata describing the instruction-offset range for anycallsite with the flag set. The only truly necessary semanticrestriction is that there are no return values (because if we turn thecallsite off, nothing writes to them); we could support patchability forother ABIs and for the other kinds of call instructions. The `patchable`ABI would then be better described as something like the "no clobbersABI". I opted not to generalize in this way because it creates someless-tested corners and the generalized form, at least at the MachInstlevel, is not really much simpler in the end.A testing note: I opted not to implement actual code patching in the`cranelift-tools` filetest runner and test patching callsites in/out viasome actuation (e.g. a magic hostcall, like we do for throws) because(i) that's a lot of new plumbing and (ii) we are going to test this veryshortly in Wasmtime anyway and (iii) the correctness (or not) of thelocation-and-length metadata is easy enough to verify in thedisassemblies in the compile-tests.* Review feedback: remove dependence on (and test for) NOP being the literal byte 0. List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

a3d6e407 - Cranelift: add debug tag infrastructure. (#11768)

Mon, 06 Oct 2025 19:38:03 +0000

Cranelift: add debug tag infrastructure. (#11768)* Cranelift: add debug tag infrastructure.This PR adds *debug tags*, a kind of metadata that can attach to CLIFinstructions and be lowered to VCode instructions and as metadata onthe produced compiled code. It also adds opaque descriptor blobscarried with stackslots. Together, these two features allow decoratingIR with first-class debug instrumentation that is properly preservedby the compiler, including across optimizations andinlining. (Wasmtime's use of these features will come in followupPRs.)The key idea of a "debug tag" is to allow the Cranelift embedder toexpress whatever information it needs to, in a format that is opaqueto Cranelift itself, except for the parts that need translation duringlowering. In particular, the `DebugTag::StackSlot` variant getstranslated to a physical offset into the stackframe in the compiledmetadata output. So, for example, the embedder can emit a tagreferring to a stackslot, and another describing an offset in thatstackslot.The debug tags exist as a *sequence* on any given instruction; themeaning of the sequence is known only to the embedder, *except* thatduring inlining, the tags for the inlining call instruction areprepended to the tags of inlined instructions. In this way, acanonical use-case of tags as describing original source-languageframes can preserve the source-language view even when multiplefunctions are inlined into one.The descriptor on a stackslot may look a little odd at first, but itspurpose is to allow serializing some description ofstackslot-contained runtime user-program data, in a way that is firmlyattached to the stackslot. In particular, in the face of inlining,this descriptor is copied into the inlining (parent) function from theinlined function when the stackslot entity is copied; no othermetadata outside Cranelift needs to track the identity of stackslotsand know about that motion. This fits nicely with the ability of tagsto refer to stackslots; together, the embedder can annotateinstructions as having certain state in stackslots, and describe theformat of that state per stackslot.This infrastructure is tested with some compile-tests now;testing of the interpretation of the metadata output will come withend-to-end debug instrumentation tests in a followup PR.* Review feedback: add back sequence points and enforce tags only on sequence points or calls.* Use Vecs for debug metadata in MachBuffer to avoid SmallVec size penalty in not-used case.* Review feedback: switch from inlined stackslot descriptor blobs to u64 keys. List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

4c01ee2f - Cranelift: add get_exception_handler_address. (#11629)

Fri, 05 Sep 2025 22:41:46 +0000

Cranelift: add get_exception_handler_address. (#11629)* Cranelift: add get_exception_handler_address.This is designed to enable applications such as #11592 that usealternative unwinding mechanisms that may not necessarily want to walk astack and look up exception tables. The idea is that whenever it wouldbe valid to resume to an exception handler that is active on the stack,we can provide the same PC as a first-class runtime value that would befound in the exception table for the given handler edge. A "custom"resume step can then use this PC as a resume-point as long as it followsthe relevant exception ABI (i.e.: restore SP, FP, any other savedregisters that the exception ABI specifies, and provide appropriatepayload value(s)).Handlers are associated with edges out of `try_call`s (or`try_call_indirect`s); and edges specifically, not blocks, because therecould be multiple out-edges to one block. The instruction thus takes theblock that contains the try-call and an immediate that indexes itsexceptional edges.This CLIF instruction required a bit of infrastructure to (i) allownaming raw blocks, not just block calls, as instruction arguments, and(ii) allow getting the MachLabel for any other lowered block duringlowering. But given that, the lowerings themselves are straightforwarduses of MachBuffer labels to fix-up PC-relative address-loadinginstructions (e.g., `LEA` or `ADR` or `AUIPC`+`ADDI`).* Review feedback.* Review feedback: more tests. List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

8a23cc74 - Cranelift: Make `ir::{Constant,Immediate}` considered entities (#11207)

Wed, 09 Jul 2025 19:24:48 +0000

Cranelift: Make `ir::{Constant,Immediate}` considered entities (#11207)* Cranelift: Make `ir::{Constant,Immediate}` considered entitiesThey reference data in out-of-line pools rather than storing their data inlinein the instruction, and when an instruction containing them is moved from one`ir::Function` to another, they need their indices updatedaccordingly. Therefore, they really are entities rather than immediates.This recategorization means that they will now be properly mapped in`ir::InstructionData::map` calls.* fix tests List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.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/cranelift/codegen/meta/src/shared/instructions.rs

94ec88ea - Cranelift: initial try_call / try_call_indirect (exception) support. (#10510)

Tue, 08 Apr 2025 00:02:16 +0000

Cranelift: initial try_call / try_call_indirect (exception) support. (#10510)* Cranelift: initial try_call / try_call_indirect (exception) support.This PR adds `try_call` and `try_call_indirect` instructions, andlowerings on four of five ISAs (x86-64, aarch64, riscv64, pulley; s390xhas its own non-shared ABI code that will need separate work).It extends CLIF to support these instructions as new kinds of branches,and extends block-calls to accept `retN` and `exnN` block-call args thatcarry the normal return values or exception payloads (respectively) intothe appropriate successor blocks.It wires up the "normal return path" so that it continues to work.It updates the ABI so that unwinding is possible without an initialregister state at throw: specifically, as per our RFC, all registers areclobbered. It also includes metadata in the `MachBuffer` that describesexception-catch destinations. However, no unwinder exists to interpretthese catch-destinations yet, so they are untested.* Add try_call_indirect lowering as well. List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

a88eb702 - Cranelift: dedupe `trap[n]z` instructions (#10004)

Tue, 14 Jan 2025 18:28:51 +0000

Cranelift: dedupe `trap[n]z` instructions (#10004)* Cranelift: dedupe `trap[n]z` instructionsThis commit extends our existing support for merging idempotently side-effectfulinstructions that produce exactly one value to those that produce zero or onevalue, and marks the `trap[n]z` instructions as having idempotent sideeffects. This cleans up a lot test cases in our `disas` test suite, particularlythose related to explicit bounds checks and GC.As an aside, it seems like it should be easy to extend this to idempotentlyside-effectful instructions that produce multiple values as well, but I don'tbelieve we have any such instructions, so I didn't bother.* Update more disas tests* review feedback List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

2d1c0abd - pulley: Implement vector sqmul_round_sat (#9911)

Sun, 29 Dec 2024 20:02:52 +0000

pulley: Implement vector sqmul_round_sat (#9911)* pulley: Implement vector sqmul_round_sat* parenthesize to bring out op. order List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

45b60bd6 - Start using `#[expect]` instead of `#[allow]` (#9696)

Mon, 02 Dec 2024 17:19:20 +0000

Start using `#[expect]` instead of `#[allow]` (#9696)* Start using `#[expect]` instead of `#[allow]`In Rust 1.81, our new MSRV, a new feature was added to Rust to use`#[expect]` to control lint levels. This new lint annotation willsilence a lint but will itself cause a lint if it doesn't actuallysilence anything. This is quite useful to ensure that annotations don'tget stale over time.Another feature is the ability to use a `reason` directive on theattribute with a string explaining why the attribute is there. Thisstring is then rendered in compiler messages if a warning or errorhappens.This commit migrates applies a few changes across the workspace:* Some `#[allow]` are changed to `#[expect]` with a `reason`.* Some `#[allow]` have a `reason` added if the lint conditionally fires (mostly related to macros).* Some `#[allow]` are removed since the lint doesn't actually fire.* The workspace configures `clippy::allow_attributes_without_reason = 'warn'` as a "ratchet" to prevent future regressions.* Many crates are annotated to allow `allow_attributes_without_reason` during this transitionary period.The end-state is that all crates should use`#[expect(..., reason = "...")]` for any lint that unconditionally firesbut is expected. The `#[allow(..., reason = "...")]` lint should be usedfor conditionally firing lints, primarily in macro-related code.The `allow_attributes_without_reason = 'warn'` level is intended to bepermanent but the transitionary`#[expect(clippy::allow_attributes_without_reason)]` crate annotationsto go away over time.* Fix adapter buildprtest:full* Fix one-core build of icache coherence* Use `allow` for missing_docsWork around rust-lang/rust#130021 which was fixed in Rust 1.83 and isn'tfixed for our MSRV at this time.* More MSRV compat List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

3036e795 - Add I128 atomic support to the `x64` backend (#9459)

Mon, 14 Oct 2024 21:33:08 +0000

Add I128 atomic support to the `x64` backend (#9459)* Add I128 atomic support to the `x64` backend* fix typo in cranelift/codegen/src/isa/x64/inst/emit.rs---------Co-authored-by: Nick Fitzgerald List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

ff987608 - Remove `iadd_cin` and `isub_bin`, split `isub_borrow` and `iadd_carry` (#9199)

Fri, 06 Sep 2024 19:29:46 +0000

Remove `iadd_cin` and `isub_bin`, split `isub_borrow` and `iadd_carry` (#9199)* Remove `iadd_cin` and `isub_bin`, split `isub_borrow` and `iadd_carry`This commit refactors the opcodes the Cranelift supports foradd-with-carry and subtract-with-borrow. None of these opcodes arecurrently in use by the wasm frontend nor supported by any backend. Inthat sense it's unlikely they have many users and the hope is thatrefactoring won't cause much impact.The `iadd_cin` and `isub_bin` opcodes are the equivalent of `*_borrow`and `*_carry` except that they don't return the carry flag, they onlyreturn the result of the operation. While theoretically useful I'veelected to remove them here in favor of only the borrow-returningoperations. They can be added back in in the future though if necessary.I've split the preexisting operations `isub_borrow` and `iadd_carry`additionally into signed/unsigned portions:* `isub_borrow` => `usub_borrow` and `ssub_borrow`* `iadd_carry` => `uadd_carry` and `sadd_carry`This reflects how the condition needs to differ on the carry flagcomputation for signed/unsigned inputs. I've additionally fixed theinterpreter's implementation of `IsubBorrow` when switching to thesigned/unsigned opcodes.Finally the documentation for these instructions now explicitly say thatthe incoming carry/borrow is zero-or-nonzero even though it's typed as`i8`. Additionally the tests have been refactored to make use ofmulti-return which may not have existed when they were first written.* Rename instructions* Fix more renames* Update instruction descriptions List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

b81ef46c - Remove reference types (`r32` and `r64`) from Cranelift (#9164)

Thu, 22 Aug 2024 21:39:26 +0000

Remove reference types (`r32` and `r64`) from Cranelift (#9164)* Remove reference types (`r32` and `r64`) from Cranelift* restore fuzz regression test List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

dbc11c30 - Cranelift: add stack_switch CLIF instruction (#9078)

Wed, 21 Aug 2024 21:37:05 +0000

Cranelift: add stack_switch CLIF instruction (#9078)* stack_switch instruction* Update cranelift/codegen/src/isa/x64/pcc.rsCo-authored-by: Nick Fitzgerald * cargo fmt* only lower on linux* give stack_switch the call() side effect* add function in filetest doing switching only* Extend documentation of new instruction* better comments on how we handle the payloads* Revert "only lower on linux"This reverts commit 2af10f944186629de1615aa0ed999b7f49d13132.* Add StackSwitchModel, use to compile stack_switch* turn stack_switch_model into partial constructor---------Co-authored-by: Nick Fitzgerald List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

41eca60b - cranelift: Add `f16const` and `f128const` instructions (#8893)

Wed, 17 Jul 2024 16:39:47 +0000

cranelift: Add `f16const` and `f128const` instructions (#8893)* cranelift: Add `f16const` and `f128const` instructions* cranelift: Add constant propagation for `f16` and `f128` List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

9ffc9e67 - Cranelift: Remove resumable traps (#8809)

Fri, 14 Jun 2024 19:26:11 +0000

Cranelift: Remove resumable traps (#8809)These were originally a SpiderMonkey-ism and have been unused eversince. It was introduced for GC integration, where the runtime could dosomething to make Cranelift code hit a trap and pause for a GC and then resumeexecution once GC completed. But it is unclear that, as implemented, this isactually a useful mechanism for doing that (compared to, say, loading from someWell Known page and the GC protecting that page and catching signals tointerrupt the mutator, or simply branching and doing a libcall). And if someonehas that particular use case in the future (Wasmtime and its GC integrationdoesn't need exactly this) then we can design something for what is actuallyneeded at that time, instead of carrying this cruft forward forever. List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

f59b3246 - cranelift: Optimize select_spectre_guard, carefully (#8139)

Wed, 20 Mar 2024 22:31:45 +0000

cranelift: Optimize select_spectre_guard, carefully (#8139)* cranelift: Optimize select_spectre_guard, carefullyThis commit makes two changes to our treatment of`select_spectre_guard`.First, stop annotating this instruction as having any side effects. Weonly care that if its value result is used, then it's computed withoutbranching on the condition input. We don't otherwise care when the valueis computed, or if it's computed at all.Second, introduce some carefully selected ISLE egraph rewrites for thisinstruction. These particular rewrites are those where we can staticallydetermine which SSA value will be the result of the instruction. Sincethere is no actual choice involved, there's no way to accidentallyintroduce speculation on the condition input.* Add filetests List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs

c4478334 - cranelift: Remove support for WebAssembly tables (#8124)

Thu, 14 Mar 2024 15:40:25 +0000

cranelift: Remove support for WebAssembly tables (#8124)Wasmtime no longer needs any of this infrastructure and neither shouldanybody else.This diff is nearly identical to @bjorn3's version of the same change,except I didn't remove Uimm64, which has started being used in otherplaces. I forgot bjorn3 had already tackled this part until after I wasalready done, but it's reassuring that we both made the same changes.https://github.com/bjorn3/wasmtime/commit/fb82ccb3948e949641a6d9581aa84472f68f97b8Fixes #5532 List of files: /wasmtime-44.0.1/cranelift/codegen/meta/src/shared/instructions.rs