Changes in lib.rs

557cc2d6 - Another batch of dependency updates (#11832)

Fri, 10 Oct 2025 17:12:23 +0000

Another batch of dependency updates (#11832)* Another batch of dependency updatesBringing some deps in `Cargo.toml` up-to-date with their latest versionsalong the same lines as #11820 to avoid deps getting too stale/old.Code-wise this updates `anyhow` which enables preexisting Clippywarnings to check more code, so those warnings are fixed here as well.prtest:full* Run rustfmt List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

968952ab - Cranelift: introduce a function inliner (#11210)

Thu, 10 Jul 2025 18:32:30 +0000

Cranelift: introduce a function inliner (#11210)* Cranelift: introduce a function inlinerThis comit adds "inlining as a library" to Cranelift; it does _not_ provide acomplete, off-the-shelf inlining solution. Cranelift's compilation context isper-function and does not encompass the full call graph. It does not know whichfunctions are hot and which are cold, which have been marked the equivalent of`#[inline(always)]` versus `#[inline(never)]`, etc... Only the Cranelift usercan understand these aspects of the full compilation pipeline, and these thingscan be very different between (say) Wasmtime and `cg_clif`. Therefore, thisinfrastructure does not attempt to define hueristics for when inlining aparticular call is likely beneficial. This module only provides hooks for theCranelift user to tell Cranelift whether a given call should be inlined or not,and the mechanics to inline a callee into a particular call site when the userdirects Cranelift to do so.This commit also creates a new kind of filetest that will always inline calls tofunctions that have already been defined in the file. This lets us exercise theinliner in filetests.Fixes https://github.com/bytecodealliance/wasmtime/issues/4127* Address review feedback* Require callee bodies are pre-legalized List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

71cb94be - Burn down the `allow_attributes_without_reason` backlog (#9712)

Tue, 03 Dec 2024 16:57:45 +0000

Burn down the `allow_attributes_without_reason` backlog (#9712)* Burn down the `allow_attributes_without_reason` backlogJust a bit, not everything fixed.* Fix wasi-nn annotations* Tweak `#[cfg]` List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.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/filetests/src/lib.rs

b869b66b - cranelift: Delete redundant DCE optimization pass (#8227)

Mon, 13 May 2024 16:12:48 +0000

cranelift: Delete redundant DCE optimization pass (#8227)The egraph pass and the dead-code elimination pass both removeinstructions whose results are unused. If the optimization level is"none", neither pass runs, and if it's anything else both passes run. Idon't think we should do this work twice.Note that the DCE pass is different than the "eliminate unreachablecode" pass, which removes entire blocks that are unreachable from theentry block. That pass might still be necessary. List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

17146ab2 - Remove some more cranelift-filetest wasm testing bits (#8143)

Fri, 15 Mar 2024 16:51:17 +0000

Remove some more cranelift-filetest wasm testing bits (#8143)* Delete now-dead code from the wasm runner in cranelift-filetestNo longer needed with tests having moved out to `tests/disas`* Move wasm<->clif testing to `tests/disas.rs`No need for `test_wasm.rs` to stick around in cranelift-filetest, somove the bits up a layer.* Remove wasm crate dependencies* Change bless env var name* Force link to `libm` List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

b2c28bab - Add a `disas` test suite for Wasmtime (#8129)

Thu, 14 Mar 2024 20:11:24 +0000

Add a `disas` test suite for Wasmtime (#8129)* Add an `asm` test suite for WasmtimeThis commit adds a suite of tests at `tests/asm/*.wat` which is intendedto replace the tests in `cranelift/filetests/filetests/wasm`. Tests areconfigured differently than before using Wasmtime CLI flags rather thana custom TOML-based configuration scheme. Otherwise though the sameshape of tests is supported.This commit migrates a small handful of tests as a showcase and bulkmigration is left for a follow-up.* Organize the asm.rs test with methods/functions* Switch back to TOML for config parsing* Disable disassembly tests on miriTakes a bit too long in cranelift List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

5856590f - Configure workspace lints, enable running some Clippy lints on CI (#7561)

Mon, 20 Nov 2023 23:23:41 +0000

Configure workspace lints, enable running some Clippy lints on CI (#7561)* Configure Rust lints at the workspace levelThis commit adds necessary configuration knobs to have lints configuredat the workspace level in Wasmtime rather than the crate level. Thisuses a feature of Cargo first released with 1.74.0 (last week) of the`[workspace.lints]` table. This should help create a more consistent setof lints applied across all crates in our workspace in addition topossibly running select clippy lints on CI as well.* Move `unused_extern_crates` to the workspace levelThis commit configures a `deny` lint level for the`unused_extern_crates` lint to the workspace level rather than theprevious configuration at the individual crate level.* Move `trivial_numeric_casts` to workspace level* Change workspace lint levels to `warn`CI will ensure that these don't get checked into the codebase andotherwise provide fewer speed bumps for in-process development.* Move `unstable_features` lint to workspace level* Move `unused_import_braces` lint to workspace level* Start running Clippy on CIThis commit configures our CI to run `cargo clippy --workspace` for allmerged PRs. Historically this hasn't been all the feasible due to theamount of configuration required to control the number of warnings onCI, but with Cargo's new `[lint]` table it's possible to have aone-liner to silence all lints from Clippy by default. This commit bydefault sets the `all` lint in Clippy to `allow` to by-default disablewarnings from Clippy. The goal of this PR is to enable selective accessto Clippy lints for Wasmtime on CI.* Selectively enable `clippy::cast_sign_loss`This would have fixed #7558 so try to head off future issues with thatby warning against this situation in a few crates. This lint is stillquite noisy though for Cranelift for example so it's not worthwhile atthis time to enable it for the whole workspace.* Fix CI errorprtest:full List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

62fdafa1 - Remove clippy configuration from repo and crates (#6927)

Tue, 29 Aug 2023 21:07:27 +0000

Remove clippy configuration from repo and crates (#6927)Wasmtime's CI does not run clippy so there's no enforcement of thisconfiguration. Additionally the configuration per-crate is not uniformlyapplied across all of the Wasmtime workspace and is only on somehistorical crates. Because we don't run clippy in CI this commit removesall of the clippy annotations for allow/warn/deny from the source. List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

230e2135 - Cranelift: remove non-egraphs optimization pipeline and `use_egraphs` option. (#6167)

Thu, 06 Apr 2023 18:11:03 +0000

Cranelift: remove non-egraphs optimization pipeline and `use_egraphs` option. (#6167)* Cranelift: remove non-egraphs optimization pipeline and `use_egraphs` option.This PR removes the LICM, GVN, and preopt passes, and associated supportpieces, from `cranelift-codegen`. Not to worry, we still haveoptimizations: the egraph framework subsumes all of these, and has beenon by default since #5181.A few decision points:- Filetests for the legacy LICM, GVN and simple_preopt were removed too. As we built optimizations in the egraph framework we wrote new tests for the equivalent functionality, and many of the old tests were testing specific behaviors in the old implementations that may not be relevant anymore. However if folks prefer I could take a different approach here and try to port over all of the tests.- The corresponding filetest modes (commands) were deleted too. The `test alias_analysis` mode remains, but no longer invokes a separate GVN first (since there is no separate GVN that will not also do alias analysis) so the tests were tweaked slightly to work with that. The egrpah testsuite also covers alias analysis.- The `divconst_magic_numbers` module is removed since it's unused without `simple_preopt`, though this is the one remaining optimization we still need to build in the egraphs framework, pending #5908. The magic numbers will live forever in git history so removing this in the meantime is not a major issue IMHO.- The `use_egraphs` setting itself was removed at both the Cranelift and Wasmtime levels. It has been marked deprecated for a few releases now (Wasmtime 6.0, 7.0, upcoming 8.0, and corresponding Cranelift versions) so I think this is probably OK. As an alternative if anyone feels strongly, we could leave the setting and make it a no-op.* Update test outputs for remaining test differences. List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

108f7917 - Support plugging external profilers into the Cranelift timing infrastructure (#5749)

Fri, 10 Mar 2023 19:33:56 +0000

Support plugging external profilers into the Cranelift timing infrastructure (#5749)* Remove no-std code for cranelift_codegen::timingsno-std mode isn't supported by Cranelift anymore* Simplify define_passes macro* Add egraph opt timings* Replace the add_to_current api with PassTimes::add* Omit a couple of unused time measurements* Reduce divergence between run and run_passes a bit* Introduce a Profiler traitThis allows plugging in external profilers into the Cranelift profilingframework.* Add Pass::description method* Remove duplicate usage of the compile pass timing* Rustfmt List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

91580155 - Delete old cranelift-preopt crate (#5642)

Thu, 26 Jan 2023 21:32:33 +0000

Delete old cranelift-preopt crate (#5642)Most of these optimizations are in the egraph `cprop.isle` rules now, making a separate crate unnecessary. Also I think the `udiv` optimizations here are straight-up wrong (doing signed instead of unsigned division, and panicking instead of preserving traps on division by zero) so I'm guessing this crate isn't seriously used anywhere. At the least, bjorn3 confirms that cg_clif doesn't use this, and I've verified that Wasmtime doesn't either. Closes #1090. List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

c0b587ac - Remove heaps from core Cranelift, push them into `cranelift-wasm` (#5386)

Thu, 15 Dec 2022 00:26:45 +0000

Remove heaps from core Cranelift, push them into `cranelift-wasm` (#5386)* cranelift-wasm: translate Wasm loads into lower-level CLIF operations Rather than using `heap_{load,store,addr}`. * cranelift: Remove the `heap_{addr,load,store}` instructions These are now legalized in the `cranelift-wasm` frontend. * cranelift: Remove the `ir::Heap` entity from CLIF * Port basic memory operation tests to .wat filetests * Remove test for verifying CLIF heaps * Remove `heap_addr` from replace_branching_instructions_and_cfg_predecessors.clif test * Remove `heap_addr` from readonly.clif test * Remove `heap_addr` from `table_addr.clif` test * Remove `heap_addr` from the simd-fvpromote_low.clif test * Remove `heap_addr` from simd-fvdemote.clif test * Remove `heap_addr` from the load-op-store.clif test * Remove the CLIF heap runtest * Remove `heap_addr` from the global_value.clif test * Remove `heap_addr` from fpromote.clif runtests * Remove `heap_addr` from fdemote.clif runtests * Remove `heap_addr` from memory.clif parser test * Remove `heap_addr` from reject_load_readonly.clif test * Remove `heap_addr` from reject_load_notrap.clif test * Remove `heap_addr` from load_readonly_notrap.clif test * Remove `static-heap-without-guard-pages.clif` test Will be subsumed when we port `make-heap-load-store-tests.sh` to generating `.wat` tests. * Remove `static-heap-with-guard-pages.clif` test Will be subsumed when we port `make-heap-load-store-tests.sh` over to `.wat` tests. * Remove more heap tests These will be subsumed by porting `make-heap-load-store-tests.sh` over to `.wat` tests. * Remove `heap_addr` from `simple-alias.clif` test * Remove `heap_addr` from partial-redundancy.clif test * Remove `heap_addr` from multiple-blocks.clif test * Remove `heap_addr` from fence.clif test * Remove `heap_addr` from extends.clif test * Remove runtests that rely on heaps Heaps are not a thing in CLIF or the interpreter anymore * Add generated load/store `.wat` tests * Enable memory-related wasm features in `.wat` tests * Remove CLIF heap from fcmp-mem-bug.clif test * Add a mode for compiling `.wat` all the way to assembly in filetests * Also generate WAT to assembly tests in `make-load-store-tests.sh` * cargo fmt * Reinstate `f{de,pro}mote.clif` tests without the heap bits * Remove undefined doc link * Remove outdated SVG and dot file from docs * Add docs about `None` returns for base address computation helpers * Factor out `env.heap_access_spectre_mitigation()` to a local * Expand docs for `FuncEnvironment::heaps` trait method * Restore f{de,pro}mote+load clif runtests with stack memory List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

f2e1eaa8 - cranelift-filetest: Add support for Wasm-to-CLIF translation filetests (#5412)

Mon, 12 Dec 2022 19:31:29 +0000

cranelift-filetest: Add support for Wasm-to-CLIF translation filetests (#5412)This adds support for `.wat` tests in `cranelift-filetest`. The test runner translates the WAT to Wasm and then uses `cranelift-wasm` to translate the Wasm to CLIF. These tests are always precise output tests. The test expectations can be updated by running tests with the `CRANELIFT_TEST_BLESS=1` environment variable set, similar to our compile precise output tests. The test's expected output is contained in the last comment in the test file. The tests allow for configuring the kinds of heaps used to implement Wasm linear memory via TOML in a `;;!` comment at the start of the test. To get ISA and Cranelift flags parsing available in the filetests crate, I had to move the `parse_sets_and_triple` helper from the `cranelift-tools` binary crate to the `cranelift-reader` crate, where I think it logically fits. Additionally, I had to make some more bits of `cranelift-wasm`'s dummy environment `pub` so that I could properly wrap and compose it with the environment used for the `.wat` tests. I don't think this is a big deal, but if we eventually want to clean this stuff up, we can probably remove the dummy environments completely, remove `translate_module`, and fold them into these new test environments and test runner (since Wasmtime isn't using those things anyways). List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

2be12a51 - egraph-based midend: draw the rest of the owl (productionized). (#4953)

Wed, 12 Oct 2022 01:15:53 +0000

egraph-based midend: draw the rest of the owl (productionized). (#4953)* egraph-based midend: draw the rest of the owl. * Rename `egg` submodule of cranelift-codegen to `egraph`. * Apply some feedback from @jsharp during code walkthrough. * Remove recursion from find_best_node by doing a single pass. Rather than recursively computing the lowest-cost node for a given eclass and memoizing the answer at each eclass node, we can do a single forward pass; because every eclass node refers only to earlier nodes, this is sufficient. The behavior may slightly differ from the earlier behavior because we cannot short-circuit costs to zero once a node is elaborated; but in practice this should not matter. * Make elaboration non-recursive. Use an explicit stack instead (with `ElabStackEntry` entries, alongside a result stack). * Make elaboration traversal of the domtree non-recursive/stack-safe. * Work analysis logic in Cranelift-side egraph glue into a general analysis framework in cranelift-egraph. * Apply static recursion limit to rule application. * Fix aarch64 wrt dynamic-vector support -- broken rebase. * Topo-sort cranelift-egraph before cranelift-codegen in publish script, like the comment instructs me to! * Fix multi-result call testcase. * Include `cranelift-egraph` in `PUBLISHED_CRATES`. * Fix atomic_rmw: not really a load. * Remove now-unnecessary PartialOrd/Ord derivations. * Address some code-review comments. * Review feedback. * Review feedback. * No overlap in mid-end rules, because we are defining a multi-constructor. * rustfmt * Review feedback. * Review feedback. * Review feedback. * Review feedback. * Remove redundant `mut`. * Add comment noting what rules can do. * Review feedback. * Clarify comment wording. * Update `has_memory_fence_semantics`. * Apply @jameysharp's improved loop-level computation. Co-authored-by: Jamey Sharp * Fix suggestion commit. * Fix off-by-one in new loop-nest analysis. * Review feedback. * Review feedback. * Review feedback. * Use `Default`, not `std::default::Default`, as per @fitzgen Co-authored-by: Nick Fitzgerald * Apply @fitzgen's comment elaboration to a doc-comment. Co-authored-by: Nick Fitzgerald * Add stat for hitting the rewrite-depth limit. * Some code motion in split prelude to make the diff a little clearer wrt `main`. * Take @jameysharp's suggested `try_into()` usage for blockparam indices. Co-authored-by: Jamey Sharp * Take @jameysharp's suggestion to avoid double-match on load op. Co-authored-by: Jamey Sharp * Fix suggestion (add import). * Review feedback. * Fix stack_load handling. * Remove redundant can_store case. * Take @jameysharp's suggested improvement to FuncEGraph::build() logic Co-authored-by: Jamey Sharp * Tweaks to FuncEGraph::build() on top of suggestion. * Take @jameysharp's suggested clarified condition Co-authored-by: Jamey Sharp * Clean up after suggestion (unused variable). * Fix loop analysis. * loop level asserts * Revert constant-space loop analysis -- edge cases were incorrect, so let's go with the simple thing for now. * Take @jameysharp's suggestion re: result_tys Co-authored-by: Jamey Sharp * Fix up after suggestion * Take @jameysharp's suggestion to use fold rather than reduce Co-authored-by: Jamey Sharp * Fixup after suggestion * Take @jameysharp's suggestion to remove elaborate_eclass_use's return value. * Clarifying comment in terminator insts. Co-authored-by: Jamey Sharp Co-authored-by: Nick Fitzgerald List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

7a9078d9 - cranelift: Allow `call` and `call_indirect` in runtests (#4667)

Fri, 26 Aug 2022 19:42:16 +0000

cranelift: Allow `call` and `call_indirect` in runtests (#4667)* cranelift: Change test runner order Changes the ordering of runtests to run per target and then per function. This change doesn't do a lot by itself, but helps future refactorings of runtests. * cranelift: Rename SingleFunctionCompiler to TestCaseCompiler * cranelift: Skip runtests per target instead of per run * cranelift: Deduplicate test names With the upcoming changes to the runtest infrastructure we require unique ExtNames for all tests. Note that for test names we have a 16 character limit on test names, and must be unique within those 16 characters. * cranelift: Add TestFileCompiler to runtests TestFileCompiler allows us to compile the entire file once, and then call the trampolines for each test. The previous code was compiling the function for each invocation of a test. * cranelift: Deduplicate ExtName for avg_round tests * cranelift: Rename functions as they are defined. The JIT internally only deals with User functions, and cannot link test name funcs. This also caches trampolines by signature. * cranelift: Preserve original name when reporting errors. * cranelift: Rename aarch64 test functions * cranelift: Add `call` and `call_indirect` tests! * cranelift: Add pauth runtests for aarch64 * cranelift: Rename duplicate s390x tests * cranelift: Delete `i128_bricmp_of` function from i128-bricmp It looks like we forgot to delete it when it was moved to `i128-bricmp-overflow`, and since it didn't have a run invocation it was never compiled. However, s390x does not support this, and panics when lowering. * cranelift: Add `colocated` call tests * cranelift: Rename *more* `s390x` tests * cranelift: Add pauth + sign_return_address call tests * cranelift: Undeduplicate test names With the latest main changes we now support *unlimited* length test names. This commit reverts: 52274676ff631c630f9879dd32e756566d3e700f 7989edc172493547cdf63e180bb58365e8a43a42 25c8a8395527d98976be6a34baa3b0b214776739 792e8cfa8f748077f9d80fe7ee5e958b7124e83b * cranelift: Add LibCall tests * cranelift: Revert more test names These weren't auto reverted by the previous revert. * cranelift: Disable libcall tests for aarch64 * cranelift: Runtest fibonacci tests * cranelift: Misc cleanup List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

0824abba - Add a basic alias analysis with redundant-load elim and store-to-load fowarding opts. (#4163)

Fri, 20 May 2022 20:19:32 +0000

Add a basic alias analysis with redundant-load elim and store-to-load fowarding opts. (#4163)This PR adds a basic *alias analysis*, and optimizations that use it. This is a "mid-end optimization": it operates on CLIF, the machine-independent IR, before lowering occurs. The alias analysis (or maybe more properly, a sort of memory-value analysis) determines when it can prove a particular memory location is equal to a given SSA value, and when it can, it replaces any loads of that location. This subsumes two common optimizations: * Redundant load elimination: when the same memory address is loaded two times, and it can be proven that no intervening operations will write to that memory, then the second load is *redundant* and its result must be the same as the first. We can use the first load's result and remove the second load. * Store-to-load forwarding: when a load can be proven to access exactly the memory written by a preceding store, we can replace the load's result with the store's data operand, and remove the load. Both of these optimizations rely on a "last store" analysis that is a sort of coloring mechanism, split across disjoint categories of abstract state. The basic idea is that every memory-accessing operation is put into one of N disjoint categories; it is disallowed for memory to ever be accessed by an op in one category and later accessed by an op in another category. (The frontend must ensure this.) Then, given this, we scan the code and determine, for each memory-accessing op, when a single prior instruction is a store to the same category. This "colors" the instruction: it is, in a sense, a static name for that version of memory. This analysis provides an important invariant: if two operations access memory with the same last-store, then *no other store can alias* in the time between that last store and these operations. This must-not-alias property, together with a check that the accessed address is *exactly the same* (same SSA value and offset), and other attributes of the access (type, extension mode) are the same, let us prove that the results are the same. Given last-store info, we scan the instructions and build a table from "memory location" key (last store, address, offset, type, extension) to known SSA value stored in that location. A store inserts a new mapping. A load may also insert a new mapping, if we didn't already have one. Then when a load occurs and an entry already exists for its "location", we can reuse the value. This will be either RLE or St-to-Ld depending on where the value came from. Note that this *does* work across basic blocks: the last-store analysis is a full iterative dataflow pass, and we are careful to check dominance of a previously-defined value before aliasing to it at a potentially redundant load. So we will do the right thing if we only have a "partially redundant" load (loaded already but only in one predecessor block), but we will also correctly reuse a value if there is a store or load above a loop and a redundant load of that value within the loop, as long as no potentially-aliasing stores happen within the loop. List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

d2d0a0f3 - Remove Peepmatic!!!

Wed, 17 Nov 2021 21:04:17 +0000

Remove Peepmatic!!!Peepmatic was an early attempt at a DSL for peephole optimizations, with theidea that maybe sometime in the future we could user it for instructionselection as well. It didn't really pan out, however:* Peepmatic wasn't quite flexible enough, and adding new operators or snippets of code implemented externally in Rust was a bit of a pain.* The performance was never competitive with the hand-written peephole optimizers. It was *very* size efficient, but that came at the cost of run-time efficiency. Everything was table-based and interpreted, rather than generating any Rust code.Ultimately, because of these reasons, we never turned Peepmatic on by default.These days, we just landed the ISLE domain-specific language, and it is bettersuited than Peepmatic for all the things that Peepmatic was originally designedto do. It is more flexible and easy to integrate with external Rust code. It ishas better time efficiency, meeting or even beating hand-written code. I think asmall part of the reason why ISLE excels in these things is because its designwas informed by Peepmatic's failures. I still plan on continuing Peepmatic'smission to make Cranelift's peephole optimizer passes generated from DSL rewriterules, but using ISLE instead of Peepmatic.Thank you Peepmatic, rest in peace! List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

43a86f14 - Remove more old backend ISA concepts (#3402)

Mon, 04 Oct 2021 08:36:12 +0000

Remove more old backend ISA concepts (#3402)This also paves the way for unifying TargetIsa and MachBackend, since now they map one to one. In theory the two traits could be merged, which would be nice to limit the number of total concepts. Also they have quite different responsibilities, so it might be fine to keep them separate. Interestingly, this PR started as removing RegInfo from the TargetIsa trait since the adapter returned a dummy value there. From the fallout, noticed that all Display implementations didn't needed an ISA anymore (since these were only used to render ISA specific registers). Also the whole family of RegInfo / ValueLoc / RegUnit was exclusively used for the old backend, and these could be removed. Notably, some IR instructions needed to be removed, because they were using RegUnit too: this was the oddball of regfill / regmove / regspill / copy_special, which were IR instructions inserted by the old regalloc. Fare thee well! List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs

bae4ec64 - Remove ancient register allocation (#3401)

Thu, 30 Sep 2021 19:27:23 +0000

Remove ancient register allocation (#3401) List of files: /wasmtime-44.0.1/cranelift/filetests/src/lib.rs