Changes in obj.rs

c7cab275 - wasmtime-cranelift: Use `wasmtime_environ::error` instead of `anyhow` (#12204)

Mon, 22 Dec 2025 20:59:10 +0000

wasmtime-cranelift: Use `wasmtime_environ::error` instead of `anyhow` (#12204) List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

17fbd3c6 - Debug: implement breakpoints and single-stepping. (#12133)

Fri, 12 Dec 2025 20:02:54 +0000

Debug: implement breakpoints and single-stepping. (#12133)* Debug: implement breakpoints and single-stepping.This is a PR that puts together a bunch of earlier pieces (patchablecalls in #12061 and #12101, private copies of code in #12051, and allthe prior debug event and instrumentation infrastructure) to implementbreakpoints in the guest debugger.These are implemented in the way we have planned in #11964: eachsequence point (location prior to a Wasm opcode) is now a patchable callinstruction, patched out (replaced with NOPs) by default. When patchedin, the breakpoint callsite calls a trampoline with the `patchable` ABIwhich then invokes the `breakpoint` hostcall. That hostcall emits thedebug event and nothing else.A few of the interesting bits in this PR include:- Implementations of "unpublish" (switch permissions back to read/write from read/execute) for mmap'd code memory on all our platforms.- Infrastructure in the frame-tables (debug info) metadata producer and parser to record "breakpoint patches".- A tweak to the NOP metadata packaged with the `MachBuffer` to allow multiple NOP sizes. This lets us use one 5-byte NOP on x86-64, for example (did you know x86-64 had these?!) rather than five 1-byte NOPs.This PR also implements single-stepping with a global-per-`Store` flag,because at this point why not; it's a small additional bit of logic todo *all* patches in all modules registered in the `Store` when that flagis enabled.A few realizations for future work:- The need for an introspection API available to a debugger to see the modules within a component is starting to become clear; either that, or the "module and PC" location identifier for a breakpoint switches to a "module or component" sum type. Right now, the tests for this feature use only core modules. Extending to components should not actually be hard at all, we just need to build the API for it.- The interaction between inlining and `patchable_call` is interesting: what happens if we inline a `patchable_call` at a `try_call` callsite? Right now, we do *not* update the `patchable_call` to a `try_call`, because there is no `patchable_try_call`; this is fine in the Wasmtime embedding in practice because we never (today!) throw exceptions from a breakpoint handler. This does suggest to me that maybe we should make patchability a property of any callsite, and allow try-calls to be patchable too (with the same restriction about no return values as the only restriction); but happy to discuss that one further.* Add missing debug.wat disas test.* Review feedback.* Fix comment on `CodeMemory::text_mut`.* Review feedback.* Review feedback: abort process on failure to re-apply executable permissions.* Implement icache flush for aarch64.This appears to be necessary as we otherwise see a failure in CI onmacOS/aarch64 that is consistent with patched-in breakpoint calls stillbeing incorrectly cached after we remove them and republish the code.There is a longstanding issue in #3310 tracking proper icache coherencehandling on aarch64. We implemented this for Linux with the `membarrier`syscall but never did so for macOS. Maybe this is the first point atwhich it matters, because code was always loaded at new addresses (hencedid not have coherence issues because nothing would have been cached)previously.prtest:full* Review feedback: use `next_multiple_of`. List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

cfc05638 - Make Wasmtime's `FuncKey` one-to-one with Cranelift's `ir::UserExternalName` (#11415)

Tue, 12 Aug 2025 18:38:04 +0000

Make Wasmtime's `FuncKey` one-to-one with Cranelift's `ir::UserExternalName` (#11415)* Make Wasmtime's `FuncKey` one-to-one with Cranelift's `ir::UserExternalName``FuncKey`, which used to be called `CompileKey`, is now one-to-one with`cranelift_codegen::ir::UserExternalName`, and is used for not just identifyingcompilation objects but also relocations and call-graph edges. This allows us todetermine the `StaticModuleIndex` and `DefinedFuncIndex` pair for any`cranelift_codegen::ir::FuncRef`, regardless of inlining depth, which fixes somefuzz bugs on OSS-Fuzz.This continues pushing on the idea that Wasmtime's compilation orchestration andlinking should be relatively agnostic to the kinds of things it is actuallycompiling and linking, allowing us to tweak, add, and remove new kinds of`FuncKey`s more easily. Adding a new `FuncKey` should not require modifyingrelocation resolution, for example, just a little bit of code to run theassociated compilation and optionally some code to extract metadata into ourfinal artifacts for querying at runtime. Everything in between should JustContinue Working. We still aren't all the way there yet, but this does bring usa little bit closer.Finally, in Cranelift's inlining pass, this adds a check that a block isinserted in the layout before attempting to remove it from the layout, whichwould otherwise cause panics. This was triggered by multi-level inlining andnow-unreachable blocks in the inner callees.I'll note that this does update basically all of the disas tests, or at leastnearly all of them that make function calls. This is because the namespace/indexnumbering pair changed slightly to align with `FuncKey`, but that should prettymuch be the only changes.* remove debug info from panic message, it is only available in some `cfg`s* fill out module doc comment* Fix compilation without `component-model` feature* Fix some more cfg compilations* cargo fmt* fix a wrong `&dyn Any` auto coercion; add helpful debug logging and assertions for this kind of thing List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

def5998e - Remove `cranelift_entity::{Signed, Unsigned}` (#11400)

Thu, 07 Aug 2025 23:44:38 +0000

Remove `cranelift_entity::{Signed, Unsigned}` (#11400)Use `*::cast_{un,}signed` in the Rust standard library stabilized in1.87. List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

90ac295e - Update Wasmtime to the 2024 Rust Edition (#10806)

Mon, 19 May 2025 16:40:55 +0000

Update Wasmtime to the 2024 Rust Edition (#10806)* Update Wasmtime to the 2024 Rust EditionNow that our MSRV supports the 2024 edition it's possible to make thisswitch. This commit moves Wasmtime to the 2024 Edition to keepup-to-date with Rust idioms and access many of the edition featuresexclusive to the 2024 edition.prtest:full* Reformat with the 2024 edition List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

ee275a89 - Switch to using Wasmtime-style builtins for ceil, floor, etc. (#10657)

Thu, 24 Apr 2025 05:06:05 +0000

Switch to using Wasmtime-style builtins for ceil, floor, etc. (#10657)* Switch to using Wasmtime-style builtins for ceil, floor, etc.With this patch, all emitted calls are Wasmtime-style builtins, ratherthan Cranelift-style libcalls. This ensures that all calls fromCranelift-generated code into Wasmtime host code use the same mechanism,and eliminates the relocation handling code for the libcall mechanism.* Update tests.* Avoid using x86_pshufb on non-x86 platforms.* Revert unneeded f32/f64 changes in Pulley.* Define i8x16 as an unconstructible type if sse isn't available.* Delete the setters too.* Fix f32/f64 setters.* Test with prtest:full.prtest:full* Support fma.* Return true for `has_native_fma` on pulley.This works because pulley already has code implementing fma. This avoidsneeding to marshal f32x4 values into builtin function calls on pulley.* Update tests. List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

4e8dc9d0 - Don't pad .text to page size for pulley (#10285)

Wed, 12 Mar 2025 19:06:08 +0000

Don't pad .text to page size for pulley (#10285)* Don't pad .text to page size for pulleyWhen targeting pulley we aren't directly emitting executablecode in the .text section and we don't have a good idea of thetrue target page size so we end up with ELF files that canhave a significant amount of extra padding around the .textsection with no benefit to the consumer.The change here aligns with the already present section flagSH_WASMTIME_NOT_EXECUTED. Padding elimination for the .rodata.wasmsection is already handled by the presence/absence of thememory-init-on-cow configuration.For a basic wasip1 hello-world rust program with the combinationof this patch and `-O memory-init-cow=n` I saw a reduction inthe compiled wasm ELF from 421KB to 189KB with the sections nolonger showing as being padded out significantly:```$ objdump --section-headers target/wasm32-wasip1/release/hello-wasm-world-0x00.cwasmtarget/wasm32-wasip1/release/hello-wasm-world-0x00.cwasm: file format elf64-littleriscvSections:Idx Name Size VMA Type 0 00000000 0000000000000000 1 .wasmtime.engine 00000353 0000000000000000 DATA 2 .wasmtime.bti 00000001 0000000000000000 DATA 3 .text 00011bdc 0000000000000000 4 .wasmtime.addrmap 00011c5c 0000000000000000 DATA 5 .wasmtime.traps 00000ae0 0000000000000000 DATA 6 .rodata.wasm 000019e8 0000000000000000 DATA 7 .name.wasm 000027a6 0000000000000000 DATA 8 .wasmtime.info 000010f9 0000000000000000 DATA 9 .symtab 00001788 0000000000000000 10 .strtab 000040f0 0000000000000000 11 .shstrtab 00000089 0000000000000000```* code_memory: don't unpublish non-published memoryFor the case that we construct a CodeMemory with a custom_code_memoryimplementation but we don't end up publishing memory, do not tryto unpublish the memory.This could happen in a few cases:- The .text didn't require being made executable- There's an error or other circumstances cause the CodeMemory to be dropped prior to publish being called.Within the context of the .text size optimizations for pulley,this caused CI failures for a default pulley target as theerrant unpublish was now being called on non-aligned memory.Prior to the .text optimizations there was still an mprotectbeing called to change bits on the .text region which just happenedto be benign.* In addition to published, check needs_executable before custom unpublishingChanging the placement of published or introducing new state couldbe other ways of addressing the problem of doing a customunpublish but those approaches would potentially create other issueswith avoiding duplicate relocations.Given where this code would be used and the ability for the`custom_code_memory` to provide their own protections, thisseems very much so Good Enough and gets the tests passingagain while providing more reasonable behavior for user code. List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

48f4621f - Run the full test suite on 32-bit platforms (#9837)

Wed, 15 Jan 2025 18:43:18 +0000

Run the full test suite on 32-bit platforms (#9837)* Run the full test suite on 32-bit platformsThis commit switches to running the full test suite in its entirety(`./ci/run-tests.sh`) on 32-bit platforms in CI in addition to 64-bitplatforms. This notably adds i686 and armv7 as architectures that aretested in CI.Lots of little fixes here and there were applied to a number of tests.Many tests just don't run on 32-bit platforms or a platform withoutCranelift support, and they've been annotated as such where necessary.Other tests were adjusted to run on all platforms a few minor bug fixesare here as well.prtest:full* Fix clippy warning* Get wasm code working by default on 32-bitDon't require the `pulley` feature opt-in on 32-bit platforms to getwasm code running.* Fix dead code warning* Fix build on armv7* Fix test assertion on armv7* Review comments* Update how tests are skipped* Change how Pulley is defaultedDefault to pulley in `build.rs` rather than in `Cargo.toml` to make iteasier to write down the condition and comment what's happening. Thismeans that the `pulley-interpreter` crate and pulley support inCranelift is always compiled in now and cannot be removed. This shouldhopefully be ok though as the `pulley-interpreter` crate is stillconditionally used (meaning it can get GC'd) and the code-size ofCranelift is not as important as the runtime itself.* pulley: Save/restore callee-save state on traps* Fewer clippy warnings about casts* Use wrapping_add in `g32_addr`, fixing arm test List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

47a60e83 - fix typo (#9906)

Fri, 27 Dec 2024 17:02:21 +0000

fix typo (#9906)Signed-off-by: Jack Drogon List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

70a37939 - Support executing Pulley in Wasmtime (#9744)

Fri, 06 Dec 2024 20:23:55 +0000

Support executing Pulley in Wasmtime (#9744)* Support executing Pulley in WasmtimeThis commit is the initial implementation of executing the Pulleyinterpreter from the `wasmtime` crate. This gives access to all of the`wasmtime` crate's runtime APIs backed by execution of bytecode inPulley. This builds on the previous PRs I've been making for support inPulley to culminate in testing on CI in this PR. This PR handles somefinal tidbits related to producing a runnable image that can beinterpreted by the `wasmtime` crate such as:* Pulley compilation artifacts are no longer marked as natively executable, just read-only.* Pulley compilation artifacts include wasm-to-array trampolines like normal platforms (removes a pulley special-case).* Dispatch of host calls from Pulley to the Wasmtime runtime are implemented.* Pulley's list of panicking wasm features is slimmed down as most are covered by "this lowering isn't supported" errors.* Execution of wasm code now has an `if` to see whether Pulley is enabled within a `Store` or not.* Traps and basic "unwinding" of the pulley stack are implemented (e.g. a "pulley version" of `setjmp` and `longjmp`, sort of)* Halting the interpreter has been refactored to help shrink the size of `ControlFlow` and handle metadata with each done state.Some minor refactorings are also included here and there along with afew fixes here and there necessary to get tests passing.The next major part of this commit is updates to our `wast` test suiteand executing all `*.wast` files. Pulley is now executed by default forall files as a new execution engine. This means that all platforms in CIwill start executing Pulley tests. At this time almost all tests areflagged as "expected to fail" but there are a small handful ofallow-listed tests which are expected to pass. This exact list willchange over time as CLIF lowerings are implemented and the interpreteris extended.Follow-up PRs will extend the testing strategy further such as:* Extending `#[wasmtime_test]` to include Pulley in addition to Winch.* Getting testing set up on CI for 32-bit platforms.prtest:full* Fix pulley fuzz build* Fix clippy lints* Shuffle around some `#[cfg]`'d code* Remove unused imports* Update feature sets testing MIRIEnable pulley for wasmtime/wasmtime-cli and also enable all features forwasmtime-environ* Round up pulley's page size to 64k* Skip pulley tests on s390x for now* Add a safety rail for matching a pulley target to the host* Fix more pulley tests on s390x* Review comments* Fix fuzz build List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

2f7b0f58 - pulley: Clarify documentation around `CallIndirectHost` (#9746)

Thu, 05 Dec 2024 20:43:08 +0000

pulley: Clarify documentation around `CallIndirectHost` (#9746)Handling review comments from #9665 and fully updating documentation toreflect the mid-pr design shift to the currently-landed state. List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.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/crates/cranelift/src/obj.rs

438fc938 - pulley: Implement interpreter-to-host calls (#9665)

Mon, 25 Nov 2024 23:12:53 +0000

pulley: Implement interpreter-to-host calls (#9665)* pulley: Implement interpreter-to-host callsThis commit is an initial stab at implementing interpreter-to-hostcommunication in Pulley. The basic problem is that Pulley needs theability to call back into Wasmtime to implement tasks such as`memory.grow`, imported functions, etc. For native platforms this is asimple `call_indirect` operation in Cranelift but the story for Pulleymust be different because it's effectively switching from interpretedcode to native code.The initial idea for this in #9651 is replaced here and looks mostlysimilar but with a few changes. The overall structure of how this worksis:* A new `call_indirect_host` opcode is added to Pulley. * Function signatures that can be called from Pulley bytecode are statically enumerated at build-time. * This enables the implementation of `call_indirect_host` to take an immediate of which signature is being used and cast the function pointer to the right type.* A new pulley-specific relocation is added to Cranelift for this opcode. * `RelocDistance::Far` calls to a name trigger the use of `call_indirect_host`. * The relocation is filled in by Wasmtime after compilation where the signature number is inserted. * A new `NS_*` value for user-function namespaces is reserved in `wasmtime-cranelift` for this new namespace of functions.* Code generation for Pulley in `wasmtime-cranelift` now has Pulley-specific handling of the wasm-to-host transition where all previous `call_indirect` instructions are replaced with a call to a "backend intrinsic" which gets lowered to a `call_indirect_host`.Note that most of this still isn't hooked up everywhere in Wasmtime.That means that the testing here is pretty light at this time. It'llrequire a fair bit more work to get everything fully integrated fromWasmtime in Pulley. This is expected to be one of the significantremaining chunks of work and should help unblock future testing (or makethose diffs smaller ideally).* Review comments List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

7be834f6 - Enable some Clippy conversion lints for `wasmtime-cranelift` (#9536)

Fri, 01 Nov 2024 17:20:04 +0000

Enable some Clippy conversion lints for `wasmtime-cranelift` (#9536)Similar to how `wasmtime::runtime` has a few off-by-default lints turnedon for it do the same for the compilation phase of `wasmtime-cranelift`.This is intended to help weed out lossy `as` casts and instead steerusers to `from` or `try_from` conversions. List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

4e50ecc6 - Implement unwind support for ARM64 Windows (#9266)

Thu, 19 Sep 2024 16:39:14 +0000

Implement unwind support for ARM64 Windows (#9266) List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.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/crates/cranelift/src/obj.rs

1fa722e3 - Bad relocation type generated (#8255) (#8264)

Fri, 29 Mar 2024 14:34:31 +0000

Bad relocation type generated (#8255) (#8264)* Bad relocation type generatedWhen disabling sse on x86_64 architecture machines and generating floatlibcall, incorrect relocation type R_X86_64_8 may be obtained, with thecorrect type being R_X86_64_64. List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs

70b076d3 - Migrate all Winch filetests to `tests/disas` (#8243)

Wed, 27 Mar 2024 14:44:46 +0000

Migrate all Winch filetests to `tests/disas` (#8243)* Switch Winch tests to ATT syntax* Update all test expectations* Move all winch tests to `disas` folder* Add `test = "winch"` to `disas`* Add `test = "winch"` to all winch test files* Stub out bits to get AArch64 Winch tests working* Update expectations for all aarch64 winch tests* Update flags in Winch testsUse CLI syntax as that's what `flags` was repurposes as in the new testsuite.* Update all test expectations for x64 winch* Omit more offsets by default* Delete now-dead code* Update an error message* Update non-winch test expectations List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.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/crates/cranelift/src/obj.rs

b545cc50 - Remove the wasmtime-cranelift-shared crate (#8222)

Fri, 22 Mar 2024 19:29:38 +0000

Remove the wasmtime-cranelift-shared crate (#8222)The wasmtime-cranelift-shared crate is not as useful as it once was, asit's no longer possible to build wasmtime with only winch; winch usesthe trampolines generated by cranelift now. List of files: /wasmtime-44.0.1/crates/cranelift/src/obj.rs