Changes in blockorder.rs

2f7dbd61 - PCC: remove proof-carrying code (for now?). (#12800)

Tue, 31 Mar 2026 04:36:33 +0000

PCC: remove proof-carrying code (for now?). (#12800)In late 2023, we built out an experimental feature calledProof-Carrying Code (PCC), where we attached "facts" to values in theCLIF IR and built verification of these facts after lowering tomachine instructions. We also added "memory types" describing layoutof memory and a "checked" flag on memory operations such that we couldverify that any checked memory operation accessed valid memory (asdefined by memory types attached to pointer values viafacts). Wasmtime's Cranelift backend then put appropriate memory typesand facts in its IR such that all accesses to memory (aspirationally)could be checked, taking the whole mid-end and lowering backend ofCranelift out of the trusted core that enforces SFI.This basically worked, at the time, for static memories; but never fordynamic memories, and then work on the feature lostprioritization (aka I had to work on other things) and I wasn't ableto complete it and put it in fuzzing/enable it as a production option.Unfortunately since then it has bit-rotted significantly -- as we addnew backend optimizations and instruction lowerings we haven't keptthe PCC framework up to date.Inspired by the discussion in #12497 I think it's time to deleteit (hopefully just "for now"?) unless/until we can build it again. Andwhen we do that, we should probably get it to the point of validatingrobust operation on all combinations of memory configurations beforemerging. (That implies a big experiment branch rather than a bunch ofeager PRs in-tree, but so it goes.) I still believe it is possible tobuild this (and I have ideas on how to do it!) but not right now. List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

76911c29 - Partial support for no_std in cranelift_codegen (#12222)

Wed, 07 Jan 2026 16:41:32 +0000

Partial support for no_std in cranelift_codegen (#12222)* Move most things from std to core and alloc* Port assembler_x64 to no_std* before adding prelude to each file* Most of the files now work with no_std* update isle to use alloc and core* some instances shouldn't have been renamed, fixes cargo test* add cranelift-assembler-x64 (no_std) to CI* fix codegen_meta, missed one spot with std::slice* automatically remove prelude with cargo fix* update isle changes* update assembler changes* update assembler changes* use latest codegen changes + fix FxHash problem* add imports* fix floating issues with libm* remove unused import* temporarily remove OnceLock* add no_std arm support and add it into CI* Move most things from std to core and alloc* Port assembler_x64 to no_std* before adding prelude to each file* Most of the files now work with no_std* update isle to use alloc and core* some instances shouldn't have been renamed, fixes cargo test* add cranelift-assembler-x64 (no_std) to CI* automatically remove prelude with cargo fix* update isle changes* update assembler changes* update assembler changes* use latest codegen changes + fix FxHash problem* add imports* fix floating issues with libm* remove unused import* temporarily remove OnceLock* add no_std arm support and add it into CI* Move most things from std to core and alloc* Port assembler_x64 to no_std* before adding prelude to each file* Most of the files now work with no_std* update isle to use alloc and core* add cranelift-assembler-x64 (no_std) to CI* automatically remove prelude with cargo fix* update isle changes* update assembler changes* use latest codegen changes + fix FxHash problem* add imports* fix floating issues with libm* temporarily remove OnceLock* add no_std arm support and add it into CI* revert Cargo.toml formating* remove prelude and fix cargo.toml* cargo fmt* remove empty lines* bad renames* macro_use only on no_std* revert OnceLock change* only use stable libm features* update regalloc2* update comment* use continue instead* Update vets---------Co-authored-by: Alex Crichton List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

0889323a - cranelift-codegen: rename most uses of std to core and alloc (#12237)

Sat, 03 Jan 2026 00:54:48 +0000

cranelift-codegen: rename most uses of std to core and alloc (#12237)* rename most std uses to core and alloc* cargo fmt List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.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/src/machinst/blockorder.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/src/machinst/blockorder.rs

14db3bf8 - Cranelift: fix invalid regalloc constraints on try-call with empty handler list. (#10709)

Fri, 02 May 2025 18:40:01 +0000

Cranelift: fix invalid regalloc constraints on try-call with empty handler list. (#10709)(Reported by bjorn3 -- thanks!)We handle edge splitting for regalloc moves in a way that is designed tosplit minimally (for compiler performance and codegen quality): we onlysplit edges that are truly critical, i.e., come from a block with morethan one successor and go to a block with more than one predecessor.In all other cases, there is always a place for these moves to go: if ablock only has one successor, then edge-moves can go before its jump;and if a block only has one predecessor, then edge-moves can go at thebeginning of that block (before the blockparams' parallel-move). Theformer case -- before the branch -- works because of a restriction thatregalloc2 imposes: branches with only one target (that is, unconditionalbranches) cannot have any arguments. Otherwise, those uses would occurafter the edge-moves have already shuffled the register state into astate suitable for the next block. Violating this constraint leads to apanic.With ordinary unconditional branches, this is no problem. With`try_call`s with at least one handler listed, this is also no problem:such a terminator is seen as a branch with (at least) two targets byregalloc, so no edge-moves are placed before it, so it's allowed to havearguments, such as the arguments to the call itself. However, a`try_call` with *no* handler clauses, though pathological, appears toregalloc as an unconditional branch and so should not have anyarguments. The included test-case triggers this issue with such a`try_call` together with a normal-return target branch that has morethan one incoming edge, forcing the location for the moves into the`try_call`'s block. (The lack of actual edge-moves doesn't matter -- RA2performs the check on the IR restriction first.) The result is a panicat compile time.This PR fixes the issue by extending a similar fix for `br_table`s(which can trigger a very similar bug if they have only the defaultcase, i.e., one target) to `try_call{,_indirect}` as well: thelowered-block order computation, where edge-splits are determined,pretends that they always have at least two successors. This ensuresthat edges will be split as necessary, satisfying theno-arguments-to-unconditional-terminators restriction. List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

44e4919a - Cranelift: remove block params on critical-edge blocks. (#10485)

Mon, 31 Mar 2025 18:57:16 +0000

Cranelift: remove block params on critical-edge blocks. (#10485)When a block has a terminator branch that targets two or more otherblocks at the CLIF level, and any of these blocks have two or moreprecessors, the edge is a "critical edge" and we split it (insert anew empty block) so that the register allocator has a place to putmoves that happen only on that edge. Otherwise, there is no locationthat works: in the predecessor, code runs no matter which outgoingedge we take; and in the successor, code runs no matter which incomingedge we came from.Currently, when we generate these critical-edge blocks, we insertexactly one instruction: an unconditional branch. We wire up theblockparam dataflow by (i) adding block parameters to thecritical-edge block with the same signature as the original target,and (ii) adding all of these arguments to the unconditional branch. Inother words, we maintain the original block signature throughout.This is fine and correct, but it has two downsides. The first is aminor loss in compile-time efficiency (more SSA values andblock-params to process). The second, more interesting, is that ithinders future work with certain kinds of branches that may definevalues *on edges*.In particular, this approach prevents exception-handling support: a`try_call` instruction that acts as a terminator branch (withnormal-return and exceptional out-edges) defines normal-return valuesas block-call arguments that are usable on the normal-returnedge. Some of these normal-return values may be defined by loads froma return-value area. These loads need somewhere to go; they can't go"after the terminator" (then it wouldn't be a terminator), so they goin an edge block; as a result, the block-call for the normal-returnneeds to use its arguments only in the unconditional branch out of theedge block, not in the initial branch to the edge block.This PR alters the critical-edge blockparam handling to have noblock-call args on the branch into the edge block, and use theoriginal values (not the newly defined edge-block blockparams) in theblock-call out of the edge block. This will allow these values to bepossibly defined in the edge block rather than in the predecessor (theblock with the original terminator).This has no functional change today other than some perturbation ofregalloc decisions and a possibly slight compile-time speedup. List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

3e0b7e50 - loop analysis simplification (#9613)

Tue, 19 Nov 2024 20:00:16 +0000

loop analysis simplification (#9613)* loop analysis simplification* add iterator over reverse post order* review comments* review comments* use rpo iterator where possible* make use of same struct access pattern throughout* use new directly instead of calling macro List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

0c0153c1 - Enforce `clippy::clone_on_copy` for the workspace (#9025)

Sat, 27 Jul 2024 01:11:06 +0000

Enforce `clippy::clone_on_copy` for the workspace (#9025)* Derive `Copy` for `Val`* Fix `clippy::clone_on_copy` for the whole repo* Enforce `clippy::clone_on_copy` for the workspace* fix some more clippy::clone_on_copy that got missed List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.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/cranelift/codegen/src/machinst/blockorder.rs

132ef1e4 - Fxhash to rustchash (#8498)

Mon, 29 Apr 2024 15:25:41 +0000

Fxhash to rustchash (#8498)* move fx hash to workspace level dep* change internal fxhash to use fxhash crate* remove unneeded HashSet import* change fxhash crate to rustc hash* undo migration to rustc hash* manually implement hash function from fxhash* change to rustc hash List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

9ce3ffe1 - Update some CI dependencies (#7983)

Thu, 22 Feb 2024 23:54:03 +0000

Update some CI dependencies (#7983)* Update some CI dependencies* Update to the latest nightly toolchain* Update mdbook* Update QEMU for cross-compiled testing* Update `cargo nextest` for usage with MIRIprtest:full* Remove lots of unnecessary imports* Downgrade qemu as 8.2.1 seems to segfault* Remove more imports* Remove unused winch trait method* Fix warnings about unused trait methods* More unused imports* More unused imports List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

fde6c6f5 - fuzz: randomize block lowering order (#6254)

Tue, 02 May 2023 16:20:39 +0000

fuzz: randomize block lowering order (#6254)* fuzz: randomize block lowering orderCo-authored-by: Moritz Waser Co-authored-by: Remo Senekowitsch * fix block lowering order randomizationCo-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser * simplify control plane internalsCo-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser * avoid unnecessary allocationsCo-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser * remove unused change_order functionCo-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser * add arbitrary 1.3.0 to cargo vet imports lockCo-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser * optimize ControlPlane::shuffleCo-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser * clarify shuffle being a noop without chaos modeCo-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser * reorder only direct successors of a blockCo-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser * rename get_permutation -> shuffledCo-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser ---------Co-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

1192697c - refactor BlockLoweringOrder::new (#6255)

Thu, 20 Apr 2023 22:24:32 +0000

refactor BlockLoweringOrder::new (#6255)Co-authored-by: Falk Zwimpfer <24669719+FalkZ@users.noreply.github.com>Co-authored-by: Moritz Waser List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

8abfe928 - Reuse the DominatorTree postorder travesal in BlockLoweringOrder (#5843)

Thu, 23 Feb 2023 22:05:20 +0000

Reuse the DominatorTree postorder travesal in BlockLoweringOrder (#5843)* Rework the blockorder module to reuse the dom tree's cfg postorder* Update domtree tests* Treat br_table with an empty jump table as multiple block exits* Bless tests* Change branch_idx to succ_idx and fix the comment List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

a5698ced - cranelift: Remove brz and brnz (#5630)

Mon, 30 Jan 2023 20:34:56 +0000

cranelift: Remove brz and brnz (#5630)Remove the brz and brnz instructions, as their behavior is now redundant with brif. List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

25bf8e0e - Make DataFlowGraph::insts public, but restricted (#5450)

Fri, 16 Dec 2022 18:46:09 +0000

Make DataFlowGraph::insts public, but restricted (#5450)We have some operations defined on DataFlowGraph purely to work around borrow-checker issues with InstructionData and other data on DataFlowGraph. Part of the problem is that indexing the DFG directly hides the fact that we're only indexing the insts field of the DFG. This PR makes the insts field of the DFG public, but wraps it in a newtype that only allows indexing. This means that the borrow checker is better able to tell when operations on memory held by the DFG won't conflict, which comes up frequently when mutating ValueLists held by InstructionData. List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

d8b29089 - Initial forward-edge CFI implementation (#3693)

Thu, 08 Sep 2022 14:35:58 +0000

Initial forward-edge CFI implementation (#3693)* Initial forward-edge CFI implementation Give the user the option to start all basic blocks that are targets of indirect branches with the BTI instruction introduced by the Branch Target Identification extension to the Arm instruction set architecture. Copyright (c) 2022, Arm Limited. * Refactor `from_artifacts` to avoid second `make_executable` (#1) This involves "parsing" twice but this is parsing just the header of an ELF file so it's not a very intensive operation and should be ok to do twice. * Address the code review feedback Copyright (c) 2022, Arm Limited. Co-authored-by: Alex Crichton List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

8a9b1a90 - Implement an incremental compilation cache for Cranelift (#4551)

Fri, 12 Aug 2022 16:47:43 +0000

Implement an incremental compilation cache for Cranelift (#4551)This is the implementation of https://github.com/bytecodealliance/wasmtime/issues/4155, using the "inverted API" approach suggested by @cfallin (thanks!) in Cranelift, and trait object to provide a backend for an all-included experience in Wasmtime. After the suggestion of Chris, `Function` has been split into mostly two parts: - on the one hand, `FunctionStencil` contains all the fields required during compilation, and that act as a compilation cache key: if two function stencils are the same, then the result of their compilation (`CompiledCodeBase`) will be the same. This makes caching trivial, as the only thing to cache is the `FunctionStencil`. - on the other hand, `FunctionParameters` contain the... function parameters that are required to finalize the result of compilation into a `CompiledCode` (aka `CompiledCodeBase`) with proper final relocations etc., by applying fixups and so on. Most changes are here to accomodate those requirements, in particular that `FunctionStencil` should be `Hash`able to be used as a key in the cache: - most source locations are now relative to a base source location in the function, and as such they're encoded as `RelSourceLoc` in the `FunctionStencil`. This required changes so that there's no need to explicitly mark a `SourceLoc` as the base source location, it's automatically detected instead the first time a non-default `SourceLoc` is set. - user-defined external names in the `FunctionStencil` (aka before this patch `ExternalName::User { namespace, index }`) are now references into an external table of `UserExternalNameRef -> UserExternalName`, present in the `FunctionParameters`, and must be explicitly declared using `Function::declare_imported_user_function`. - some refactorings have been made for function names: - `ExternalName` was used as the type for a `Function`'s name; while it thus allowed `ExternalName::Libcall` in this place, this would have been quite confusing to use it there. Instead, a new enum `UserFuncName` is introduced for this name, that's either a user-defined function name (the above `UserExternalName`) or a test case name. - The future of `ExternalName` is likely to become a full reference into the `FunctionParameters`'s mapping, instead of being "either a handle for user-defined external names, or the thing itself for other variants". I'm running out of time to do this, and this is not trivial as it implies touching ISLE which I'm less familiar with. The cache computes a sha256 hash of the `FunctionStencil`, and uses this as the cache key. No equality check (using `PartialEq`) is performed in addition to the hash being the same, as we hope that this is sufficient data to avoid collisions. A basic fuzz target has been introduced that tries to do the bare minimum: - check that a function successfully compiled and cached will be also successfully reloaded from the cache, and returns the exact same function. - check that a trivial modification in the external mapping of `UserExternalNameRef -> UserExternalName` hits the cache, and that other modifications don't hit the cache. - This last check is less efficient and less likely to happen, so probably should be rethought a bit. Thanks to both @alexcrichton and @cfallin for your very useful feedback on Zulip. Some numbers show that for a large wasm module we're using internally, this is a 20% compile-time speedup, because so many `FunctionStencil`s are the same, even within a single module. For a group of modules that have a lot of code in common, we get hit rates up to 70% when they're used together. When a single function changes in a wasm module, every other function is reloaded; that's still slower than I expect (between 10% and 50% of the overall compile time), so there's likely room for improvement. Fixes #4155. List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs

953f83e6 - Cranelift: disallow marking entry block 'cold'. (#4659)

Tue, 09 Aug 2022 18:52:30 +0000

Cranelift: disallow marking entry block 'cold'. (#4659)This is a nonsensical constraint: the entry block must come first in the compiled code's layout, so it cannot also be sunk to the end of the function. This PR modifies the CLIF verifier to disallow this situation entirely. It also adds an assert during final block-order computation to catch the problem (and avoid a silent miscompile) even if the verifier is disabled. Fixes #4656. List of files: /wasmtime-44.0.1/cranelift/codegen/src/machinst/blockorder.rs