Bug 1614303 - Bump Cranelift to "98c818c129979e98a3db150f8f9698f6451b7ef7"; r=rhunt
authorBenjamin Bouvier <benj@benj.me>
Mon, 10 Feb 2020 16:50:57 +0000
changeset 513692 57d10ca6fbee57242db7eea07d5e5e685e00b006
parent 513691 2c1409815131d723823695a6f6b1f0fd2c07e5e7
child 513693 7df1967010af976aadade5e6e964731c6c9680e1
push id37120
push usercbrindusan@mozilla.com
push dateThu, 13 Feb 2020 18:21:33 +0000
treeherdermozilla-central@b47e32ff95b8 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersrhunt
bugs1614303
milestone75.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1614303 - Bump Cranelift to "98c818c129979e98a3db150f8f9698f6451b7ef7"; r=rhunt Differential Revision: https://phabricator.services.mozilla.com/D62233
.cargo/config.in
Cargo.lock
Cargo.toml
js/src/wasm/cranelift/Cargo.toml
third_party/rust/cranelift-bforest/.cargo-checksum.json
third_party/rust/cranelift-bforest/Cargo.toml
third_party/rust/cranelift-bforest/src/lib.rs
third_party/rust/cranelift-codegen-meta/.cargo-checksum.json
third_party/rust/cranelift-codegen-meta/Cargo.toml
third_party/rust/cranelift-codegen-meta/src/cdsl/ast.rs
third_party/rust/cranelift-codegen-meta/src/cdsl/instructions.rs
third_party/rust/cranelift-codegen-meta/src/gen_inst.rs
third_party/rust/cranelift-codegen-meta/src/gen_legalizer.rs
third_party/rust/cranelift-codegen-meta/src/shared/entities.rs
third_party/rust/cranelift-codegen-meta/src/shared/formats.rs
third_party/rust/cranelift-codegen-meta/src/shared/instructions.rs
third_party/rust/cranelift-codegen-meta/src/shared/legalize.rs
third_party/rust/cranelift-codegen-shared/.cargo-checksum.json
third_party/rust/cranelift-codegen-shared/Cargo.toml
third_party/rust/cranelift-codegen/.cargo-checksum.json
third_party/rust/cranelift-codegen/Cargo.toml
third_party/rust/cranelift-codegen/src/abi.rs
third_party/rust/cranelift-codegen/src/binemit/memorysink.rs
third_party/rust/cranelift-codegen/src/binemit/mod.rs
third_party/rust/cranelift-codegen/src/binemit/relaxation.rs
third_party/rust/cranelift-codegen/src/binemit/shrink.rs
third_party/rust/cranelift-codegen/src/cfg_printer.rs
third_party/rust/cranelift-codegen/src/cursor.rs
third_party/rust/cranelift-codegen/src/dce.rs
third_party/rust/cranelift-codegen/src/dominator_tree.rs
third_party/rust/cranelift-codegen/src/flowgraph.rs
third_party/rust/cranelift-codegen/src/ir/builder.rs
third_party/rust/cranelift-codegen/src/ir/dfg.rs
third_party/rust/cranelift-codegen/src/ir/entities.rs
third_party/rust/cranelift-codegen/src/ir/extname.rs
third_party/rust/cranelift-codegen/src/ir/function.rs
third_party/rust/cranelift-codegen/src/ir/instructions.rs
third_party/rust/cranelift-codegen/src/ir/jumptable.rs
third_party/rust/cranelift-codegen/src/ir/layout.rs
third_party/rust/cranelift-codegen/src/ir/libcall.rs
third_party/rust/cranelift-codegen/src/ir/mod.rs
third_party/rust/cranelift-codegen/src/ir/progpoint.rs
third_party/rust/cranelift-codegen/src/isa/constraints.rs
third_party/rust/cranelift-codegen/src/isa/riscv/mod.rs
third_party/rust/cranelift-codegen/src/isa/x86/abi.rs
third_party/rust/cranelift-codegen/src/isa/x86/binemit.rs
third_party/rust/cranelift-codegen/src/isa/x86/enc_tables.rs
third_party/rust/cranelift-codegen/src/isa/x86/fde.rs
third_party/rust/cranelift-codegen/src/isa/x86/unwind.rs
third_party/rust/cranelift-codegen/src/legalizer/boundary.rs
third_party/rust/cranelift-codegen/src/legalizer/heap.rs
third_party/rust/cranelift-codegen/src/legalizer/libcall.rs
third_party/rust/cranelift-codegen/src/legalizer/mod.rs
third_party/rust/cranelift-codegen/src/legalizer/split.rs
third_party/rust/cranelift-codegen/src/licm.rs
third_party/rust/cranelift-codegen/src/loop_analysis.rs
third_party/rust/cranelift-codegen/src/nan_canonicalization.rs
third_party/rust/cranelift-codegen/src/postopt.rs
third_party/rust/cranelift-codegen/src/print_errors.rs
third_party/rust/cranelift-codegen/src/redundant_reload_remover.rs
third_party/rust/cranelift-codegen/src/regalloc/branch_splitting.rs
third_party/rust/cranelift-codegen/src/regalloc/coalescing.rs
third_party/rust/cranelift-codegen/src/regalloc/coloring.rs
third_party/rust/cranelift-codegen/src/regalloc/context.rs
third_party/rust/cranelift-codegen/src/regalloc/diversion.rs
third_party/rust/cranelift-codegen/src/regalloc/live_value_tracker.rs
third_party/rust/cranelift-codegen/src/regalloc/liveness.rs
third_party/rust/cranelift-codegen/src/regalloc/liverange.rs
third_party/rust/cranelift-codegen/src/regalloc/reload.rs
third_party/rust/cranelift-codegen/src/regalloc/safepoint.rs
third_party/rust/cranelift-codegen/src/regalloc/solver.rs
third_party/rust/cranelift-codegen/src/regalloc/spilling.rs
third_party/rust/cranelift-codegen/src/regalloc/virtregs.rs
third_party/rust/cranelift-codegen/src/simple_gvn.rs
third_party/rust/cranelift-codegen/src/simple_preopt.rs
third_party/rust/cranelift-codegen/src/topo_order.rs
third_party/rust/cranelift-codegen/src/unreachable_code.rs
third_party/rust/cranelift-codegen/src/value_label.rs
third_party/rust/cranelift-codegen/src/verifier/cssa.rs
third_party/rust/cranelift-codegen/src/verifier/flags.rs
third_party/rust/cranelift-codegen/src/verifier/liveness.rs
third_party/rust/cranelift-codegen/src/verifier/locations.rs
third_party/rust/cranelift-codegen/src/verifier/mod.rs
third_party/rust/cranelift-codegen/src/write.rs
third_party/rust/cranelift-entity/.cargo-checksum.json
third_party/rust/cranelift-entity/Cargo.toml
third_party/rust/cranelift-entity/src/lib.rs
third_party/rust/cranelift-entity/src/set.rs
third_party/rust/cranelift-frontend/.cargo-checksum.json
third_party/rust/cranelift-frontend/Cargo.toml
third_party/rust/cranelift-frontend/src/frontend.rs
third_party/rust/cranelift-frontend/src/lib.rs
third_party/rust/cranelift-frontend/src/ssa.rs
third_party/rust/cranelift-frontend/src/switch.rs
third_party/rust/cranelift-wasm/.cargo-checksum.json
third_party/rust/cranelift-wasm/Cargo.toml
third_party/rust/cranelift-wasm/src/code_translator.rs
third_party/rust/cranelift-wasm/src/func_translator.rs
third_party/rust/cranelift-wasm/src/sections_translator.rs
third_party/rust/cranelift-wasm/src/state/func_state.rs
third_party/rust/cranelift-wasm/src/translation_utils.rs
third_party/rust/wasmparser/.cargo-checksum.json
third_party/rust/wasmparser/Cargo.lock
third_party/rust/wasmparser/Cargo.toml
third_party/rust/wasmparser/src/binary_reader.rs
third_party/rust/wasmparser/src/lib.rs
third_party/rust/wasmparser/src/module_resources.rs
third_party/rust/wasmparser/src/operators_validator.rs
third_party/rust/wasmparser/src/parser.rs
third_party/rust/wasmparser/src/primitives.rs
third_party/rust/wasmparser/src/readers/mod.rs
third_party/rust/wasmparser/src/readers/module.rs
third_party/rust/wasmparser/src/tests.rs
third_party/rust/wasmparser/src/validator.rs
--- a/.cargo/config.in
+++ b/.cargo/config.in
@@ -40,17 +40,17 @@ rev = "3541e3818fdc7c2a24f87e3459151a4ce
 [source."https://github.com/djg/cubeb-pulse-rs"]
 git = "https://github.com/djg/cubeb-pulse-rs"
 replace-with = "vendored-sources"
 rev = "8069f8f4189982e0b38fa6dc8993dd4fab41f728"
 
 [source."https://github.com/bytecodealliance/cranelift"]
 git = "https://github.com/bytecodealliance/cranelift"
 replace-with = "vendored-sources"
-rev = "eb20fcab349ce20ac6f8659d1c4b058108d5e627"
+rev = "98c818c129979e98a3db150f8f9698f6451b7ef7"
 
 [source."https://github.com/badboy/failure"]
 git = "https://github.com/badboy/failure"
 replace-with = "vendored-sources"
 rev = "64af847bc5fdcb6d2438bec8a6030812a80519a5"
 
 [source."https://github.com/alexcrichton/mio-named-pipes"]
 branch = "master"
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -693,80 +693,80 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49726015ab0ca765144fcca61e4a7a543a16b795a777fa53f554da2fffff9a94"
 dependencies = [
  "cose",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.56.0"
-source = "git+https://github.com/bytecodealliance/cranelift?rev=eb20fcab349ce20ac6f8659d1c4b058108d5e627#eb20fcab349ce20ac6f8659d1c4b058108d5e627"
-dependencies = [
- "cranelift-entity 0.56.0",
+version = "0.58.0"
+source = "git+https://github.com/bytecodealliance/cranelift?rev=98c818c129979e98a3db150f8f9698f6451b7ef7#98c818c129979e98a3db150f8f9698f6451b7ef7"
+dependencies = [
+ "cranelift-entity 0.58.0",
 ]
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.56.0"
-source = "git+https://github.com/bytecodealliance/cranelift?rev=eb20fcab349ce20ac6f8659d1c4b058108d5e627#eb20fcab349ce20ac6f8659d1c4b058108d5e627"
+version = "0.58.0"
+source = "git+https://github.com/bytecodealliance/cranelift?rev=98c818c129979e98a3db150f8f9698f6451b7ef7#98c818c129979e98a3db150f8f9698f6451b7ef7"
 dependencies = [
  "byteorder",
  "cranelift-bforest",
  "cranelift-codegen-meta",
  "cranelift-codegen-shared",
- "cranelift-entity 0.56.0",
+ "cranelift-entity 0.58.0",
  "log",
  "smallvec 1.2.0",
  "target-lexicon 0.10.0",
  "thiserror",
 ]
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.56.0"
-source = "git+https://github.com/bytecodealliance/cranelift?rev=eb20fcab349ce20ac6f8659d1c4b058108d5e627#eb20fcab349ce20ac6f8659d1c4b058108d5e627"
+version = "0.58.0"
+source = "git+https://github.com/bytecodealliance/cranelift?rev=98c818c129979e98a3db150f8f9698f6451b7ef7#98c818c129979e98a3db150f8f9698f6451b7ef7"
 dependencies = [
  "cranelift-codegen-shared",
- "cranelift-entity 0.56.0",
+ "cranelift-entity 0.58.0",
 ]
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.56.0"
-source = "git+https://github.com/bytecodealliance/cranelift?rev=eb20fcab349ce20ac6f8659d1c4b058108d5e627#eb20fcab349ce20ac6f8659d1c4b058108d5e627"
+version = "0.58.0"
+source = "git+https://github.com/bytecodealliance/cranelift?rev=98c818c129979e98a3db150f8f9698f6451b7ef7#98c818c129979e98a3db150f8f9698f6451b7ef7"
 
 [[package]]
 name = "cranelift-entity"
 version = "0.41.0"
 source = "git+https://github.com/PLSysSec/lucet_sandbox_compiler?rev=a3fd180d53a6f929a7ef47466ffc2e53338ad4f1#a3fd180d53a6f929a7ef47466ffc2e53338ad4f1"
 
 [[package]]
 name = "cranelift-entity"
-version = "0.56.0"
-source = "git+https://github.com/bytecodealliance/cranelift?rev=eb20fcab349ce20ac6f8659d1c4b058108d5e627#eb20fcab349ce20ac6f8659d1c4b058108d5e627"
+version = "0.58.0"
+source = "git+https://github.com/bytecodealliance/cranelift?rev=98c818c129979e98a3db150f8f9698f6451b7ef7#98c818c129979e98a3db150f8f9698f6451b7ef7"
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.56.0"
-source = "git+https://github.com/bytecodealliance/cranelift?rev=eb20fcab349ce20ac6f8659d1c4b058108d5e627#eb20fcab349ce20ac6f8659d1c4b058108d5e627"
+version = "0.58.0"
+source = "git+https://github.com/bytecodealliance/cranelift?rev=98c818c129979e98a3db150f8f9698f6451b7ef7#98c818c129979e98a3db150f8f9698f6451b7ef7"
 dependencies = [
  "cranelift-codegen",
  "log",
  "smallvec 1.2.0",
  "target-lexicon 0.10.0",
 ]
 
 [[package]]
 name = "cranelift-wasm"
-version = "0.56.0"
-source = "git+https://github.com/bytecodealliance/cranelift?rev=eb20fcab349ce20ac6f8659d1c4b058108d5e627#eb20fcab349ce20ac6f8659d1c4b058108d5e627"
+version = "0.58.0"
+source = "git+https://github.com/bytecodealliance/cranelift?rev=98c818c129979e98a3db150f8f9698f6451b7ef7#98c818c129979e98a3db150f8f9698f6451b7ef7"
 dependencies = [
  "cranelift-codegen",
- "cranelift-entity 0.56.0",
+ "cranelift-entity 0.58.0",
  "cranelift-frontend",
  "log",
  "thiserror",
  "wasmparser",
 ]
 
 [[package]]
 name = "crc32fast"
@@ -4595,19 +4595,19 @@ dependencies = [
  "tokio",
  "tokio-io",
  "tokio-threadpool",
  "urlencoding",
 ]
 
 [[package]]
 name = "wasmparser"
-version = "0.47.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1add8db5a53a2f64f13418b241982c4ab533d7a9e1e8a5dcadccce633d8d393b"
+version = "0.48.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "073da89bf1c84db000dd68ce660c1b4a08e3a2d28fd1e3394ab9e7abdde4a0f8"
 
 [[package]]
 name = "webdriver"
 version = "0.40.2"
 dependencies = [
  "base64",
  "cookie",
  "http 0.1.17",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -66,13 +66,13 @@ rlbox_lucet_sandbox = { git = "https://g
 nix = { git = "https://github.com/shravanrn/nix/", branch = "r0.13.1", rev="4af6c367603869a30fddb5ffb0aba2b9477ba92e" }
 spirv_cross = { git = "https://github.com/kvark/spirv_cross", branch = "wgpu", rev = "9cb4de489bf80b2b23efffe5a79afb7db6247ba4" }
 # failure's backtrace feature might break our builds, see bug 1608157.
 failure = { git = "https://github.com/badboy/failure", rev = "64af847bc5fdcb6d2438bec8a6030812a80519a5" }
 failure_derive = { git = "https://github.com/badboy/failure", rev = "64af847bc5fdcb6d2438bec8a6030812a80519a5" }
 
 [patch.crates-io.cranelift-codegen]
 git = "https://github.com/bytecodealliance/cranelift"
-rev = "eb20fcab349ce20ac6f8659d1c4b058108d5e627"
+rev = "98c818c129979e98a3db150f8f9698f6451b7ef7"
 
 [patch.crates-io.cranelift-wasm]
 git = "https://github.com/bytecodealliance/cranelift"
-rev = "eb20fcab349ce20ac6f8659d1c4b058108d5e627"
+rev = "98c818c129979e98a3db150f8f9698f6451b7ef7"
--- a/js/src/wasm/cranelift/Cargo.toml
+++ b/js/src/wasm/cranelift/Cargo.toml
@@ -8,18 +8,18 @@ edition = "2018"
 crate-type = ["rlib"]
 name = "baldrdash"
 
 [dependencies]
 # The build system redirects the versions of cranelift-codegen and
 # cranelift-wasm to pinned commits. If you want to update Cranelift in Gecko,
 # you should update the following $TOP_LEVEL/Cargo.toml file: look for the
 # revision (rev) hashes of both cranelift dependencies (codegen and wasm).
-cranelift-codegen = { version = "0.56", default-features = false }
-cranelift-wasm = "0.56"
+cranelift-codegen = { version = "0.58.0", default-features = false }
+cranelift-wasm = "0.58.0"
 log = { version = "0.4.6", default-features = false, features = ["release_max_level_info"] }
 env_logger = "0.6"
 smallvec = "1.0"
 
 [build-dependencies]
 bindgen = {version = "0.51.1", default-features = false} # disable `logging` to reduce code size
 
 [features]
--- a/third_party/rust/cranelift-bforest/.cargo-checksum.json
+++ b/third_party/rust/cranelift-bforest/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"6ff5db6c1ea4645414a7bee929c1acc913382bbcb29b4dd33477185e64a83bf4","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"af367c67340fa7f6fb9a35b0aa637dcf303957f7ae7427a5f4f6356801c8bb04","src/lib.rs":"59933214e5213d003d98c6fa5f22c3c863557640189588d989ff0335b006af9a","src/map.rs":"a3b7f64cae7ec9c2a8038def315bcf90e8751552b1bc1c20b62fbb8c763866c4","src/node.rs":"28f7edd979f7b9712bc4ab30b0d2a1b8ad5485a4b1e8c09f3dcaf501b9b5ccd1","src/path.rs":"a86ee1c882c173e8af96fd53a416a0fb485dd3f045ac590ef313a9d9ecf90f56","src/pool.rs":"f6337b5417f7772e6878a160c1a40629199ff09997bdff18eb2a0ba770158600","src/set.rs":"281eb8b5ead1ffd395946464d881f9bb0e7fb61092aed701d72d2314b5f80994"},"package":null}
\ No newline at end of file
+{"files":{"Cargo.toml":"535a760fb2660c657313c8161a52e76cf5f5eb2b3c2beda5803ae16bb7ad1166","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"af367c67340fa7f6fb9a35b0aa637dcf303957f7ae7427a5f4f6356801c8bb04","src/lib.rs":"23a5c42d477197a947122e662068e681bb9ed31041c0b668c3267c3fce15d39e","src/map.rs":"a3b7f64cae7ec9c2a8038def315bcf90e8751552b1bc1c20b62fbb8c763866c4","src/node.rs":"28f7edd979f7b9712bc4ab30b0d2a1b8ad5485a4b1e8c09f3dcaf501b9b5ccd1","src/path.rs":"a86ee1c882c173e8af96fd53a416a0fb485dd3f045ac590ef313a9d9ecf90f56","src/pool.rs":"f6337b5417f7772e6878a160c1a40629199ff09997bdff18eb2a0ba770158600","src/set.rs":"281eb8b5ead1ffd395946464d881f9bb0e7fb61092aed701d72d2314b5f80994"},"package":null}
\ No newline at end of file
--- a/third_party/rust/cranelift-bforest/Cargo.toml
+++ b/third_party/rust/cranelift-bforest/Cargo.toml
@@ -1,19 +1,19 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift-bforest"
-version = "0.56.0"
+version = "0.58.0"
 description = "A forest of B+-trees"
 license = "Apache-2.0 WITH LLVM-exception"
 documentation = "https://cranelift.readthedocs.io/"
 repository = "https://github.com/bytecodealliance/cranelift"
 categories = ["no-std"]
 readme = "README.md"
 keywords = ["btree", "forest", "set", "map"]
 edition = "2018"
 
 [dependencies]
-cranelift-entity = { path = "../cranelift-entity", version = "0.56.0", default-features = false }
+cranelift-entity = { path = "../cranelift-entity", version = "0.58.0", default-features = false }
 
 [badges]
 maintenance = { status = "experimental" }
 travis-ci = { repository = "bytecodealliance/cranelift" }
--- a/third_party/rust/cranelift-bforest/src/lib.rs
+++ b/third_party/rust/cranelift-bforest/src/lib.rs
@@ -143,32 +143,32 @@ fn slice_shift<T: Copy>(s: &mut [T], n: 
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::entity::EntityRef;
 
-    /// An opaque reference to an extended basic block in a function.
+    /// An opaque reference to a basic block in a function.
     #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-    pub struct Ebb(u32);
-    entity_impl!(Ebb, "ebb");
+    pub struct Block(u32);
+    entity_impl!(Block, "block");
 
     #[test]
     fn comparator() {
-        let ebb1 = Ebb::new(1);
-        let ebb2 = Ebb::new(2);
-        let ebb3 = Ebb::new(3);
-        let ebb4 = Ebb::new(4);
-        let vals = [ebb1, ebb2, ebb4];
+        let block1 = Block::new(1);
+        let block2 = Block::new(2);
+        let block3 = Block::new(3);
+        let block4 = Block::new(4);
+        let vals = [block1, block2, block4];
         let comp = ();
-        assert_eq!(comp.search(ebb1, &vals), Ok(0));
-        assert_eq!(comp.search(ebb3, &vals), Err(2));
-        assert_eq!(comp.search(ebb4, &vals), Ok(2));
+        assert_eq!(comp.search(block1, &vals), Ok(0));
+        assert_eq!(comp.search(block3, &vals), Err(2));
+        assert_eq!(comp.search(block4, &vals), Ok(2));
     }
 
     #[test]
     fn slice_insertion() {
         let mut a = ['a', 'b', 'c', 'd'];
 
         slice_insert(&mut a[0..1], 0, 'e');
         assert_eq!(a, ['e', 'b', 'c', 'd']);
--- a/third_party/rust/cranelift-codegen-meta/.cargo-checksum.json
+++ b/third_party/rust/cranelift-codegen-meta/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"938700819ee5e8988ff462d6a3fb4abe94fcd9f9111033dad9610f444c68f6eb","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"b123f056d0d458396679c5f7f2a16d2762af0258fcda4ac14b6655a95e5a0022","src/cdsl/ast.rs":"8fdd17d9d8c4bd0cf535599a40d7da0e5bf27fdcef817cd55ab7c580c8eb6a6c","src/cdsl/cpu_modes.rs":"996e45b374cfe85ac47c8c86c4459fe4c04b3158102b4c63b6ee434d5eed6a9e","src/cdsl/encodings.rs":"d884a564815a03c23369bcf31d13b122ae5ba84d0c80eda9312f0c0a829bf794","src/cdsl/formats.rs":"63e638305aa3ca6dd409ddf0e5e9605eeac1cc2631103e42fc6cbc87703d9b63","src/cdsl/instructions.rs":"bc8b65a2bc689ee2837ea0d9771a37791b747ec1b71cb46eae414830f55be581","src/cdsl/isa.rs":"ccabd6848b69eb069c10db61c7e7f86080777495714bb53d03e663c40541be94","src/cdsl/mod.rs":"0aa827923bf4c45e5ee2359573bd863e00f474acd532739f49dcd74a27553882","src/cdsl/operands.rs":"1c3411504de9c83112ff48e0ff1cfbb2e4ba5a9a15c1716f411ef31a4df59899","src/cdsl/recipes.rs":"80b7cd87332229b569e38086ceee8d557e679b9a32ad2e50bdb15c33337c3418","src/cdsl/regs.rs":"05f93ab8504ee82d7cc9811a5b40e5cd004c327577b4c0b3dd957fc422f3c013","src/cdsl/settings.rs":"e6fd9a31925743b93b11f09c9c8271bab6aa2430aa053a2601957b4487df7d77","src/cdsl/type_inference.rs":"1efca8a095ffc899b7527bda6b9d9378c73d7283f8dceaa4819e8af599f8be21","src/cdsl/types.rs":"ff764c9e9c29a05677bff6164e7bc25a0c32655052d77ae580536abba8b1713b","src/cdsl/typevar.rs":"c7e80a3c52755f2d91fb5c3d18413b7c97777bd54d1aece8a17d1bbd9944c46a","src/cdsl/xform.rs":"55da0c3f2403147b535ab6ae5d69c623fbe839edecf2a3af1de84420cd58402d","src/default_map.rs":"101bb0282a124f9c921f6bd095f529e8753621450d783c3273b0b0394c2c5c03","src/error.rs":"e9b11b2feb2d867b94c8810fdc5a6c4e0d9131604a0bfa5340ff2639a55100b4","src/gen_binemit.rs":"515e243420b30d1e01f8ea630282d9b6d78a715e1951f3f20392e19a48164442","src/gen_encodings.rs":"f00cded6b68a9b48c9e3cd39a8b6f0ba136f4062c8f8666109158a72c62c3ed1","src/gen_inst.rs":"fac99641622591c0529c0ef789dd83290a624fc674c91a959f426696f82044de","src/gen_legalizer.rs":"7a68c2b9fd77b6420ecb10539d9af0520374e4f2e30d5a345d98dafde157e6bd","src/gen_registers.rs":"3628949229c1cb5179ec5f655b9a1ddd0504ba74ffb9fb23741c85c9154b696f","src/gen_settings.rs":"f3cc3d31f6cc898f30606caf084f0de220db2d3b1b5e5e4145fa7c9a9a1597e2","src/gen_types.rs":"f6c090e1646a43bf2fe81ae0a7029cc6f7dc6d43285368f56d86c35a21c469a6","src/isa/arm32/mod.rs":"8e09ec1b3caf2d22dce8517b37c356047bfce9a6dea712467d867ed05c4bedaf","src/isa/arm64/mod.rs":"b01f030925d3f2af37d7df1b4a800eb7f0d24f74a46e9154fd8b6752643eb2d5","src/isa/mod.rs":"136141f99f217ba42b9e3f7f47238ab19cc974bb3bef2e2df7f7b5a683989d46","src/isa/riscv/encodings.rs":"8abb1968d917588bc5fc5f5be6dd66bdec23ac456ba65f8138237c8e891e843c","src/isa/riscv/mod.rs":"a7b461a30bbfbc1e3b33645422ff40d5b1761c30cb5d4a8aa12e9a3b7f7aee51","src/isa/riscv/recipes.rs":"c9424cffed54cc4d328879a4613b9f6a2c2b7cde7e6e17b4fccd5f661aaf92f2","src/isa/x86/encodings.rs":"f151bfb4da35c57bb614856ac84f5ac7fd0593a77360623338e6c1c7e5c5ba5f","src/isa/x86/instructions.rs":"e4a92f2b707e0a9af0317041eb9a8bc58a8bedcdbbe35f54dcfaf05699a50675","src/isa/x86/legalize.rs":"fca4a2729fbefded71effb7517c63a3da3648f8ab68968ef014cfc5d5f631cc7","src/isa/x86/mod.rs":"d6e363531df896ab542af664a5f2514f993cfb8ea485d39d8ea1b7a40747267e","src/isa/x86/opcodes.rs":"643bae64cd4050814adfb856046cf650979bec5d251a9d9a6e11bafb5a603c43","src/isa/x86/recipes.rs":"c80a15a90d521eb4752595601087d8797a43f17a5e1b7ed5379e85f7c926cd62","src/isa/x86/registers.rs":"e24c9487f4c257b1089dac6bca0106cc673db77292cd000ca8e0c7e0d0103f63","src/isa/x86/settings.rs":"9087cd57da2852b689bddc296639f9b9e1caa30e8185798891079da8d9340b53","src/lib.rs":"2491b0e74078914cb89d1778fa8174daf723fe76aaf7fed18741237d68f6df32","src/shared/entities.rs":"911b396da11188bd510de004956596f150e27540edd351c74028f99f5f3c79c5","src/shared/formats.rs":"d8cf211c392ec3c54d0101ef31b700c3222bc8e80b69a04b244953e449770336","src/shared/immediates.rs":"e4a57657f6af9853794804eb41c01204a2c13a632f44f55d90e156a4b98c5f65","src/shared/instructions.rs":"9e575d6378a3eb0e297dca41acf86ec6547a2a27600df2d8c500b7648f600e6d","src/shared/legalize.rs":"73e1b42743c324104f5a34120e1598146ce4ee7393137ecb5391b768c61f2605","src/shared/mod.rs":"bc497c14d083c29eefe4935cff9cd1bd138c071bc50f787248727a3858dc69f3","src/shared/settings.rs":"cda96c9599d49b82e5cd43c7d0fd53a197fa8dadcc56dc33566ac47fdd6da607","src/shared/types.rs":"4702df132f4b5d70cc9411ec5221ba0b1bd4479252274e0223ae57b6d0331247","src/srcgen.rs":"dcfc159c8599270f17e6a978c4be255abca51556b5ef0da497faec4a4a1e62ce","src/unique_table.rs":"31aa54330ca4786af772d32e8cb6158b6504b88fa93fe177bf0c6cbe545a8d35"},"package":null}
\ No newline at end of file
+{"files":{"Cargo.toml":"3179d424e3926ec5951277b2325013fcde7286f992c9a0dba6ff4da1fa694e5a","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"b123f056d0d458396679c5f7f2a16d2762af0258fcda4ac14b6655a95e5a0022","src/cdsl/ast.rs":"84a4b7e3301e3249716958a7aa4ea5ba8c6172e3c02f57ee3880504c4433ff19","src/cdsl/cpu_modes.rs":"996e45b374cfe85ac47c8c86c4459fe4c04b3158102b4c63b6ee434d5eed6a9e","src/cdsl/encodings.rs":"d884a564815a03c23369bcf31d13b122ae5ba84d0c80eda9312f0c0a829bf794","src/cdsl/formats.rs":"63e638305aa3ca6dd409ddf0e5e9605eeac1cc2631103e42fc6cbc87703d9b63","src/cdsl/instructions.rs":"034fe7dae4fc9b90cf876a3d966d4bf1e4b5db11888704a7adc7a522dcd32947","src/cdsl/isa.rs":"ccabd6848b69eb069c10db61c7e7f86080777495714bb53d03e663c40541be94","src/cdsl/mod.rs":"0aa827923bf4c45e5ee2359573bd863e00f474acd532739f49dcd74a27553882","src/cdsl/operands.rs":"1c3411504de9c83112ff48e0ff1cfbb2e4ba5a9a15c1716f411ef31a4df59899","src/cdsl/recipes.rs":"80b7cd87332229b569e38086ceee8d557e679b9a32ad2e50bdb15c33337c3418","src/cdsl/regs.rs":"05f93ab8504ee82d7cc9811a5b40e5cd004c327577b4c0b3dd957fc422f3c013","src/cdsl/settings.rs":"e6fd9a31925743b93b11f09c9c8271bab6aa2430aa053a2601957b4487df7d77","src/cdsl/type_inference.rs":"1efca8a095ffc899b7527bda6b9d9378c73d7283f8dceaa4819e8af599f8be21","src/cdsl/types.rs":"ff764c9e9c29a05677bff6164e7bc25a0c32655052d77ae580536abba8b1713b","src/cdsl/typevar.rs":"c7e80a3c52755f2d91fb5c3d18413b7c97777bd54d1aece8a17d1bbd9944c46a","src/cdsl/xform.rs":"55da0c3f2403147b535ab6ae5d69c623fbe839edecf2a3af1de84420cd58402d","src/default_map.rs":"101bb0282a124f9c921f6bd095f529e8753621450d783c3273b0b0394c2c5c03","src/error.rs":"e9b11b2feb2d867b94c8810fdc5a6c4e0d9131604a0bfa5340ff2639a55100b4","src/gen_binemit.rs":"515e243420b30d1e01f8ea630282d9b6d78a715e1951f3f20392e19a48164442","src/gen_encodings.rs":"f00cded6b68a9b48c9e3cd39a8b6f0ba136f4062c8f8666109158a72c62c3ed1","src/gen_inst.rs":"2e103077d5c3233b9b2d5e93ef595e1259c5e95886afca1be4ba2a9820ff2f23","src/gen_legalizer.rs":"de4b41b78a1cefa0c458b699058405c14ebccd5219b51e0be329af9d96f19dc9","src/gen_registers.rs":"3628949229c1cb5179ec5f655b9a1ddd0504ba74ffb9fb23741c85c9154b696f","src/gen_settings.rs":"f3cc3d31f6cc898f30606caf084f0de220db2d3b1b5e5e4145fa7c9a9a1597e2","src/gen_types.rs":"f6c090e1646a43bf2fe81ae0a7029cc6f7dc6d43285368f56d86c35a21c469a6","src/isa/arm32/mod.rs":"8e09ec1b3caf2d22dce8517b37c356047bfce9a6dea712467d867ed05c4bedaf","src/isa/arm64/mod.rs":"b01f030925d3f2af37d7df1b4a800eb7f0d24f74a46e9154fd8b6752643eb2d5","src/isa/mod.rs":"136141f99f217ba42b9e3f7f47238ab19cc974bb3bef2e2df7f7b5a683989d46","src/isa/riscv/encodings.rs":"8abb1968d917588bc5fc5f5be6dd66bdec23ac456ba65f8138237c8e891e843c","src/isa/riscv/mod.rs":"a7b461a30bbfbc1e3b33645422ff40d5b1761c30cb5d4a8aa12e9a3b7f7aee51","src/isa/riscv/recipes.rs":"c9424cffed54cc4d328879a4613b9f6a2c2b7cde7e6e17b4fccd5f661aaf92f2","src/isa/x86/encodings.rs":"f151bfb4da35c57bb614856ac84f5ac7fd0593a77360623338e6c1c7e5c5ba5f","src/isa/x86/instructions.rs":"e4a92f2b707e0a9af0317041eb9a8bc58a8bedcdbbe35f54dcfaf05699a50675","src/isa/x86/legalize.rs":"fca4a2729fbefded71effb7517c63a3da3648f8ab68968ef014cfc5d5f631cc7","src/isa/x86/mod.rs":"d6e363531df896ab542af664a5f2514f993cfb8ea485d39d8ea1b7a40747267e","src/isa/x86/opcodes.rs":"643bae64cd4050814adfb856046cf650979bec5d251a9d9a6e11bafb5a603c43","src/isa/x86/recipes.rs":"c80a15a90d521eb4752595601087d8797a43f17a5e1b7ed5379e85f7c926cd62","src/isa/x86/registers.rs":"e24c9487f4c257b1089dac6bca0106cc673db77292cd000ca8e0c7e0d0103f63","src/isa/x86/settings.rs":"9087cd57da2852b689bddc296639f9b9e1caa30e8185798891079da8d9340b53","src/lib.rs":"2491b0e74078914cb89d1778fa8174daf723fe76aaf7fed18741237d68f6df32","src/shared/entities.rs":"90f774a70e1c2a2e9a553c07a5e80e0fe54cf127434bd83e67274bba4e1a19ba","src/shared/formats.rs":"89ed4074f748637adf56b93ba952e398c45d43e6326d01676885939e3fe8bc4a","src/shared/immediates.rs":"e4a57657f6af9853794804eb41c01204a2c13a632f44f55d90e156a4b98c5f65","src/shared/instructions.rs":"d5c3d3c59eb157f047bb2afe71f0a065c28b06627c6ab4e0104a44205cf89004","src/shared/legalize.rs":"bc9c3292446c1d338df1c4ce19f3ac5482cfe582a04a5a1e82fc9aaa6aef25ea","src/shared/mod.rs":"bc497c14d083c29eefe4935cff9cd1bd138c071bc50f787248727a3858dc69f3","src/shared/settings.rs":"cda96c9599d49b82e5cd43c7d0fd53a197fa8dadcc56dc33566ac47fdd6da607","src/shared/types.rs":"4702df132f4b5d70cc9411ec5221ba0b1bd4479252274e0223ae57b6d0331247","src/srcgen.rs":"dcfc159c8599270f17e6a978c4be255abca51556b5ef0da497faec4a4a1e62ce","src/unique_table.rs":"31aa54330ca4786af772d32e8cb6158b6504b88fa93fe177bf0c6cbe545a8d35"},"package":null}
\ No newline at end of file
--- a/third_party/rust/cranelift-codegen-meta/Cargo.toml
+++ b/third_party/rust/cranelift-codegen-meta/Cargo.toml
@@ -1,20 +1,20 @@
 [package]
 name = "cranelift-codegen-meta"
 authors = ["The Cranelift Project Developers"]
-version = "0.56.0"
+version = "0.58.0"
 description = "Metaprogram for cranelift-codegen code generator library"
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/cranelift"
 readme = "README.md"
 edition = "2018"
 
 [dependencies]
-cranelift-codegen-shared = { path = "../shared", version = "0.56.0" }
-cranelift-entity = { path = "../../cranelift-entity", version = "0.56.0" }
+cranelift-codegen-shared = { path = "../shared", version = "0.58.0" }
+cranelift-entity = { path = "../../cranelift-entity", version = "0.58.0" }
 
 [badges]
 maintenance = { status = "experimental" }
 travis-ci = { repository = "bytecodealliance/cranelift" }
 
 [package.metadata.docs.rs]
 rustdoc-args = [ "--document-private-items" ]
--- a/third_party/rust/cranelift-codegen-meta/src/cdsl/ast.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/cdsl/ast.rs
@@ -703,18 +703,18 @@ macro_rules! def {
 
     // An instruction with no results.
     ($($tt:tt)*) => {
         def_rhs!($($tt)*).assign_to(Vec::new())
     }
 }
 
 // Helper macro to define legalization recipes.
-macro_rules! ebb {
-    // An basic block definition, splitting the current block in 2.
+macro_rules! block {
+    // a basic block definition, splitting the current block in 2.
     ($block: ident) => {
         ExprBuilder::block($block).assign_to(Vec::new())
     };
 }
 
 #[cfg(test)]
 mod tests {
     use crate::cdsl::ast::ConstPool;
--- a/third_party/rust/cranelift-codegen-meta/src/cdsl/instructions.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/cdsl/instructions.rs
@@ -107,17 +107,17 @@ pub(crate) struct InstructionContent {
 
     /// Indices in operands_in of input operands that are values.
     pub value_opnums: Vec<usize>,
     /// Indices in operands_in of input operands that are immediates or entities.
     pub imm_opnums: Vec<usize>,
     /// Indices in operands_out of output operands that are values.
     pub value_results: Vec<usize>,
 
-    /// True for instructions that terminate the EBB.
+    /// True for instructions that terminate the block.
     pub is_terminator: bool,
     /// True for all branch or jump instructions.
     pub is_branch: bool,
     /// True for all indirect branch or jump instructions.',
     pub is_indirect_branch: bool,
     /// Is this a call instruction?
     pub is_call: bool,
     /// Is this a return instruction?
--- a/third_party/rust/cranelift-codegen-meta/src/gen_inst.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/gen_inst.rs
@@ -445,17 +445,17 @@ fn gen_opcodes(all_inst: &AllInstruction
     fmt.empty_line();
 
     fmt.line("impl Opcode {");
     fmt.indent(|fmt| {
         gen_bool_accessor(
             all_inst,
             |inst| inst.is_terminator,
             "is_terminator",
-            "True for instructions that terminate the EBB",
+            "True for instructions that terminate the block",
             fmt,
         );
         gen_bool_accessor(
             all_inst,
             |inst| inst.is_branch,
             "is_branch",
             "True for all branch or jump instructions.",
             fmt,
--- a/third_party/rust/cranelift-codegen-meta/src/gen_legalizer.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/gen_legalizer.rs
@@ -469,70 +469,70 @@ fn gen_transform<'a>(
                 name,
                 value
             );
         }
 
         // If we are adding some blocks, we need to recall the original block, such that we can
         // recompute it.
         if !transform.block_pool.is_empty() {
-            fmt.line("let orig_ebb = pos.current_ebb().unwrap();");
+            fmt.line("let orig_block = pos.current_block().unwrap();");
         }
 
         // If we're going to delete `inst`, we need to detach its results first so they can be
         // reattached during pattern expansion.
         if !replace_inst {
             fmt.line("pos.func.dfg.clear_results(inst);");
         }
 
         // Emit new block creation.
         for block in &transform.block_pool {
             let var = transform.var_pool.get(block.name);
-            fmtln!(fmt, "let {} = pos.func.dfg.make_ebb();", var.name);
+            fmtln!(fmt, "let {} = pos.func.dfg.make_block();", var.name);
         }
 
         // Emit the destination pattern.
         for &def_index in &transform.dst {
             if let Some(block) = transform.block_pool.get(def_index) {
                 let var = transform.var_pool.get(block.name);
-                fmtln!(fmt, "pos.insert_ebb({});", var.name);
+                fmtln!(fmt, "pos.insert_block({});", var.name);
             }
             emit_dst_inst(
                 transform.def_pool.get(def_index),
                 &transform.def_pool,
                 &transform.var_pool,
                 fmt,
             );
         }
 
         // Insert a new block after the last instruction, if needed.
         let def_next_index = transform.def_pool.next_index();
         if let Some(block) = transform.block_pool.get(def_next_index) {
             let var = transform.var_pool.get(block.name);
-            fmtln!(fmt, "pos.insert_ebb({});", var.name);
+            fmtln!(fmt, "pos.insert_block({});", var.name);
         }
 
         // Delete the original instruction if we didn't have an opportunity to replace it.
         if !replace_inst {
             fmt.line("let removed = pos.remove_inst();");
             fmt.line("debug_assert_eq!(removed, inst);");
         }
 
         if transform.block_pool.is_empty() {
             if transform.def_pool.get(transform.src).apply.inst.is_branch {
                 // A branch might have been legalized into multiple branches, so we need to recompute
                 // the cfg.
-                fmt.line("cfg.recompute_ebb(pos.func, pos.current_ebb().unwrap());");
+                fmt.line("cfg.recompute_block(pos.func, pos.current_block().unwrap());");
             }
         } else {
             // Update CFG for the new blocks.
-            fmt.line("cfg.recompute_ebb(pos.func, orig_ebb);");
+            fmt.line("cfg.recompute_block(pos.func, orig_block);");
             for block in &transform.block_pool {
                 let var = transform.var_pool.get(block.name);
-                fmtln!(fmt, "cfg.recompute_ebb(pos.func, {});", var.name);
+                fmtln!(fmt, "cfg.recompute_block(pos.func, {});", var.name);
             }
         }
 
         fmt.line("return true;");
     };
 
     // Guard the actual expansion by `predicate`.
     if has_extra_constraints {
--- a/third_party/rust/cranelift-codegen-meta/src/shared/entities.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/shared/entities.rs
@@ -1,19 +1,19 @@
 use crate::cdsl::operands::{OperandKind, OperandKindFields};
 
 /// Small helper to initialize an OperandBuilder with the right kind, for a given name and doc.
 fn new(format_field_name: &'static str, rust_type: &'static str, doc: &'static str) -> OperandKind {
     OperandKind::new(format_field_name, rust_type, OperandKindFields::EntityRef).with_doc(doc)
 }
 
 pub(crate) struct EntityRefs {
-    /// A reference to an extended basic block in the same function.
+    /// A reference to a basic block in the same function.
     /// This is primarliy used in control flow instructions.
-    pub(crate) ebb: OperandKind,
+    pub(crate) block: OperandKind,
 
     /// A reference to a stack slot declared in the function preamble.
     pub(crate) stack_slot: OperandKind,
 
     /// A reference to a global value.
     pub(crate) global_value: OperandKind,
 
     /// A reference to a function signature declared in the function preamble.
@@ -28,27 +28,27 @@ pub(crate) struct EntityRefs {
     pub(crate) jump_table: OperandKind,
 
     /// A reference to a heap declared in the function preamble.
     pub(crate) heap: OperandKind,
 
     /// A reference to a table declared in the function preamble.
     pub(crate) table: OperandKind,
 
-    /// A variable-sized list of value operands. Use for Ebb and function call arguments.
+    /// A variable-sized list of value operands. Use for Block and function call arguments.
     pub(crate) varargs: OperandKind,
 }
 
 impl EntityRefs {
     pub fn new() -> Self {
         Self {
-            ebb: new(
+            block: new(
                 "destination",
-                "ir::Ebb",
-                "An extended basic block in the same function.",
+                "ir::Block",
+                "a basic block in the same function.",
             ),
             stack_slot: new("stack_slot", "ir::StackSlot", "A stack slot"),
 
             global_value: new("global_value", "ir::GlobalValue", "A global value."),
 
             sig_ref: new("sig_ref", "ir::SigRef", "A function signature."),
 
             func_ref: new("func_ref", "ir::FuncRef", "An external function."),
@@ -59,15 +59,15 @@ impl EntityRefs {
 
             table: new("table", "ir::Table", "A table."),
 
             varargs: OperandKind::new("", "&[Value]", OperandKindFields::VariableArgs).with_doc(
                 r#"
                         A variable size list of `value` operands.
 
                         Use this to represent arguments passed to a function call, arguments
-                        passed to an extended basic block, or a variable number of results
+                        passed to a basic block, or a variable number of results
                         returned from an instruction.
                     "#,
             ),
         }
     }
 }
--- a/third_party/rust/cranelift-codegen-meta/src/shared/formats.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/shared/formats.rs
@@ -135,49 +135,49 @@ impl Formats {
 
             int_select: Builder::new("IntSelect")
                 .imm(&imm.intcc)
                 .value()
                 .value()
                 .value()
                 .build(),
 
-            jump: Builder::new("Jump").imm(&entities.ebb).varargs().build(),
+            jump: Builder::new("Jump").imm(&entities.block).varargs().build(),
 
             branch: Builder::new("Branch")
                 .value()
-                .imm(&entities.ebb)
+                .imm(&entities.block)
                 .varargs()
                 .build(),
 
             branch_int: Builder::new("BranchInt")
                 .imm(&imm.intcc)
                 .value()
-                .imm(&entities.ebb)
+                .imm(&entities.block)
                 .varargs()
                 .build(),
 
             branch_float: Builder::new("BranchFloat")
                 .imm(&imm.floatcc)
                 .value()
-                .imm(&entities.ebb)
+                .imm(&entities.block)
                 .varargs()
                 .build(),
 
             branch_icmp: Builder::new("BranchIcmp")
                 .imm(&imm.intcc)
                 .value()
                 .value()
-                .imm(&entities.ebb)
+                .imm(&entities.block)
                 .varargs()
                 .build(),
 
             branch_table: Builder::new("BranchTable")
                 .value()
-                .imm(&entities.ebb)
+                .imm(&entities.block)
                 .imm(&entities.jump_table)
                 .build(),
 
             branch_table_entry: Builder::new("BranchTableEntry")
                 .value()
                 .value()
                 .imm(&imm.uimm8)
                 .imm(&entities.jump_table)
--- a/third_party/rust/cranelift-codegen-meta/src/shared/instructions.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/shared/instructions.rs
@@ -13,52 +13,52 @@ use crate::shared::{entities::EntityRefs
 
 #[inline(never)]
 fn define_control_flow(
     ig: &mut InstructionGroupBuilder,
     formats: &Formats,
     imm: &Immediates,
     entities: &EntityRefs,
 ) {
-    let EBB = &Operand::new("EBB", &entities.ebb).with_doc("Destination extended basic block");
-    let args = &Operand::new("args", &entities.varargs).with_doc("EBB arguments");
+    let block = &Operand::new("block", &entities.block).with_doc("Destination basic block");
+    let args = &Operand::new("args", &entities.varargs).with_doc("block arguments");
 
     ig.push(
         Inst::new(
             "jump",
             r#"
         Jump.
 
-        Unconditionally jump to an extended basic block, passing the specified
-        EBB arguments. The number and types of arguments must match the
-        destination EBB.
+        Unconditionally jump to a basic block, passing the specified
+        block arguments. The number and types of arguments must match the
+        destination block.
         "#,
             &formats.jump,
         )
-        .operands_in(vec![EBB, args])
+        .operands_in(vec![block, args])
         .is_terminator(true)
         .is_branch(true),
     );
 
     ig.push(
         Inst::new(
             "fallthrough",
             r#"
-        Fall through to the next EBB.
-
-        This is the same as `jump`, except the destination EBB must be
+        Fall through to the next block.
+
+        This is the same as `jump`, except the destination block must be
         the next one in the layout.
 
         Jumps are turned into fall-through instructions by the branch
         relaxation pass. There is no reason to use this instruction outside
         that pass.
         "#,
             &formats.jump,
         )
-        .operands_in(vec![EBB, args])
+        .operands_in(vec![block, args])
         .is_terminator(true)
         .is_branch(true),
     );
 
     let Testable = &TypeVar::new(
         "Testable",
         "A scalar boolean or integer type",
         TypeSetBuilder::new()
@@ -76,32 +76,32 @@ fn define_control_flow(
                 r#"
         Branch when zero.
 
         If ``c`` is a `b1` value, take the branch when ``c`` is false. If
         ``c`` is an integer value, take the branch when ``c = 0``.
         "#,
                 &formats.branch,
             )
-            .operands_in(vec![c, EBB, args])
+            .operands_in(vec![c, block, args])
             .is_branch(true),
         );
 
         ig.push(
             Inst::new(
                 "brnz",
                 r#"
         Branch when non-zero.
 
         If ``c`` is a `b1` value, take the branch when ``c`` is true. If
         ``c`` is an integer value, take the branch when ``c != 0``.
         "#,
                 &formats.branch,
             )
-            .operands_in(vec![c, EBB, args])
+            .operands_in(vec![c, block, args])
             .is_branch(true),
         );
     }
 
     let iB = &TypeVar::new(
         "iB",
         "A scalar integer type",
         TypeSetBuilder::new().ints(Interval::All).build(),
@@ -119,47 +119,47 @@ fn define_control_flow(
                 "br_icmp",
                 r#"
         Compare scalar integers and branch.
 
         Compare ``x`` and ``y`` in the same way as the `icmp` instruction
         and take the branch if the condition is true:
 
         ```text
-            br_icmp ugt v1, v2, ebb4(v5, v6)
+            br_icmp ugt v1, v2, block4(v5, v6)
         ```
 
         is semantically equivalent to:
 
         ```text
             v10 = icmp ugt, v1, v2
-            brnz v10, ebb4(v5, v6)
+            brnz v10, block4(v5, v6)
         ```
 
         Some RISC architectures like MIPS and RISC-V provide instructions that
         implement all or some of the condition codes. The instruction can also
         be used to represent *macro-op fusion* on architectures like Intel's.
         "#,
                 &formats.branch_icmp,
             )
-            .operands_in(vec![Cond, x, y, EBB, args])
+            .operands_in(vec![Cond, x, y, block, args])
             .is_branch(true),
         );
 
         let f = &Operand::new("f", iflags);
 
         ig.push(
             Inst::new(
                 "brif",
                 r#"
         Branch when condition is true in integer CPU flags.
         "#,
                 &formats.branch_int,
             )
-            .operands_in(vec![Cond, f, EBB, args])
+            .operands_in(vec![Cond, f, block, args])
             .is_branch(true),
         );
     }
 
     {
         let Cond = &Operand::new("Cond", &imm.floatcc);
 
         let f = &Operand::new("f", fflags);
@@ -167,47 +167,47 @@ fn define_control_flow(
         ig.push(
             Inst::new(
                 "brff",
                 r#"
         Branch when condition is true in floating point CPU flags.
         "#,
                 &formats.branch_float,
             )
-            .operands_in(vec![Cond, f, EBB, args])
+            .operands_in(vec![Cond, f, block, args])
             .is_branch(true),
         );
     }
 
     {
         let x = &Operand::new("x", iB).with_doc("index into jump table");
         let JT = &Operand::new("JT", &entities.jump_table);
 
         ig.push(
             Inst::new(
                 "br_table",
                 r#"
         Indirect branch via jump table.
 
         Use ``x`` as an unsigned index into the jump table ``JT``. If a jump
-        table entry is found, branch to the corresponding EBB. If no entry was
-        found or the index is out-of-bounds, branch to the given default EBB.
+        table entry is found, branch to the corresponding block. If no entry was
+        found or the index is out-of-bounds, branch to the given default block.
 
         Note that this branch instruction can't pass arguments to the targeted
         blocks. Split critical edges as needed to work around this.
 
         Do not confuse this with "tables" in WebAssembly. ``br_table`` is for
         jump tables with destinations within the current function only -- think
         of a ``match`` in Rust or a ``switch`` in C.  If you want to call a
         function in a dynamic library, that will typically use
         ``call_indirect``.
         "#,
                 &formats.branch_table,
             )
-            .operands_in(vec![x, EBB, JT])
+            .operands_in(vec![x, block, JT])
             .is_terminator(true)
             .is_branch(true),
         );
     }
 
     let iAddr = &TypeVar::new(
         "iAddr",
         "An integer address type",
@@ -1402,17 +1402,17 @@ pub(crate) fn define(
         Temporarily divert ``x`` from ``src`` to ``dst``.
 
         This instruction moves the location of a value from one register to
         another without creating a new SSA value. It is used by the register
         allocator to temporarily rearrange register assignments in order to
         satisfy instruction constraints.
 
         The register diversions created by this instruction must be undone
-        before the value leaves the EBB. At the entry to a new EBB, all live
+        before the value leaves the block. At the entry to a new block, all live
         values must be in their originally assigned registers.
         "#,
             &formats.reg_move,
         )
         .operands_in(vec![x, src, dst])
         .other_side_effects(true),
     );
 
--- a/third_party/rust/cranelift-codegen-meta/src/shared/legalize.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/shared/legalize.rs
@@ -192,19 +192,19 @@ pub(crate) fn define(insts: &Instruction
     let f2 = var("f2");
     let xl = var("xl");
     let xh = var("xh");
     let yl = var("yl");
     let yh = var("yh");
     let al = var("al");
     let ah = var("ah");
     let cc = var("cc");
-    let ebb = var("ebb");
-    let ebb1 = var("ebb1");
-    let ebb2 = var("ebb2");
+    let block = var("block");
+    let block1 = var("block1");
+    let block2 = var("block2");
     let ptr = var("ptr");
     let flags = var("flags");
     let offset = var("off");
     let vararg = var("vararg");
 
     narrow.custom_legalize(load, "narrow_load");
     narrow.custom_legalize(store, "narrow_store");
 
@@ -264,17 +264,17 @@ pub(crate) fn define(insts: &Instruction
             def!((yl, yh) = isplit(y)),
             def!(al = select(c, xl, yl)),
             def!(ah = select(c, xh, yh)),
             def!(a = iconcat(al, ah)),
         ],
     );
 
     narrow.legalize(
-        def!(brz.I128(x, ebb, vararg)),
+        def!(brz.I128(x, block, vararg)),
         vec![
             def!((xl, xh) = isplit(x)),
             def!(
                 a = icmp_imm(
                     Literal::enumerator_for(&imm.intcc, "eq"),
                     xl,
                     Literal::constant(&imm.imm64, 0)
                 )
@@ -282,28 +282,28 @@ pub(crate) fn define(insts: &Instruction
             def!(
                 b = icmp_imm(
                     Literal::enumerator_for(&imm.intcc, "eq"),
                     xh,
                     Literal::constant(&imm.imm64, 0)
                 )
             ),
             def!(c = band(a, b)),
-            def!(brnz(c, ebb, vararg)),
+            def!(brnz(c, block, vararg)),
         ],
     );
 
     narrow.legalize(
-        def!(brnz.I128(x, ebb1, vararg)),
+        def!(brnz.I128(x, block1, vararg)),
         vec![
             def!((xl, xh) = isplit(x)),
-            def!(brnz(xl, ebb1, vararg)),
-            def!(jump(ebb2, Literal::empty_vararg())),
-            ebb!(ebb2),
-            def!(brnz(xh, ebb1, vararg)),
+            def!(brnz(xl, block1, vararg)),
+            def!(jump(block2, Literal::empty_vararg())),
+            block!(block2),
+            def!(brnz(xh, block1, vararg)),
         ],
     );
 
     narrow.legalize(
         def!(a = popcnt.I128(x)),
         vec![
             def!((xl, xh) = isplit(x)),
             def!(e1 = popcnt(xl)),
@@ -614,23 +614,23 @@ pub(crate) fn define(insts: &Instruction
                     def!(a = icmp(w_cc, x, y)),
                 ],
             );
         }
     }
 
     for &ty in &[I8, I16] {
         widen.legalize(
-            def!(brz.ty(x, ebb, vararg)),
-            vec![def!(a = uextend.I32(x)), def!(brz(a, ebb, vararg))],
+            def!(brz.ty(x, block, vararg)),
+            vec![def!(a = uextend.I32(x)), def!(brz(a, block, vararg))],
         );
 
         widen.legalize(
-            def!(brnz.ty(x, ebb, vararg)),
-            vec![def!(a = uextend.I32(x)), def!(brnz(a, ebb, vararg))],
+            def!(brnz.ty(x, block, vararg)),
+            vec![def!(a = uextend.I32(x)), def!(brnz(a, block, vararg))],
         );
     }
 
     // Expand integer operations with carry for RISC architectures that don't have
     // the flags.
     let intcc_ult = Literal::enumerator_for(&imm.intcc, "ult");
     expand.legalize(
         def!((a, c) = iadd_cout(x, y)),
--- a/third_party/rust/cranelift-codegen-shared/.cargo-checksum.json
+++ b/third_party/rust/cranelift-codegen-shared/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"df839290e460380f9b3007d081c8180510d957c65ebeb2d30b898dfe6865bbec","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"a410bc2f5dcbde499c0cd299c2620bc8111e3c5b3fccdd9e2d85caf3c24fdab3","src/condcodes.rs":"b8d433b2217b86e172d25b6c65a3ce0cc8ca221062cad1b28b0c78d2159fbda9","src/constant_hash.rs":"ffc619f45aad62c6fdcb83553a05879691a72e9a0103375b2d6cc12d52cf72d0","src/constants.rs":"fed03a10a6316e06aa174091db6e7d1fbb5f73c82c31193012ec5ab52f1c603a","src/isa/mod.rs":"428a950eca14acbe783899ccb1aecf15027f8cbe205578308ebde203d10535f3","src/isa/x86/encoding_bits.rs":"7e013fb804b13f9f83a0d517c6f5105856938d08ad378cc44a6fe6a59adef270","src/isa/x86/mod.rs":"01ef4e4d7437f938badbe2137892183c1ac684da0f68a5bec7e06aad34f43b9b","src/lib.rs":"91f26f998f11fb9cb74d2ec171424e29badd417beef023674850ace57149c656"},"package":null}
\ No newline at end of file
+{"files":{"Cargo.toml":"4b84070f17601421b41646efa8761533de5867778772e126c5349d623b30d278","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"a410bc2f5dcbde499c0cd299c2620bc8111e3c5b3fccdd9e2d85caf3c24fdab3","src/condcodes.rs":"b8d433b2217b86e172d25b6c65a3ce0cc8ca221062cad1b28b0c78d2159fbda9","src/constant_hash.rs":"ffc619f45aad62c6fdcb83553a05879691a72e9a0103375b2d6cc12d52cf72d0","src/constants.rs":"fed03a10a6316e06aa174091db6e7d1fbb5f73c82c31193012ec5ab52f1c603a","src/isa/mod.rs":"428a950eca14acbe783899ccb1aecf15027f8cbe205578308ebde203d10535f3","src/isa/x86/encoding_bits.rs":"7e013fb804b13f9f83a0d517c6f5105856938d08ad378cc44a6fe6a59adef270","src/isa/x86/mod.rs":"01ef4e4d7437f938badbe2137892183c1ac684da0f68a5bec7e06aad34f43b9b","src/lib.rs":"91f26f998f11fb9cb74d2ec171424e29badd417beef023674850ace57149c656"},"package":null}
\ No newline at end of file
--- a/third_party/rust/cranelift-codegen-shared/Cargo.toml
+++ b/third_party/rust/cranelift-codegen-shared/Cargo.toml
@@ -1,11 +1,11 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift-codegen-shared"
-version = "0.56.0"
+version = "0.58.0"
 description = "For code shared between cranelift-codegen-meta and cranelift-codegen"
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/cranelift"
 readme = "README.md"
 edition = "2018"
 
 # Since this is a shared dependency of several packages, please strive to keep this dependency-free.
--- a/third_party/rust/cranelift-codegen/.cargo-checksum.json
+++ b/third_party/rust/cranelift-codegen/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"edaf70577db03f1b3de39a42eeaf062334255ed501afdbe3085722523a52429f","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"e5127227a7db4a8aa92fa6613ed71801025790e696bb41b0323fb7f3c6f7495a","build.rs":"9fffedcfb42f2147f1a3f2b8d39af91e291768fe6f4e75ce19de1debfca7bfd8","src/abi.rs":"eec2c37e39e29665d971da1ebf4e42e9dc28e5c8e3ba030dd4d2c4090f99579a","src/binemit/memorysink.rs":"bd630a490b98049ef1ea5dbb203bacf6ae6e76551b3328ea9e5b9b3744b5035d","src/binemit/mod.rs":"111362efd540307136badea21003393e7da193b4c11758e7d7c846ab4904ecde","src/binemit/relaxation.rs":"35a5f7afe552c1ab6dfdd125e75880b217944adcffc5db027a4ac0b8ad9620a0","src/binemit/shrink.rs":"5755efc978f5056a33c0ecb1bd5e08310397f54a67434ecead184fc6ee047133","src/binemit/stackmap.rs":"3f141f4652ec5148fbcf2db88d0ac7881823158b528c989770eacd4165afa39b","src/bitset.rs":"c4fa43fff52a8f2d343e3edbeeb26d851c64ed811e3d3aa9e2af80358d43be14","src/cfg_printer.rs":"d2909587cfd65b9a66c87e749248b055b32eeea428597572a3f0c6c542bee8c9","src/constant_hash.rs":"8f53afb38891fbdab8553c7a89e61f0ce30947a22fb24ae84523c9a1ab025c3f","src/context.rs":"d47182f15327dbd775d9bbeae87439a108f8e12ac20515ee59934d059aaf5fb2","src/cursor.rs":"9ff74f47f0e0ecbb7ae67ed001c794e386d65f6eb99892f77109b0b8f1f90634","src/dbg.rs":"1898d94cff0975815eb348651702e95c8f2f63886501d3b7043ee75668480472","src/dce.rs":"d8ab7c0cac0416f9d75afdacc60ba02e532361ec927c3f8bd171b1a53ec8b31a","src/divconst_magic_numbers.rs":"e7f8f46f3a25ed7155890e9d76c10f5dde9dc5bbcebb623c8166fa415abdd959","src/dominator_tree.rs":"184a501aa1838902ad3cf6145a58ff3ddd2ed0cb00ca4ed4a39b56ea5d8b0a55","src/flowgraph.rs":"2709526095875da1e93cb831599360e05b92e2566447e525e7870a29b0a2acf5","src/fx.rs":"8a5d07487906d8316a179e826fcd817a92a4860686256a6fd9d78ba47c63f330","src/ir/builder.rs":"6f111f2a65dfe27633dcec918f74b767277131a72cd94b7bec2e1ef5c4308d5b","src/ir/constant.rs":"6e9e9c82f2ded45d574d0a6029ce6cd3513b9de6329ed194ca5bab21ed1d1b9a","src/ir/dfg.rs":"6385e629822418a60d70c96074defc4a30aa9b87550640d43a459a6cef0c3080","src/ir/entities.rs":"a166cf74be2e51d9e8dc22dfb27e0d1f03f3d16d59deee37e980e1b0e62a68ea","src/ir/extfunc.rs":"57ef6509acb504cdd292fc5a637486a1de15c78f8c9b2205ac820874592e54c4","src/ir/extname.rs":"8f539363e24b37abd7d1a34ad66ae6eca59207f611e02c3dface76da477346f7","src/ir/framelayout.rs":"c3393bcaec95df01f732164525c65843db157ed8816e0cc4b82fd9f868c31550","src/ir/function.rs":"229366e48141f020b870cfeacf8fe9b04fd5e495ece948373f85b73a52c774a0","src/ir/globalvalue.rs":"5a33af46e0c4b9537ef9fc422ab4fa2dc70b919b7cd6316f27b76a715361f060","src/ir/heap.rs":"a59d3e5901412b53c0b53a8cdf10765ff5921de9c410ae9acea226c89827df3c","src/ir/immediates.rs":"323ff93cb36bb682374ad323f145e61ba554f01d7ffebebe058531cbc556b91a","src/ir/instructions.rs":"2b71d040ae6240348ab74bf764c84e01e699708342349a090337a010400577a2","src/ir/jumptable.rs":"6375275599dc6f07027f81d823fa1d7371359a7b961f9627377164710a87bb71","src/ir/layout.rs":"d0e358885f1b03412d651b8d6e57cc362cc3c02bcda4ab5ea259d06dedfadf77","src/ir/libcall.rs":"510cd6301940ab92e54711d9e52cb34f29dca7e6d6203f1d7cff3daa085bc1ac","src/ir/memflags.rs":"dbcf3798ab66dc764b73fb7f139a621c54cc6bcc683f1f70a33ed7e8c3486bfd","src/ir/mod.rs":"ed386b2648c513d54d35781652a07a6b989deb481a1b3cc7c5aa7776337b05c4","src/ir/progpoint.rs":"96609331ba8b23dc3ab3c485464ab7ab3e7d0c0e8843a5d72e39ea334d4b3070","src/ir/sourceloc.rs":"67c66adace734645ddf311ecb22e975f20756e07c91e10f698a830cfc2cd08aa","src/ir/stackslot.rs":"5d489d21f17c9992d0862c38c661fab2a19e025a7f29a4417d0336d9bfc5f7f0","src/ir/table.rs":"dcc3b663a989b2b084402b08dc9a0e928dbd052e194a46a1886cc6f0cf1a5f2c","src/ir/trapcode.rs":"413090e632116d405ba69f3b0e6f4460e0a67c5dfb934e11c8eebde04d8e1af5","src/ir/types.rs":"ec261b6c3677f4113a2f7125da0df3fd66a1a666aebb19abd5cb49fcef372bc6","src/ir/valueloc.rs":"fc31e06b2b0f37333829c4658b7f6fa8a717e93e18a5c67a63947e5882bbe1a2","src/isa/arm32/abi.rs":"59abc42d75445f7f3335b035655083772e98e413ee58a72fc4e224620327b5ea","src/isa/arm32/binemit.rs":"eecd7296c27d2520db8e86dd462833ecf06afd33548b03ae676c02454cdd13c2","src/isa/arm32/enc_tables.rs":"e94b12af802de59484cab1124d2ac8a88d08433f6e1a476724ed0403f4b5967f","src/isa/arm32/mod.rs":"9ccd3a24afc921f35bb89f508d86fe5eb63e86e9c85d34132a01a131e19e2f61","src/isa/arm32/registers.rs":"100033c78e2a891ad90a2765137bd678f1d11ae4ba61974d1083106fa1324037","src/isa/arm32/settings.rs":"2314460f885c24f9571d640f9737a8e0b7d20ca02bcda1127f878fd3891c0529","src/isa/arm64/abi.rs":"c946f65b7731095734074e9c06964672cdf4c8352a54fe23f7411d874b27ec28","src/isa/arm64/binemit.rs":"3afbb78f6d9ae5614d908023f84b774c0493c8757ad86fd8301baf0928bb0104","src/isa/arm64/enc_tables.rs":"73fedf7da610a982e37c76e5211dbce880f77841b71c678b0dab2b9e7217cb7c","src/isa/arm64/mod.rs":"e89bbc1d0dcbce21378fd83ef5b73071cb51b2f5561092ae960aa229accc6f53","src/isa/arm64/registers.rs":"e8bc77f218c83cedec50e2b5b28b88e3301443bd02f7a80151748f2be4b31ea0","src/isa/arm64/settings.rs":"5405ce3560b7ba0705ef525c706eb9f1593e901e1767b837c012084397639042","src/isa/call_conv.rs":"da8064a29cd3577928e3ebd3d3f869bf3dc707a4ac0f2e04d01e81770ff1aebf","src/isa/constraints.rs":"bddb5c68e56b122a53d8be215e41d22ccf8c4563630b1486e6eb31c0d3337565","src/isa/enc_tables.rs":"382e714f9500afc292c563cb66d4c963d6787e58f197b1db242db7a099c22b9a","src/isa/encoding.rs":"22e21fdb8e15859c69e4f836bb61e1a82cd6838d093ce5fe641a90f16fb65c9e","src/isa/mod.rs":"ab7319fdc633228610329a87e22e06308e310e60cd6e59e279b3076259632ab6","src/isa/registers.rs":"f09ca662be1e0beb776d050a46a8ecf7927f2bf75e36c4bda4010b442c4df815","src/isa/riscv/abi.rs":"aa60b701efcef417ee1262a95398343578dc1a30decc8e11044b74d41654ec51","src/isa/riscv/binemit.rs":"264d223da311d4482ebf2f55438b665c67b163058251bc78173c76ba983a31ef","src/isa/riscv/enc_tables.rs":"8491f2082b24c7dedeb7c36cfd913bf9aeaa0a4c8fc754166e9285f4ae002f40","src/isa/riscv/mod.rs":"829c19511b713646e5fb78edae7341ef6da57804b3782e184d1ad31c613a4fec","src/isa/riscv/registers.rs":"6275ec3ef19195d16556c1856cb23095f25a80c31d6b429eaa749d549515a6d3","src/isa/riscv/settings.rs":"e3c063add822ca366e845f5a19d25b56635e828b157a37d29aca5355650e6a66","src/isa/stack.rs":"c391216fb8ee6566e3b14aa4bd83ba85aef2bd23422a9dca2c8c6f47016372e2","src/isa/x86/abi.rs":"6fd5cf5a42a527640fd35d1c1fb508718a8a87c694b4b8fda9d5105d874fb88f","src/isa/x86/binemit.rs":"87c1052aa245995af0fd9d0295e457d034c06ac6987dd12f8af47652406a5430","src/isa/x86/enc_tables.rs":"37190fc2ddcab2af9f252c8a9aa519c4875f042aea68fcff993956369bd51865","src/isa/x86/fde.rs":"e4e251c75e3aff6e72ce5e826500bb8670b1d188b891cfbc47913e3c6c1830d9","src/isa/x86/mod.rs":"855e4f35af9ea0c86b0b035ff939fdce40bca51f7b7eba32299e7db8fc64f8a1","src/isa/x86/registers.rs":"a0dff4534c6029444867251980ae9a79027f6a50d10ba5fcc974cd3fb3cf3a45","src/isa/x86/settings.rs":"d3e403db3507830f79bcc976c17340b57052cf1b50877fcf1a79549f2a054458","src/isa/x86/unwind.rs":"73261f403b44b11485778b7a099055223b75320ff79e332d3670791bd7ee95d0","src/iterators.rs":"d399a80bc65b97f7d650978e19086dcc1d280ac96d60628eac3d17eb363b0d71","src/legalizer/boundary.rs":"5e91e9cfdadaf3d010bc43c0374e076f0d30727cd65dd8746fe861938a4cb248","src/legalizer/call.rs":"be6074c64c1a00e5e81159dd94c8401fef62205b22c15e07e0c56cf922554d00","src/legalizer/globalvalue.rs":"59ab09a0faf593c7f228500b3fd3bacfc0412bdcb2864ec3621aa65adc4a5693","src/legalizer/heap.rs":"6f722a5ba720acdf19c58ba7c9820ea3a5b5017af3bda70adeeeb8b3c1408eb1","src/legalizer/libcall.rs":"524357d5e63b0a3fcff7e2d3c6b24be33bb50c6aae1d9771349da3fd78138204","src/legalizer/mod.rs":"6101def6213c872e46d1fb5585bfb71328f45d9b4b35b7643e188800f1da16f9","src/legalizer/split.rs":"88ef378317e5e9b4de556eed3e9e517e1e6c8d9f787ccf78d92c4fb40852f542","src/legalizer/table.rs":"c36d03525312e3191aba8ee00c26a87c1ea200f9a9a0370f0cc84eeacff71786","src/lib.rs":"c306a7aedcc183fda2c72c87129fe73829d49b80a0ed909c22732f0fd7bf1546","src/licm.rs":"2b3bf07bcfe5a54af8fb0827c1b326c7079c6eba634cc0e3569ffac81f1d27c7","src/loop_analysis.rs":"74d32e8125126adb5e06f2b9a3c6bd914b09f71be5c5bf1c344d4b3a09f7e538","src/nan_canonicalization.rs":"9619bb5554791bd1be75ecd98564d6c9f5b65132bc07c5c4d8c210cd79b66f82","src/partition_slice.rs":"861e778f887ea5d0841d730963565690fd8c298edddf08848d0d215ae5125eba","src/postopt.rs":"d4c487f0299fb905bb5a5822e38dea6f70afa4d4577288988b5bec8660bc1ba0","src/predicates.rs":"d4fa993d8b3036ac9e19d1c1d8880ab5b33030fff0a38d65e2a24b9f9d3956c9","src/print_errors.rs":"9a5f28b5d4278e3364767716ae8c3d9bbbfb2a67edbf0ae1d75fd16226797f6d","src/redundant_reload_remover.rs":"ef78df5bcf70a0958e50c924f92c091f818f38cd71aa56ad9019dfcbb913c0fa","src/regalloc/affinity.rs":"ec5d688c24043a8aa72efcfbfddc14497cd9bab288c9d339e5c0150cdade2b1d","src/regalloc/branch_splitting.rs":"b4adb8f5b67c9380c2f0a61b83528e0e4cdf44512640c65d16d7f4b3fa2bad56","src/regalloc/coalescing.rs":"b05d401e1557d5ccc1df7c98df4bf1ed9992c78ec8ba2ab001f5b3f8139da224","src/regalloc/coloring.rs":"5ecaa16a9bf3b0967d2574cbed70eb4584c21185f7c4e8383f0849962f225857","src/regalloc/context.rs":"0b3d5009c23b58cc9ccca2ece9d85dbdea52f843f52452e7813dd7a3229547d3","src/regalloc/diversion.rs":"77474469869061ed0c6eaed64ace63d1b0f648ee12d017a768f3bff1bf15f849","src/regalloc/live_value_tracker.rs":"69b8a58a5d92e13c9d33a9be0676ac6076fb2d8aa285f1d83673236ee3cbdd5a","src/regalloc/liveness.rs":"f2798904079acaa0f28f9d492d8500963939f8038974178a5b600174a769f367","src/regalloc/liverange.rs":"16a52110ba81b90cbc60620460f584b3ed2059a719eb5ab921892afbb622eb8b","src/regalloc/mod.rs":"50399d6569687a87bf1481304aca42506d946e34465e38ca8093e06485ab5fb6","src/regalloc/pressure.rs":"8408213afe07d4532da699f6604aff111c7061d71b585a84c5ec8db31582314c","src/regalloc/register_set.rs":"c740d10a061c4b8527ce319842b519d743e93e64db53851360f9ca2c099fd652","src/regalloc/reload.rs":"faff9b597e020b578e26cbbba4fd6afd6ccb6b075aa9517b3bd44b5c328e0e6f","src/regalloc/safepoint.rs":"fd69eafcc600136190b14d4d7b9fc241bcd209e1f2ff6c948dbfbf62ced68cbf","src/regalloc/solver.rs":"046c1126cdd027500449202c56383cab3fa3bdcef62f8b0167345ebbf5556802","src/regalloc/spilling.rs":"0d38722c7fe78e4429dd8f60ab591c3c4b15cd697251ba48d434e3c0f1d3ec08","src/regalloc/virtregs.rs":"a287cef413c4251856e0cc262334d5736fbfad008bb3dd7132828a961403edce","src/result.rs":"15e2aac59775ebf63adf29eb6f7d4925b0fe5868bec17cea46eccdfd4441c232","src/scoped_hash_map.rs":"c8d0071ce7e19438e9995b5fca1ea0fca81234811943b06b344331f9742c3718","src/settings.rs":"3ded159cf8bc31dda5546d45e3fadb4a841435434b758041773c25fe26f78511","src/simple_gvn.rs":"171dbcddc62f38c9fdd2b7a372b16fa231f4bc55b1971dca57d4359b078fbe6a","src/simple_preopt.rs":"402003f85f1bae5a3196226a9675fe810c860114e390da58765c4452a5ea2e49","src/stack_layout.rs":"2115c3aca4a632d62a850ff2c84382adef6f4a7d7cd0586fbff63bac9f090730","src/timing.rs":"231683891065f71a54c9c7616f7f9c5e2a7798b6d21b930cf9dbe703ad4784ed","src/topo_order.rs":"e3a9bf363c0322add1c700095bad0ea1fe97badb3349449bfdb9bf54a2b03e8b","src/unreachable_code.rs":"40cc71a02887ee4065c76ce96dda0a363a8cc134ec784fe5ed1f276db76596ce","src/value_label.rs":"f32c1ce283cfc5a6f29021428d054da0f47af9c725b6ea5f24012847760b3e2d","src/verifier/cssa.rs":"38355eaab2b998ee7a38fea12ac848060ba6d6a63ddae44b4174eb0fee1e752b","src/verifier/flags.rs":"b836c1fb636252b8b95a7958943f87ec774fae7a0ab91c61faf37096fe679707","src/verifier/liveness.rs":"a84da0cf0361b5c04110b5aa1c5afa4f184502d4cf9ba11bcfde2e65114c3d9a","src/verifier/locations.rs":"9f2adddcca2866fad86a7498ec730cdb93267b3802a16d4754e67dd0c53ab4b4","src/verifier/mod.rs":"c890ffdde05a16509ae7c78336ccfc2911834a46f5b34700bf1e7ed0ee6741f3","src/write.rs":"efb68efb20d63bd2969096838eae5ec3d6ebf5e3d85e7d503f7729216b0e91c5"},"package":null}
\ No newline at end of file
+{"files":{"Cargo.toml":"f51aedf3f1cd0a1649248748175cd5773ca62a28c62a27068e7e5fcb70cd5c69","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"e5127227a7db4a8aa92fa6613ed71801025790e696bb41b0323fb7f3c6f7495a","build.rs":"9fffedcfb42f2147f1a3f2b8d39af91e291768fe6f4e75ce19de1debfca7bfd8","src/abi.rs":"8e0d0c149007ec1bbc7128b806d184047a2b2aa8fc81ae73ac9d653e2650ff81","src/binemit/memorysink.rs":"1f30e4147a1895af875a9a1140e9f2cd7cee65526d49caa46a7f082b478adc29","src/binemit/mod.rs":"e20535245508330de50d58a247bbcf3ec4f0ef18bb63a1e935b21a30e2592fe4","src/binemit/relaxation.rs":"cdcec37e77613280f5bc89c44567ab094b51b0dc1e9f8101194527c5c015884b","src/binemit/shrink.rs":"552d64dff3b044bca77f39891d0e39ee619f6ec0669bf9917132c97becea79b0","src/binemit/stackmap.rs":"3f141f4652ec5148fbcf2db88d0ac7881823158b528c989770eacd4165afa39b","src/bitset.rs":"c4fa43fff52a8f2d343e3edbeeb26d851c64ed811e3d3aa9e2af80358d43be14","src/cfg_printer.rs":"94e6849da3c539c203d22b96f92cb3ae71aee3f0c7e8d5e7d4c8aa100d762ab6","src/constant_hash.rs":"8f53afb38891fbdab8553c7a89e61f0ce30947a22fb24ae84523c9a1ab025c3f","src/context.rs":"d47182f15327dbd775d9bbeae87439a108f8e12ac20515ee59934d059aaf5fb2","src/cursor.rs":"1c057d4e6761cce1f5da8d0d56cdfff11def969e7fab7f55dc069716ac8970aa","src/dbg.rs":"1898d94cff0975815eb348651702e95c8f2f63886501d3b7043ee75668480472","src/dce.rs":"3af68cbbc6acfa4e4f2105d9343ae62d58f61dd5746e5d24fb49f38a02636081","src/divconst_magic_numbers.rs":"e7f8f46f3a25ed7155890e9d76c10f5dde9dc5bbcebb623c8166fa415abdd959","src/dominator_tree.rs":"498d426a09ea9eddc05db9ffcbf051fe3323aa08ed7c96a09b0c193cbafbf8ee","src/flowgraph.rs":"b75da32a39580ebf5d0a9fdec73f7c6b550415cf27ca8a877af019efcd50095f","src/fx.rs":"8a5d07487906d8316a179e826fcd817a92a4860686256a6fd9d78ba47c63f330","src/ir/builder.rs":"3425957b118a0c40847ef7f473543baef5a24f0c7d8af198955180c8f297ee5a","src/ir/constant.rs":"6e9e9c82f2ded45d574d0a6029ce6cd3513b9de6329ed194ca5bab21ed1d1b9a","src/ir/dfg.rs":"1cfec6339c253258520758aec92e88998bbbe7b5c326f7f4fb0dc2431a965274","src/ir/entities.rs":"c5b3c1c15afaa694c25d5e887c3967c903879654bffcb81a978467ce7a8834f9","src/ir/extfunc.rs":"57ef6509acb504cdd292fc5a637486a1de15c78f8c9b2205ac820874592e54c4","src/ir/extname.rs":"977b2e380094e99cfdd080112bda709ca61a6d942e1e4c2015d39eaf3ea80f4c","src/ir/framelayout.rs":"c3393bcaec95df01f732164525c65843db157ed8816e0cc4b82fd9f868c31550","src/ir/function.rs":"003410fe06faacc17ae7d584a15553108ef1d7eb09c5ab0faa212b0912ee878d","src/ir/globalvalue.rs":"5a33af46e0c4b9537ef9fc422ab4fa2dc70b919b7cd6316f27b76a715361f060","src/ir/heap.rs":"a59d3e5901412b53c0b53a8cdf10765ff5921de9c410ae9acea226c89827df3c","src/ir/immediates.rs":"323ff93cb36bb682374ad323f145e61ba554f01d7ffebebe058531cbc556b91a","src/ir/instructions.rs":"5eb1ef1e66f1d14fdf046a6aa6552bbc0ac74503026e5b6d0f52a3ec2d59a660","src/ir/jumptable.rs":"184fa640957e8b0e451dc594e4b348f9aff5fb5b54ab3d856ab19df25f4f3322","src/ir/layout.rs":"7ce7d783ef98475eb2c51797df9a21ab90d39e32cb079fb5ec0eef15e13c608a","src/ir/libcall.rs":"5a9d0c4016f5308ebe8ec672f24014d80908ac03560b1cbb41731dde7ec17cef","src/ir/memflags.rs":"dbcf3798ab66dc764b73fb7f139a621c54cc6bcc683f1f70a33ed7e8c3486bfd","src/ir/mod.rs":"f35e2c11fc1750e0abf88cf442e2a8916932d4baf765050db894e53c7825c88e","src/ir/progpoint.rs":"b72b26411435d77e082da85029a94dd4e53cee1224f7f5a489edc5d905dbd4a2","src/ir/sourceloc.rs":"67c66adace734645ddf311ecb22e975f20756e07c91e10f698a830cfc2cd08aa","src/ir/stackslot.rs":"5d489d21f17c9992d0862c38c661fab2a19e025a7f29a4417d0336d9bfc5f7f0","src/ir/table.rs":"dcc3b663a989b2b084402b08dc9a0e928dbd052e194a46a1886cc6f0cf1a5f2c","src/ir/trapcode.rs":"413090e632116d405ba69f3b0e6f4460e0a67c5dfb934e11c8eebde04d8e1af5","src/ir/types.rs":"ec261b6c3677f4113a2f7125da0df3fd66a1a666aebb19abd5cb49fcef372bc6","src/ir/valueloc.rs":"fc31e06b2b0f37333829c4658b7f6fa8a717e93e18a5c67a63947e5882bbe1a2","src/isa/arm32/abi.rs":"59abc42d75445f7f3335b035655083772e98e413ee58a72fc4e224620327b5ea","src/isa/arm32/binemit.rs":"eecd7296c27d2520db8e86dd462833ecf06afd33548b03ae676c02454cdd13c2","src/isa/arm32/enc_tables.rs":"e94b12af802de59484cab1124d2ac8a88d08433f6e1a476724ed0403f4b5967f","src/isa/arm32/mod.rs":"9ccd3a24afc921f35bb89f508d86fe5eb63e86e9c85d34132a01a131e19e2f61","src/isa/arm32/registers.rs":"100033c78e2a891ad90a2765137bd678f1d11ae4ba61974d1083106fa1324037","src/isa/arm32/settings.rs":"2314460f885c24f9571d640f9737a8e0b7d20ca02bcda1127f878fd3891c0529","src/isa/arm64/abi.rs":"c946f65b7731095734074e9c06964672cdf4c8352a54fe23f7411d874b27ec28","src/isa/arm64/binemit.rs":"3afbb78f6d9ae5614d908023f84b774c0493c8757ad86fd8301baf0928bb0104","src/isa/arm64/enc_tables.rs":"73fedf7da610a982e37c76e5211dbce880f77841b71c678b0dab2b9e7217cb7c","src/isa/arm64/mod.rs":"e89bbc1d0dcbce21378fd83ef5b73071cb51b2f5561092ae960aa229accc6f53","src/isa/arm64/registers.rs":"e8bc77f218c83cedec50e2b5b28b88e3301443bd02f7a80151748f2be4b31ea0","src/isa/arm64/settings.rs":"5405ce3560b7ba0705ef525c706eb9f1593e901e1767b837c012084397639042","src/isa/call_conv.rs":"da8064a29cd3577928e3ebd3d3f869bf3dc707a4ac0f2e04d01e81770ff1aebf","src/isa/constraints.rs":"296f473a95146a743ecb73d8d5908675be02e37607efd287f55322549dc25763","src/isa/enc_tables.rs":"382e714f9500afc292c563cb66d4c963d6787e58f197b1db242db7a099c22b9a","src/isa/encoding.rs":"22e21fdb8e15859c69e4f836bb61e1a82cd6838d093ce5fe641a90f16fb65c9e","src/isa/mod.rs":"ab7319fdc633228610329a87e22e06308e310e60cd6e59e279b3076259632ab6","src/isa/registers.rs":"f09ca662be1e0beb776d050a46a8ecf7927f2bf75e36c4bda4010b442c4df815","src/isa/riscv/abi.rs":"aa60b701efcef417ee1262a95398343578dc1a30decc8e11044b74d41654ec51","src/isa/riscv/binemit.rs":"264d223da311d4482ebf2f55438b665c67b163058251bc78173c76ba983a31ef","src/isa/riscv/enc_tables.rs":"8491f2082b24c7dedeb7c36cfd913bf9aeaa0a4c8fc754166e9285f4ae002f40","src/isa/riscv/mod.rs":"fbbd48079ebd76d62a26550bd801878a0fe75a9fcca9a4cd951cf01ee74ec1ce","src/isa/riscv/registers.rs":"6275ec3ef19195d16556c1856cb23095f25a80c31d6b429eaa749d549515a6d3","src/isa/riscv/settings.rs":"e3c063add822ca366e845f5a19d25b56635e828b157a37d29aca5355650e6a66","src/isa/stack.rs":"c391216fb8ee6566e3b14aa4bd83ba85aef2bd23422a9dca2c8c6f47016372e2","src/isa/x86/abi.rs":"1fe47e753e1b79f2d7c67359f5b50958aa4137f4212415762441109c3cc3a2f9","src/isa/x86/binemit.rs":"7b1efffc790e832141845ecfccba9a28dccc75b5e27faa359d658b5ab5a2e0d3","src/isa/x86/enc_tables.rs":"9eec854cb2f6d89d68676254aee4f741b2389b997329ba5a436b759cd6d55c94","src/isa/x86/fde.rs":"78bc20ca10bfff6fcdd40c568271349bb82f7718b9030296d10c1f0fb3436fa2","src/isa/x86/mod.rs":"855e4f35af9ea0c86b0b035ff939fdce40bca51f7b7eba32299e7db8fc64f8a1","src/isa/x86/registers.rs":"a0dff4534c6029444867251980ae9a79027f6a50d10ba5fcc974cd3fb3cf3a45","src/isa/x86/settings.rs":"d3e403db3507830f79bcc976c17340b57052cf1b50877fcf1a79549f2a054458","src/isa/x86/unwind.rs":"adbc04a7b8ca398f7645b522ed5a1b7602a9ae53e8dccb1600235bc21fcac907","src/iterators.rs":"d399a80bc65b97f7d650978e19086dcc1d280ac96d60628eac3d17eb363b0d71","src/legalizer/boundary.rs":"e111ebf8f806221ac4ad19acaac10d3a41ae617b62ba4ea412be291edfb2521f","src/legalizer/call.rs":"be6074c64c1a00e5e81159dd94c8401fef62205b22c15e07e0c56cf922554d00","src/legalizer/globalvalue.rs":"59ab09a0faf593c7f228500b3fd3bacfc0412bdcb2864ec3621aa65adc4a5693","src/legalizer/heap.rs":"28c9579bf8c105e67862f405d528f02c52e7730781d19cd631a70d862dc5385c","src/legalizer/libcall.rs":"859662cfc49a479a0b0ebad401f806eb067bddbc4be01994131302c2a89a8183","src/legalizer/mod.rs":"f9c30c33bdb80d6f68d06b8e7e524f35ad25458e38b9c223beb02f5d93f8b52d","src/legalizer/split.rs":"2d01890a5c6ad6cbb2123288b6e478794042ff8922fe492fe339ea42377576cb","src/legalizer/table.rs":"c36d03525312e3191aba8ee00c26a87c1ea200f9a9a0370f0cc84eeacff71786","src/lib.rs":"c306a7aedcc183fda2c72c87129fe73829d49b80a0ed909c22732f0fd7bf1546","src/licm.rs":"75e94228c37a7d32cc9b0d51644439f9b1837768df67fd3de08ee43b8cdf8123","src/loop_analysis.rs":"bc6722c25adea6b40486ee0b1918a1325733cdd4ca4673de1bf71f8cb003cd4c","src/nan_canonicalization.rs":"dd853d0b1c1b5274513e9fb24b8beb8db877aca8fdfea5ceccbd1a80309c8842","src/partition_slice.rs":"861e778f887ea5d0841d730963565690fd8c298edddf08848d0d215ae5125eba","src/postopt.rs":"3a4f348dd529f5c948a4d9da3959ae30808af46d25b2bb6e3542044cf2e90c53","src/predicates.rs":"d4fa993d8b3036ac9e19d1c1d8880ab5b33030fff0a38d65e2a24b9f9d3956c9","src/print_errors.rs":"075b74520f47070b839b43714f55a46a7cc2697b9b0f24a7162d481b7e46b7d2","src/redundant_reload_remover.rs":"d666e536c02e51396d815d5639368d62fe359631a8117f1a874cb1debc914daf","src/regalloc/affinity.rs":"ec5d688c24043a8aa72efcfbfddc14497cd9bab288c9d339e5c0150cdade2b1d","src/regalloc/branch_splitting.rs":"32e34197f84e30cff758f4db611a9c70dd587dd8d094729c34aa00303538c0d0","src/regalloc/coalescing.rs":"84d609dc2217b94d4c92d56726cf8a003a8e648a01a290cce30952758869cd5a","src/regalloc/coloring.rs":"0ece388b44238cb6f71df5e07c283405fcfc447df0ce7cf081bd747eb3767218","src/regalloc/context.rs":"d85f86a8a79e7c939c0e696d30632ae3856001de75411828fc57c0b5b93e63ef","src/regalloc/diversion.rs":"6549c6bb2d1adb76f7e8098d97fcd84ac299a70f47e5f01683652ff2ae0e3fd1","src/regalloc/live_value_tracker.rs":"7ee59444ae7d290d617593fdc5737b572fab39b3d16ff831471f0c68038d2056","src/regalloc/liveness.rs":"cda2331bfa4c6c6dafc2db9265b05d02f91690fc00343a3c47d11d36ee2328e1","src/regalloc/liverange.rs":"72a9b58b01fbbf6c5da44510fb4944378ca2c07c0ac5ec3bd1d67870d227124d","src/regalloc/mod.rs":"50399d6569687a87bf1481304aca42506d946e34465e38ca8093e06485ab5fb6","src/regalloc/pressure.rs":"8408213afe07d4532da699f6604aff111c7061d71b585a84c5ec8db31582314c","src/regalloc/register_set.rs":"c740d10a061c4b8527ce319842b519d743e93e64db53851360f9ca2c099fd652","src/regalloc/reload.rs":"2132bd4cf45ce60b7799277d36bda35c05064ee1c60798388b8f55a0668fca47","src/regalloc/safepoint.rs":"6db80500584ef4a90b60c0f3fec82eaa15bfa26fb8ab5d929bc262d9f9b1ba38","src/regalloc/solver.rs":"5ad745ce9075ae8ca742602411f260036df4598695a4f5f0905bd91efe2c69c9","src/regalloc/spilling.rs":"5f560ec36c071279f11cc1cbe1e4acf9a14f1bc35a0708b4834e44428bcfce8e","src/regalloc/virtregs.rs":"28bf41520796c9945eb8920a98fc6f25907a4416e51cf2d49ca75e1592ec4d71","src/result.rs":"15e2aac59775ebf63adf29eb6f7d4925b0fe5868bec17cea46eccdfd4441c232","src/scoped_hash_map.rs":"c8d0071ce7e19438e9995b5fca1ea0fca81234811943b06b344331f9742c3718","src/settings.rs":"3ded159cf8bc31dda5546d45e3fadb4a841435434b758041773c25fe26f78511","src/simple_gvn.rs":"1de1d0c0e028833350eda7186243f255c9db97fe04f0e6fa688b8a710caa78be","src/simple_preopt.rs":"30ebe516a648957c724a72e912eff7fd0c694d8ab612991e5667bb22c014a857","src/stack_layout.rs":"2115c3aca4a632d62a850ff2c84382adef6f4a7d7cd0586fbff63bac9f090730","src/timing.rs":"231683891065f71a54c9c7616f7f9c5e2a7798b6d21b930cf9dbe703ad4784ed","src/topo_order.rs":"c092ee7a44e5f14962501eafd4478dfb855ce66af15d9c94a9b244ea30d6e991","src/unreachable_code.rs":"baea08a55b1e7eb2379fa2c4bb5ed4f5a536a35eafcb377f8ab79dc41d14d3d4","src/value_label.rs":"f0e430760d6489e4ee68d653def5b8cf8f9079176eea94f4e774bc69b3368e1b","src/verifier/cssa.rs":"4122c998d36a1902adb421f3caec1a82741252fae95148cd8d41f6655e6f48db","src/verifier/flags.rs":"4c790104e98c6c3a5d167fa7575551f5bf20ea8ade5c7e1f92d4d5412d8df97e","src/verifier/liveness.rs":"25e4206c20506d7501c10075dcfd259e2225a474a240a2ee9970b5e1f81f4e1f","src/verifier/locations.rs":"bac51d4b3fc86c23fda8405555af19f7df4409b7d7a6b5d08e1c42c22d192bb8","src/verifier/mod.rs":"bdfadb539ee5560b49464c52a7f16732d4deb90275845027be4b3a1346694fb5","src/write.rs":"9fe25abef4e1d60c755125e526d8f5e1a39e1e32b758520b3934b27446739faa"},"package":null}
\ No newline at end of file
--- a/third_party/rust/cranelift-codegen/Cargo.toml
+++ b/third_party/rust/cranelift-codegen/Cargo.toml
@@ -1,44 +1,44 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift-codegen"
-version = "0.56.0"
+version = "0.58.0"
 description = "Low-level code generator library"
 license = "Apache-2.0 WITH LLVM-exception"
 documentation = "https://cranelift.readthedocs.io/"
 repository = "https://github.com/bytecodealliance/cranelift"
 categories = ["no-std"]
 readme = "README.md"
 keywords = ["compile", "compiler", "jit"]
 build = "build.rs"
 edition = "2018"
 
 [dependencies]
-cranelift-codegen-shared = { path = "./shared", version = "0.56.0" }
-cranelift-entity = { path = "../cranelift-entity", version = "0.56.0" }
-cranelift-bforest = { path = "../cranelift-bforest", version = "0.56.0" }
+cranelift-codegen-shared = { path = "./shared", version = "0.58.0" }
+cranelift-entity = { path = "../cranelift-entity", version = "0.58.0" }
+cranelift-bforest = { path = "../cranelift-bforest", version = "0.58.0" }
 hashbrown = { version = "0.6", optional = true }
 target-lexicon = "0.10"
 log = { version = "0.4.6", default-features = false }
 serde = { version = "1.0.94", features = ["derive"], optional = true }
 gimli = { version = "0.20.0", default-features = false, features = ["write"], optional = true }
 smallvec = { version = "1.0.0" }
 thiserror = "1.0.4"
 byteorder = { version = "1.3.2", default-features = false }
 # It is a goal of the cranelift-codegen crate to have minimal external dependencies.
 # Please don't add any unless they are essential to the task of creating binary
 # machine code. Integration tests that need external dependencies can be
 # accomodated in `tests`.
 
 [build-dependencies]
-cranelift-codegen-meta = { path = "meta", version = "0.56.0" }
+cranelift-codegen-meta = { path = "meta", version = "0.58.0" }
 
 [features]
-default = ["std", "basic-blocks", "unwind"]
+default = ["std", "unwind"]
 
 # The "std" feature enables use of libstd. The "core" feature enables use
 # of some minimal std-like replacement libraries. At least one of these two
 # features need to be enabled.
 std = []
 
 # The "core" features enables use of "hashbrown" since core doesn't have
 # a HashMap implementation, and a workaround for Cargo #4866.
@@ -64,14 +64,11 @@ all-arch = [
     "arm32",
     "arm64",
     "riscv"
 ]
 
 # For dependent crates that want to serialize some parts of cranelift
 enable-serde = ["serde"]
 
-# Temporary feature that enforces basic block semantics.
-basic-blocks = []
-
 [badges]
 maintenance = { status = "experimental" }
 travis-ci = { repository = "bytecodealliance/cranelift" }
--- a/third_party/rust/cranelift-codegen/src/abi.rs
+++ b/third_party/rust/cranelift-codegen/src/abi.rs
@@ -130,17 +130,17 @@ pub fn legalize_args<AA: ArgAssigner>(ar
 /// the next argument is `arg` which has a different value type.
 ///
 /// The signature legalization process in `legalize_args` above can replace a single argument value
 /// with multiple arguments of smaller types. It can also change the type of an integer argument to
 /// a larger integer type, requiring the smaller value to be sign- or zero-extended.
 ///
 /// The legalizer needs to repair the values at all ABI boundaries:
 ///
-/// - Incoming function arguments to the entry EBB.
+/// - Incoming function arguments to the entry block.
 /// - Function arguments passed to a call.
 /// - Return values from a call.
 /// - Return values passed to a return instruction.
 ///
 /// The `legalize_abi_value` function helps the legalizer with the process. When the legalizer
 /// needs to pass a pre-legalized `have` argument, but the ABI argument `arg` has a different value
 /// type, `legalize_abi_value(have, arg)` tells the legalizer how to create the needed value type
 /// for the argument.
--- a/third_party/rust/cranelift-codegen/src/binemit/memorysink.rs
+++ b/third_party/rust/cranelift-codegen/src/binemit/memorysink.rs
@@ -69,18 +69,18 @@ impl<'a> MemoryCodeSink<'a> {
             traps,
             stackmaps,
         }
     }
 }
 
 /// A trait for receiving relocations for code that is emitted directly into memory.
 pub trait RelocSink {
-    /// Add a relocation referencing an EBB at the current offset.
-    fn reloc_ebb(&mut self, _: CodeOffset, _: Reloc, _: CodeOffset);
+    /// Add a relocation referencing an block at the current offset.
+    fn reloc_block(&mut self, _: CodeOffset, _: Reloc, _: CodeOffset);
 
     /// Add a relocation referencing an external symbol at the current offset.
     fn reloc_external(&mut self, _: CodeOffset, _: Reloc, _: &ExternalName, _: Addend);
 
     /// Add a relocation referencing a constant.
     fn reloc_constant(&mut self, _: CodeOffset, _: Reloc, _: ConstantOffset);
 
     /// Add a relocation referencing a jump table.
@@ -122,19 +122,19 @@ impl<'a> CodeSink for MemoryCodeSink<'a>
     fn put4(&mut self, x: u32) {
         self.write(x);
     }
 
     fn put8(&mut self, x: u64) {
         self.write(x);
     }
 
-    fn reloc_ebb(&mut self, rel: Reloc, ebb_offset: CodeOffset) {
+    fn reloc_block(&mut self, rel: Reloc, block_offset: CodeOffset) {
         let ofs = self.offset();
-        self.relocs.reloc_ebb(ofs, rel, ebb_offset);
+        self.relocs.reloc_block(ofs, rel, block_offset);
     }
 
     fn reloc_external(&mut self, rel: Reloc, name: &ExternalName, addend: Addend) {
         let ofs = self.offset();
         self.relocs.reloc_external(ofs, rel, name, addend);
     }
 
     fn reloc_constant(&mut self, rel: Reloc, constant_offset: ConstantOffset) {
@@ -172,17 +172,17 @@ impl<'a> CodeSink for MemoryCodeSink<'a>
     }
 }
 
 /// A `RelocSink` implementation that does nothing, which is convenient when
 /// compiling code that does not relocate anything.
 pub struct NullRelocSink {}
 
 impl RelocSink for NullRelocSink {
-    fn reloc_ebb(&mut self, _: u32, _: Reloc, _: u32) {}
+    fn reloc_block(&mut self, _: u32, _: Reloc, _: u32) {}
     fn reloc_external(&mut self, _: u32, _: Reloc, _: &ExternalName, _: i64) {}
     fn reloc_constant(&mut self, _: CodeOffset, _: Reloc, _: ConstantOffset) {}
     fn reloc_jt(&mut self, _: u32, _: Reloc, _: JumpTable) {}
 }
 
 /// A `TrapSink` implementation that does nothing, which is convenient when
 /// compiling code that does not rely on trapping semantics.
 pub struct NullTrapSink {}
--- a/third_party/rust/cranelift-codegen/src/binemit/mod.rs
+++ b/third_party/rust/cranelift-codegen/src/binemit/mod.rs
@@ -122,18 +122,18 @@ pub trait CodeSink {
     fn put2(&mut self, _: u16);
 
     /// Add 4 bytes to the code section.
     fn put4(&mut self, _: u32);
 
     /// Add 8 bytes to the code section.
     fn put8(&mut self, _: u64);
 
-    /// Add a relocation referencing an EBB at the current offset.
-    fn reloc_ebb(&mut self, _: Reloc, _: CodeOffset);
+    /// Add a relocation referencing an block at the current offset.
+    fn reloc_block(&mut self, _: Reloc, _: CodeOffset);
 
     /// Add a relocation referencing an external symbol plus the addend at the current offset.
     fn reloc_external(&mut self, _: Reloc, _: &ExternalName, _: Addend);
 
     /// Add a relocation referencing a constant.
     fn reloc_constant(&mut self, _: Reloc, _: ConstantOffset);
 
     /// Add a relocation referencing a jump table.
@@ -200,31 +200,31 @@ pub fn bad_encoding(func: &Function, ins
 /// This function is called from the `TargetIsa::emit_function()` implementations with the
 /// appropriate instruction emitter.
 pub fn emit_function<CS, EI>(func: &Function, emit_inst: EI, sink: &mut CS, isa: &dyn TargetIsa)
 where
     CS: CodeSink,
     EI: Fn(&Function, Inst, &mut RegDiversions, &mut CS, &dyn TargetIsa),
 {
     let mut divert = RegDiversions::new();
-    for ebb in func.layout.ebbs() {
-        divert.at_ebb(&func.entry_diversions, ebb);
-        debug_assert_eq!(func.offsets[ebb], sink.offset());
-        for inst in func.layout.ebb_insts(ebb) {
+    for block in func.layout.blocks() {
+        divert.at_block(&func.entry_diversions, block);
+        debug_assert_eq!(func.offsets[block], sink.offset());
+        for inst in func.layout.block_insts(block) {
             emit_inst(func, inst, &mut divert, sink, isa);
         }
     }
 
     sink.begin_jumptables();
 
     // Output jump tables.
     for (jt, jt_data) in func.jump_tables.iter() {
         let jt_offset = func.jt_offsets[jt];
-        for ebb in jt_data.iter() {
-            let rel_offset: i32 = func.offsets[*ebb] as i32 - jt_offset as i32;
+        for block in jt_data.iter() {
+            let rel_offset: i32 = func.offsets[*block] as i32 - jt_offset as i32;
             sink.put4(rel_offset as u32)
         }
     }
 
     sink.begin_rodata();
 
     // Output constants.
     for (_, constant_data) in func.dfg.constants.iter() {
--- a/third_party/rust/cranelift-codegen/src/binemit/relaxation.rs
+++ b/third_party/rust/cranelift-codegen/src/binemit/relaxation.rs
@@ -1,108 +1,104 @@
 //! Branch relaxation and offset computation.
 //!
-//! # EBB header offsets
+//! # block header offsets
 //!
 //! Before we can generate binary machine code for branch instructions, we need to know the final
-//! offsets of all the EBB headers in the function. This information is encoded in the
+//! offsets of all the block headers in the function. This information is encoded in the
 //! `func.offsets` table.
 //!
 //! # Branch relaxation
 //!
 //! Branch relaxation is the process of ensuring that all branches in the function have enough
 //! range to encode their destination. It is common to have multiple branch encodings in an ISA.
 //! For example, x86 branches can have either an 8-bit or a 32-bit displacement.
 //!
 //! On RISC architectures, it can happen that conditional branches have a shorter range than
 //! unconditional branches:
 //!
 //! ```clif
-//!     brz v1, ebb17
+//!     brz v1, block17
 //! ```
 //!
 //! can be transformed into:
 //!
 //! ```clif
-//!     brnz v1, ebb23
-//!     jump ebb17
-//! ebb23:
+//!     brnz v1, block23
+//!     jump block17
+//! block23:
 //! ```
 
 use crate::binemit::{CodeInfo, CodeOffset};
 use crate::cursor::{Cursor, FuncCursor};
 use crate::dominator_tree::DominatorTree;
 use crate::flowgraph::ControlFlowGraph;
-use crate::ir::{Function, InstructionData, Opcode};
+use crate::ir::{Block, Function, Inst, InstructionData, Opcode, Value, ValueList};
 use crate::isa::{EncInfo, TargetIsa};
 use crate::iterators::IteratorExtras;
 use crate::regalloc::RegDiversions;
 use crate::timing;
 use crate::CodegenResult;
 use core::convert::TryFrom;
 use log::debug;
 
-#[cfg(feature = "basic-blocks")]
-use crate::ir::{Ebb, Inst, Value, ValueList};
-
-/// Relax branches and compute the final layout of EBB headers in `func`.
+/// Relax branches and compute the final layout of block headers in `func`.
 ///
 /// Fill in the `func.offsets` table so the function is ready for binary emission.
 pub fn relax_branches(
     func: &mut Function,
     _cfg: &mut ControlFlowGraph,
     _domtree: &mut DominatorTree,
     isa: &dyn TargetIsa,
 ) -> CodegenResult<CodeInfo> {
     let _tt = timing::relax_branches();
 
     let encinfo = isa.encoding_info();
 
-    // Clear all offsets so we can recognize EBBs that haven't been visited yet.
+    // Clear all offsets so we can recognize blocks that haven't been visited yet.
     func.offsets.clear();
-    func.offsets.resize(func.dfg.num_ebbs());
+    func.offsets.resize(func.dfg.num_blocks());
 
     // Start by removing redundant jumps.
-    #[cfg(feature = "basic-blocks")]
     fold_redundant_jumps(func, _cfg, _domtree);
 
     // Convert jumps to fallthrough instructions where possible.
     fallthroughs(func);
 
     let mut offset = 0;
     let mut divert = RegDiversions::new();
 
-    // First, compute initial offsets for every EBB.
+    // First, compute initial offsets for every block.
     {
         let mut cur = FuncCursor::new(func);
-        while let Some(ebb) = cur.next_ebb() {
-            divert.at_ebb(&cur.func.entry_diversions, ebb);
-            cur.func.offsets[ebb] = offset;
+        while let Some(block) = cur.next_block() {
+            divert.at_block(&cur.func.entry_diversions, block);
+            cur.func.offsets[block] = offset;
             while let Some(inst) = cur.next_inst() {
                 divert.apply(&cur.func.dfg[inst]);
                 let enc = cur.func.encodings[inst];
                 offset += encinfo.byte_size(enc, inst, &divert, &cur.func);
             }
         }
     }
 
     // Then, run the relaxation algorithm until it converges.
     let mut go_again = true;
     while go_again {
         go_again = false;
         offset = 0;
 
         // Visit all instructions in layout order.
         let mut cur = FuncCursor::new(func);
-        while let Some(ebb) = cur.next_ebb() {
-            divert.at_ebb(&cur.func.entry_diversions, ebb);
+        while let Some(block) = cur.next_block() {
+            divert.at_block(&cur.func.entry_diversions, block);
 
-            // Record the offset for `ebb` and make sure we iterate until offsets are stable.
-            if cur.func.offsets[ebb] != offset {
-                cur.func.offsets[ebb] = offset;
+            // Record the offset for `block` and make sure we iterate until offsets are stable.
+            if cur.func.offsets[block] != offset {
+                cur.func.offsets[block] = offset;
                 go_again = true;
             }
 
             while let Some(inst) = cur.next_inst() {
                 divert.apply(&cur.func.dfg[inst]);
 
                 let enc = cur.func.encodings[inst];
 
@@ -149,46 +145,45 @@ pub fn relax_branches(
         jumptables_size,
         rodata_size,
         total_size: offset,
     })
 }
 
 /// Folds an instruction if it is a redundant jump.
 /// Returns whether folding was performed (which invalidates the CFG).
-#[cfg(feature = "basic-blocks")]
 fn try_fold_redundant_jump(
     func: &mut Function,
     cfg: &mut ControlFlowGraph,
-    ebb: Ebb,
+    block: Block,
     first_inst: Inst,
 ) -> bool {
     let first_dest = match func.dfg[first_inst].branch_destination() {
-        Some(ebb) => ebb, // The instruction was a single-target branch.
+        Some(block) => block, // The instruction was a single-target branch.
         None => {
             return false; // The instruction was either multi-target or not a branch.
         }
     };
 
-    // For the moment, only attempt to fold a branch to an ebb that is parameterless.
+    // For the moment, only attempt to fold a branch to an block that is parameterless.
     // These blocks are mainly produced by critical edge splitting.
     //
     // TODO: Allow folding blocks that define SSA values and function as phi nodes.
-    if func.dfg.num_ebb_params(first_dest) != 0 {
+    if func.dfg.num_block_params(first_dest) != 0 {
         return false;
     }
 
     // Look at the first instruction of the first branch's destination.
     // If it is an unconditional branch, maybe the second jump can be bypassed.
     let second_inst = func.layout.first_inst(first_dest).expect("Instructions");
     if func.dfg[second_inst].opcode() != Opcode::Jump {
         return false;
     }
 
-    // Now we need to fix up first_inst's ebb parameters to match second_inst's,
+    // Now we need to fix up first_inst's block parameters to match second_inst's,
     // without changing the branch-specific arguments.
     //
     // The intermediary block is allowed to reference any SSA value that dominates it,
     // but that SSA value may not necessarily also dominate the instruction that's
     // being patched.
 
     // Get the arguments and parameters passed by the first branch.
     let num_fixed = func.dfg[first_inst]
@@ -208,24 +203,24 @@ fn try_fold_redundant_jump(
         .arguments(&func.dfg.value_lists)
         .split_at(num_fixed);
     let mut second_params = second_params.to_vec(); // Clone for rewriting below.
 
     // For each parameter passed by the second jump, if any of those parameters
     // was a block parameter, rewrite it to refer to the value that the first jump
     // passed in its parameters. Otherwise, make sure it dominates first_inst.
     //
-    // For example: if we `ebb0: jump ebb1(v1)` to `ebb1(v2): jump ebb2(v2)`,
-    // we want to rewrite the original jump to `jump ebb2(v1)`.
-    let ebb_params: &[Value] = func.dfg.ebb_params(first_dest);
-    debug_assert!(ebb_params.len() == first_params.len());
+    // For example: if we `block0: jump block1(v1)` to `block1(v2): jump block2(v2)`,
+    // we want to rewrite the original jump to `jump block2(v1)`.
+    let block_params: &[Value] = func.dfg.block_params(first_dest);
+    debug_assert!(block_params.len() == first_params.len());
 
     for value in second_params.iter_mut() {
-        if let Some((n, _)) = ebb_params.iter().enumerate().find(|(_, &p)| p == *value) {
-            // This value was the Nth parameter passed to the second_inst's ebb.
+        if let Some((n, _)) = block_params.iter().enumerate().find(|(_, &p)| p == *value) {
+            // This value was the Nth parameter passed to the second_inst's block.
             // Rewrite it as the Nth parameter passed by first_inst.
             *value = first_params[n];
         }
     }
 
     // Build a value list of first_args (unchanged) followed by second_params (rewritten).
     let arguments_vec: alloc::vec::Vec<_> = first_args
         .iter()
@@ -233,84 +228,89 @@ fn try_fold_redundant_jump(
         .copied()
         .collect();
     let value_list = ValueList::from_slice(&arguments_vec, &mut func.dfg.value_lists);
 
     func.dfg[first_inst].take_value_list(); // Drop the current list.
     func.dfg[first_inst].put_value_list(value_list); // Put the new list.
 
     // Bypass the second jump.
-    // This can disconnect the Ebb containing `second_inst`, to be cleaned up later.
+    // This can disconnect the Block containing `second_inst`, to be cleaned up later.
     let second_dest = func.dfg[second_inst].branch_destination().expect("Dest");
     func.change_branch_destination(first_inst, second_dest);
-    cfg.recompute_ebb(func, ebb);
+    cfg.recompute_block(func, block);
 
-    // The previously-intermediary Ebb may now be unreachable. Update CFG.
+    // The previously-intermediary Block may now be unreachable. Update CFG.
     if cfg.pred_iter(first_dest).count() == 0 {
-        // Remove all instructions from that ebb.
+        // Remove all instructions from that block.
         while let Some(inst) = func.layout.first_inst(first_dest) {
             func.layout.remove_inst(inst);
         }
 
         // Remove the block...
-        cfg.recompute_ebb(func, first_dest); // ...from predecessor lists.
-        func.layout.remove_ebb(first_dest); // ...from the layout.
+        cfg.recompute_block(func, first_dest); // ...from predecessor lists.
+        func.layout.remove_block(first_dest); // ...from the layout.
     }
 
     true
 }
 
 /// Redirects `jump` instructions that point to other `jump` instructions to the final destination.
 /// This transformation may orphan some blocks.
-#[cfg(feature = "basic-blocks")]
 fn fold_redundant_jumps(
     func: &mut Function,
     cfg: &mut ControlFlowGraph,
     domtree: &mut DominatorTree,
 ) {
     let mut folded = false;
 
     // Postorder iteration guarantees that a chain of jumps is visited from
     // the end of the chain to the start of the chain.
-    for &ebb in domtree.cfg_postorder() {
+    for &block in domtree.cfg_postorder() {
         // Only proceed if the first terminator instruction is a single-target branch.
-        let first_inst = func.layout.last_inst(ebb).expect("Ebb has no terminator");
-        folded |= try_fold_redundant_jump(func, cfg, ebb, first_inst);
+        let first_inst = func
+            .layout
+            .last_inst(block)
+            .expect("Block has no terminator");
+        folded |= try_fold_redundant_jump(func, cfg, block, first_inst);
 
         // Also try the previous instruction.
         if let Some(prev_inst) = func.layout.prev_inst(first_inst) {
-            folded |= try_fold_redundant_jump(func, cfg, ebb, prev_inst);
+            folded |= try_fold_redundant_jump(func, cfg, block, prev_inst);
         }
     }
 
     // Folding jumps invalidates the dominator tree.
     if folded {
         domtree.compute(func, cfg);
     }
 }
 
 /// Convert `jump` instructions to `fallthrough` instructions where possible and verify that any
 /// existing `fallthrough` instructions are correct.
 fn fallthroughs(func: &mut Function) {
-    for (ebb, succ) in func.layout.ebbs().adjacent_pairs() {
-        let term = func.layout.last_inst(ebb).expect("EBB has no terminator.");
+    for (block, succ) in func.layout.blocks().adjacent_pairs() {
+        let term = func
+            .layout
+            .last_inst(block)
+            .expect("block has no terminator.");
         if let InstructionData::Jump {
             ref mut opcode,
             destination,
             ..
         } = func.dfg[term]
         {
             match *opcode {
                 Opcode::Fallthrough => {
                     // Somebody used a fall-through instruction before the branch relaxation pass.
                     // Make sure it is correct, i.e. the destination is the layout successor.
-                    debug_assert_eq!(destination, succ, "Illegal fall-through in {}", ebb)
+                    debug_assert_eq!(destination, succ, "Illegal fall-through in {}", block)
                 }
                 Opcode::Jump => {
-                    // If this is a jump to the successor EBB, change it to a fall-through.
+                    // If this is a jump to the successor block, change it to a fall-through.
                     if destination == succ {
                         *opcode = Opcode::Fallthrough;
                         func.encodings[term] = Default::default();
                     }
                 }
                 _ => {}
             }
         }
@@ -369,25 +369,25 @@ fn relax_branch(
         cur.func.encodings[inst] = enc;
         return encinfo.byte_size(enc, inst, &divert, &cur.func);
     }
 
     // Note: On some RISC ISAs, conditional branches have shorter range than unconditional
     // branches, so one way of extending the range of a conditional branch is to invert its
     // condition and make it branch over an unconditional jump which has the larger range.
     //
-    // Splitting the EBB is problematic this late because there may be register diversions in
+    // Splitting the block is problematic this late because there may be register diversions in
     // effect across the conditional branch, and they can't survive the control flow edge to a new
-    // EBB. We have two options for handling that:
+    // block. We have two options for handling that:
     //
-    // 1. Set a flag on the new EBB that indicates it wants the preserve the register diversions of
+    // 1. Set a flag on the new block that indicates it wants the preserve the register diversions of
     //    its layout predecessor, or
-    // 2. Use an encoding macro for the branch-over-jump pattern so we don't need to split the EBB.
+    // 2. Use an encoding macro for the branch-over-jump pattern so we don't need to split the block.
     //
     // It seems that 1. would allow us to share code among RISC ISAs that need this.
     //
     // We can't allow register diversions to survive from the layout predecessor because the layout
-    // predecessor could contain kill points for some values that are live in this EBB, and
+    // predecessor could contain kill points for some values that are live in this block, and
     // diversions are not automatically cancelled when the live range of a value ends.
 
     // This assumes solution 2. above:
     panic!("No branch in range for {:#x}-{:#x}", offset, dest_offset);
 }
--- a/third_party/rust/cranelift-codegen/src/binemit/shrink.rs
+++ b/third_party/rust/cranelift-codegen/src/binemit/shrink.rs
@@ -14,21 +14,21 @@ use log::debug;
 
 /// Pick the smallest valid encodings for instructions.
 pub fn shrink_instructions(func: &mut Function, isa: &dyn TargetIsa) {
     let _tt = timing::shrink_instructions();
 
     let encinfo = isa.encoding_info();
     let mut divert = RegDiversions::new();
 
-    for ebb in func.layout.ebbs() {
+    for block in func.layout.blocks() {
         // Load diversions from predecessors.
-        divert.at_ebb(&func.entry_diversions, ebb);
+        divert.at_block(&func.entry_diversions, block);
 
-        for inst in func.layout.ebb_insts(ebb) {
+        for inst in func.layout.block_insts(block) {
             let enc = func.encodings[inst];
             if enc.is_legal() {
                 // regmove/regfill/regspill are special instructions with register immediates
                 // that represented as normal operands, so the normal predicates below don't
                 // handle them correctly.
                 //
                 // Also, they need to be presented to the `RegDiversions` to update the
                 // location tracking.
--- a/third_party/rust/cranelift-codegen/src/cfg_printer.rs
+++ b/third_party/rust/cranelift-codegen/src/cfg_printer.rs
@@ -1,15 +1,15 @@
 //! The `CFGPrinter` utility.
 
 use alloc::vec::Vec;
 use core::fmt::{Display, Formatter, Result, Write};
 
 use crate::entity::SecondaryMap;
-use crate::flowgraph::{BasicBlock, ControlFlowGraph};
+use crate::flowgraph::{BlockPredecessor, ControlFlowGraph};
 use crate::ir::Function;
 use crate::write::{FuncWriter, PlainWriter};
 
 /// A utility for pretty-printing the CFG of a `Function`.
 pub struct CFGPrinter<'a> {
     func: &'a Function,
     cfg: ControlFlowGraph,
 }
@@ -22,55 +22,59 @@ impl<'a> CFGPrinter<'a> {
             func,
             cfg: ControlFlowGraph::with_function(func),
         }
     }
 
     /// Write the CFG for this function to `w`.
     pub fn write(&self, w: &mut dyn Write) -> Result {
         self.header(w)?;
-        self.ebb_nodes(w)?;
+        self.block_nodes(w)?;
         self.cfg_connections(w)?;
         writeln!(w, "}}")
     }
 
     fn header(&self, w: &mut dyn Write) -> Result {
         writeln!(w, "digraph \"{}\" {{", self.func.name)?;
         if let Some(entry) = self.func.layout.entry_block() {
             writeln!(w, "    {{rank=min; {}}}", entry)?;
         }
         Ok(())
     }
 
-    fn ebb_nodes(&self, w: &mut dyn Write) -> Result {
+    fn block_nodes(&self, w: &mut dyn Write) -> Result {
         let mut aliases = SecondaryMap::<_, Vec<_>>::new();
         for v in self.func.dfg.values() {
             // VADFS returns the immediate target of an alias
             if let Some(k) = self.func.dfg.value_alias_dest_for_serialization(v) {
                 aliases[k].push(v);
             }
         }
 
-        for ebb in &self.func.layout {
-            write!(w, "    {} [shape=record, label=\"{{", ebb)?;
-            crate::write::write_ebb_header(w, self.func, None, ebb, 4)?;
+        for block in &self.func.layout {
+            write!(w, "    {} [shape=record, label=\"{{", block)?;
+            crate::write::write_block_header(w, self.func, None, block, 4)?;
             // Add all outgoing branch instructions to the label.
-            for inst in self.func.layout.ebb_insts(ebb) {
+            for inst in self.func.layout.block_insts(block) {
                 write!(w, " | <{}>", inst)?;
                 PlainWriter.write_instruction(w, self.func, &aliases, None, inst, 0)?;
             }
             writeln!(w, "}}\"]")?
         }
         Ok(())
     }
 
     fn cfg_connections(&self, w: &mut dyn Write) -> Result {
-        for ebb in &self.func.layout {
-            for BasicBlock { ebb: parent, inst } in self.cfg.pred_iter(ebb) {
-                writeln!(w, "    {}:{} -> {}", parent, inst, ebb)?;
+        for block in &self.func.layout {
+            for BlockPredecessor {
+                block: parent,
+                inst,
+            } in self.cfg.pred_iter(block)
+            {
+                writeln!(w, "    {}:{} -> {}", parent, inst, block)?;
             }
         }
         Ok(())
     }
 }
 
 impl<'a> Display for CFGPrinter<'a> {
     fn fmt(&self, f: &mut Formatter) -> Result {
--- a/third_party/rust/cranelift-codegen/src/cursor.rs
+++ b/third_party/rust/cranelift-codegen/src/cursor.rs
@@ -8,22 +8,22 @@ use crate::isa::TargetIsa;
 /// The possible positions of a cursor.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum CursorPosition {
     /// Cursor is not pointing anywhere. No instructions can be inserted.
     Nowhere,
     /// Cursor is pointing at an existing instruction.
     /// New instructions will be inserted *before* the current instruction.
     At(ir::Inst),
-    /// Cursor is before the beginning of an EBB. No instructions can be inserted. Calling
-    /// `next_inst()` will move to the first instruction in the EBB.
-    Before(ir::Ebb),
-    /// Cursor is pointing after the end of an EBB.
-    /// New instructions will be appended to the EBB.
-    After(ir::Ebb),
+    /// Cursor is before the beginning of an block. No instructions can be inserted. Calling
+    /// `next_inst()` will move to the first instruction in the block.
+    Before(ir::Block),
+    /// Cursor is pointing after the end of an block.
+    /// New instructions will be appended to the block.
+    After(ir::Block),
 }
 
 /// All cursor types implement the `Cursor` which provides common navigation operations.
 pub trait Cursor {
     /// Get the current cursor position.
     fn position(&self) -> CursorPosition;
 
     /// Set the current position.
@@ -41,17 +41,17 @@ pub trait Cursor {
     /// Borrow a mutable reference to the function layout that this cursor is navigating.
     fn layout_mut(&mut self) -> &mut ir::Layout;
 
     /// Exchange this cursor for one with a set source location.
     ///
     /// This is intended to be used as a builder method:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb, SourceLoc};
+    /// # use cranelift_codegen::ir::{Function, Block, SourceLoc};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
     /// fn edit_func(func: &mut Function, srcloc: SourceLoc) {
     ///     let mut pos = FuncCursor::new(func).with_srcloc(srcloc);
     ///
     ///     // Use `pos`...
     /// }
     /// ```
     fn with_srcloc(mut self, srcloc: ir::SourceLoc) -> Self
@@ -71,340 +71,340 @@ pub trait Cursor {
         self
     }
 
     /// Rebuild this cursor positioned at `inst`.
     ///
     /// This is intended to be used as a builder method:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb, Inst};
+    /// # use cranelift_codegen::ir::{Function, Block, Inst};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
     /// fn edit_func(func: &mut Function, inst: Inst) {
     ///     let mut pos = FuncCursor::new(func).at_inst(inst);
     ///
     ///     // Use `pos`...
     /// }
     /// ```
     fn at_inst(mut self, inst: ir::Inst) -> Self
     where
         Self: Sized,
     {
         self.goto_inst(inst);
         self
     }
 
-    /// Rebuild this cursor positioned at the first insertion point for `ebb`.
+    /// Rebuild this cursor positioned at the first insertion point for `block`.
     /// This differs from `at_first_inst` in that it doesn't assume that any
-    /// instructions have been inserted into `ebb` yet.
+    /// instructions have been inserted into `block` yet.
     ///
     /// This is intended to be used as a builder method:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb, Inst};
+    /// # use cranelift_codegen::ir::{Function, Block, Inst};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
-    /// fn edit_func(func: &mut Function, ebb: Ebb) {
-    ///     let mut pos = FuncCursor::new(func).at_first_insertion_point(ebb);
+    /// fn edit_func(func: &mut Function, block: Block) {
+    ///     let mut pos = FuncCursor::new(func).at_first_insertion_point(block);
     ///
     ///     // Use `pos`...
     /// }
     /// ```
-    fn at_first_insertion_point(mut self, ebb: ir::Ebb) -> Self
+    fn at_first_insertion_point(mut self, block: ir::Block) -> Self
     where
         Self: Sized,
     {
-        self.goto_first_insertion_point(ebb);
+        self.goto_first_insertion_point(block);
         self
     }
 
-    /// Rebuild this cursor positioned at the first instruction in `ebb`.
+    /// Rebuild this cursor positioned at the first instruction in `block`.
     ///
     /// This is intended to be used as a builder method:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb, Inst};
+    /// # use cranelift_codegen::ir::{Function, Block, Inst};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
-    /// fn edit_func(func: &mut Function, ebb: Ebb) {
-    ///     let mut pos = FuncCursor::new(func).at_first_inst(ebb);
+    /// fn edit_func(func: &mut Function, block: Block) {
+    ///     let mut pos = FuncCursor::new(func).at_first_inst(block);
     ///
     ///     // Use `pos`...
     /// }
     /// ```
-    fn at_first_inst(mut self, ebb: ir::Ebb) -> Self
+    fn at_first_inst(mut self, block: ir::Block) -> Self
     where
         Self: Sized,
     {
-        self.goto_first_inst(ebb);
+        self.goto_first_inst(block);
         self
     }
 
-    /// Rebuild this cursor positioned at the last instruction in `ebb`.
+    /// Rebuild this cursor positioned at the last instruction in `block`.
     ///
     /// This is intended to be used as a builder method:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb, Inst};
+    /// # use cranelift_codegen::ir::{Function, Block, Inst};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
-    /// fn edit_func(func: &mut Function, ebb: Ebb) {
-    ///     let mut pos = FuncCursor::new(func).at_last_inst(ebb);
+    /// fn edit_func(func: &mut Function, block: Block) {
+    ///     let mut pos = FuncCursor::new(func).at_last_inst(block);
     ///
     ///     // Use `pos`...
     /// }
     /// ```
-    fn at_last_inst(mut self, ebb: ir::Ebb) -> Self
+    fn at_last_inst(mut self, block: ir::Block) -> Self
     where
         Self: Sized,
     {
-        self.goto_last_inst(ebb);
+        self.goto_last_inst(block);
         self
     }
 
     /// Rebuild this cursor positioned after `inst`.
     ///
     /// This is intended to be used as a builder method:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb, Inst};
+    /// # use cranelift_codegen::ir::{Function, Block, Inst};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
     /// fn edit_func(func: &mut Function, inst: Inst) {
     ///     let mut pos = FuncCursor::new(func).after_inst(inst);
     ///
     ///     // Use `pos`...
     /// }
     /// ```
     fn after_inst(mut self, inst: ir::Inst) -> Self
     where
         Self: Sized,
     {
         self.goto_after_inst(inst);
         self
     }
 
-    /// Rebuild this cursor positioned at the top of `ebb`.
+    /// Rebuild this cursor positioned at the top of `block`.
     ///
     /// This is intended to be used as a builder method:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb, Inst};
+    /// # use cranelift_codegen::ir::{Function, Block, Inst};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
-    /// fn edit_func(func: &mut Function, ebb: Ebb) {
-    ///     let mut pos = FuncCursor::new(func).at_top(ebb);
+    /// fn edit_func(func: &mut Function, block: Block) {
+    ///     let mut pos = FuncCursor::new(func).at_top(block);
     ///
     ///     // Use `pos`...
     /// }
     /// ```
-    fn at_top(mut self, ebb: ir::Ebb) -> Self
+    fn at_top(mut self, block: ir::Block) -> Self
     where
         Self: Sized,
     {
-        self.goto_top(ebb);
+        self.goto_top(block);
         self
     }
 
-    /// Rebuild this cursor positioned at the bottom of `ebb`.
+    /// Rebuild this cursor positioned at the bottom of `block`.
     ///
     /// This is intended to be used as a builder method:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb, Inst};
+    /// # use cranelift_codegen::ir::{Function, Block, Inst};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
-    /// fn edit_func(func: &mut Function, ebb: Ebb) {
-    ///     let mut pos = FuncCursor::new(func).at_bottom(ebb);
+    /// fn edit_func(func: &mut Function, block: Block) {
+    ///     let mut pos = FuncCursor::new(func).at_bottom(block);
     ///
     ///     // Use `pos`...
     /// }
     /// ```
-    fn at_bottom(mut self, ebb: ir::Ebb) -> Self
+    fn at_bottom(mut self, block: ir::Block) -> Self
     where
         Self: Sized,
     {
-        self.goto_bottom(ebb);
+        self.goto_bottom(block);
         self
     }
 
-    /// Get the EBB corresponding to the current position.
-    fn current_ebb(&self) -> Option<ir::Ebb> {
+    /// Get the block corresponding to the current position.
+    fn current_block(&self) -> Option<ir::Block> {
         use self::CursorPosition::*;
         match self.position() {
             Nowhere => None,
-            At(inst) => self.layout().inst_ebb(inst),
-            Before(ebb) | After(ebb) => Some(ebb),
+            At(inst) => self.layout().inst_block(inst),
+            Before(block) | After(block) => Some(block),
         }
     }
 
     /// Get the instruction corresponding to the current position, if any.
     fn current_inst(&self) -> Option<ir::Inst> {
         use self::CursorPosition::*;
         match self.position() {
             At(inst) => Some(inst),
             _ => None,
         }
     }
 
     /// Go to the position after a specific instruction, which must be inserted
     /// in the layout. New instructions will be inserted after `inst`.
     fn goto_after_inst(&mut self, inst: ir::Inst) {
-        debug_assert!(self.layout().inst_ebb(inst).is_some());
+        debug_assert!(self.layout().inst_block(inst).is_some());
         let new_pos = if let Some(next) = self.layout().next_inst(inst) {
             CursorPosition::At(next)
         } else {
             CursorPosition::After(
                 self.layout()
-                    .inst_ebb(inst)
+                    .inst_block(inst)
                     .expect("current instruction removed?"),
             )
         };
         self.set_position(new_pos);
     }
 
     /// Go to a specific instruction which must be inserted in the layout.
     /// New instructions will be inserted before `inst`.
     fn goto_inst(&mut self, inst: ir::Inst) {
-        debug_assert!(self.layout().inst_ebb(inst).is_some());
+        debug_assert!(self.layout().inst_block(inst).is_some());
         self.set_position(CursorPosition::At(inst));
     }
 
-    /// Go to the position for inserting instructions at the beginning of `ebb`,
+    /// Go to the position for inserting instructions at the beginning of `block`,
     /// which unlike `goto_first_inst` doesn't assume that any instructions have
-    /// been inserted into `ebb` yet.
-    fn goto_first_insertion_point(&mut self, ebb: ir::Ebb) {
-        if let Some(inst) = self.layout().first_inst(ebb) {
+    /// been inserted into `block` yet.
+    fn goto_first_insertion_point(&mut self, block: ir::Block) {
+        if let Some(inst) = self.layout().first_inst(block) {
             self.goto_inst(inst);
         } else {
-            self.goto_bottom(ebb);
+            self.goto_bottom(block);
         }
     }
 
-    /// Go to the first instruction in `ebb`.
-    fn goto_first_inst(&mut self, ebb: ir::Ebb) {
-        let inst = self.layout().first_inst(ebb).expect("Empty EBB");
+    /// Go to the first instruction in `block`.
+    fn goto_first_inst(&mut self, block: ir::Block) {
+        let inst = self.layout().first_inst(block).expect("Empty block");
         self.goto_inst(inst);
     }
 
-    /// Go to the last instruction in `ebb`.
-    fn goto_last_inst(&mut self, ebb: ir::Ebb) {
-        let inst = self.layout().last_inst(ebb).expect("Empty EBB");
+    /// Go to the last instruction in `block`.
+    fn goto_last_inst(&mut self, block: ir::Block) {
+        let inst = self.layout().last_inst(block).expect("Empty block");
         self.goto_inst(inst);
     }
 
-    /// Go to the top of `ebb` which must be inserted into the layout.
+    /// Go to the top of `block` which must be inserted into the layout.
     /// At this position, instructions cannot be inserted, but `next_inst()` will move to the first
-    /// instruction in `ebb`.
-    fn goto_top(&mut self, ebb: ir::Ebb) {
-        debug_assert!(self.layout().is_ebb_inserted(ebb));
-        self.set_position(CursorPosition::Before(ebb));
+    /// instruction in `block`.
+    fn goto_top(&mut self, block: ir::Block) {
+        debug_assert!(self.layout().is_block_inserted(block));
+        self.set_position(CursorPosition::Before(block));
     }
 
-    /// Go to the bottom of `ebb` which must be inserted into the layout.
-    /// At this position, inserted instructions will be appended to `ebb`.
-    fn goto_bottom(&mut self, ebb: ir::Ebb) {
-        debug_assert!(self.layout().is_ebb_inserted(ebb));
-        self.set_position(CursorPosition::After(ebb));
+    /// Go to the bottom of `block` which must be inserted into the layout.
+    /// At this position, inserted instructions will be appended to `block`.
+    fn goto_bottom(&mut self, block: ir::Block) {
+        debug_assert!(self.layout().is_block_inserted(block));
+        self.set_position(CursorPosition::After(block));
     }
 
-    /// Go to the top of the next EBB in layout order and return it.
+    /// Go to the top of the next block in layout order and return it.
     ///
-    /// - If the cursor wasn't pointing at anything, go to the top of the first EBB in the
+    /// - If the cursor wasn't pointing at anything, go to the top of the first block in the
     ///   function.
-    /// - If there are no more EBBs, leave the cursor pointing at nothing and return `None`.
+    /// - If there are no more blocks, leave the cursor pointing at nothing and return `None`.
     ///
     /// # Examples
     ///
-    /// The `next_ebb()` method is intended for iterating over the EBBs in layout order:
+    /// The `next_block()` method is intended for iterating over the blocks in layout order:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb};
+    /// # use cranelift_codegen::ir::{Function, Block};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
     /// fn edit_func(func: &mut Function) {
     ///     let mut cursor = FuncCursor::new(func);
-    ///     while let Some(ebb) = cursor.next_ebb() {
-    ///         // Edit ebb.
+    ///     while let Some(block) = cursor.next_block() {
+    ///         // Edit block.
     ///     }
     /// }
     /// ```
-    fn next_ebb(&mut self) -> Option<ir::Ebb> {
-        let next = if let Some(ebb) = self.current_ebb() {
-            self.layout().next_ebb(ebb)
+    fn next_block(&mut self) -> Option<ir::Block> {
+        let next = if let Some(block) = self.current_block() {
+            self.layout().next_block(block)
         } else {
             self.layout().entry_block()
         };
         self.set_position(match next {
-            Some(ebb) => CursorPosition::Before(ebb),
+            Some(block) => CursorPosition::Before(block),
             None => CursorPosition::Nowhere,
         });
         next
     }
 
-    /// Go to the bottom of the previous EBB in layout order and return it.
+    /// Go to the bottom of the previous block in layout order and return it.
     ///
-    /// - If the cursor wasn't pointing at anything, go to the bottom of the last EBB in the
+    /// - If the cursor wasn't pointing at anything, go to the bottom of the last block in the
     ///   function.
-    /// - If there are no more EBBs, leave the cursor pointing at nothing and return `None`.
+    /// - If there are no more blocks, leave the cursor pointing at nothing and return `None`.
     ///
     /// # Examples
     ///
-    /// The `prev_ebb()` method is intended for iterating over the EBBs in backwards layout order:
+    /// The `prev_block()` method is intended for iterating over the blocks in backwards layout order:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb};
+    /// # use cranelift_codegen::ir::{Function, Block};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
     /// fn edit_func(func: &mut Function) {
     ///     let mut cursor = FuncCursor::new(func);
-    ///     while let Some(ebb) = cursor.prev_ebb() {
-    ///         // Edit ebb.
+    ///     while let Some(block) = cursor.prev_block() {
+    ///         // Edit block.
     ///     }
     /// }
     /// ```
-    fn prev_ebb(&mut self) -> Option<ir::Ebb> {
-        let prev = if let Some(ebb) = self.current_ebb() {
-            self.layout().prev_ebb(ebb)
+    fn prev_block(&mut self) -> Option<ir::Block> {
+        let prev = if let Some(block) = self.current_block() {
+            self.layout().prev_block(block)
         } else {
-            self.layout().last_ebb()
+            self.layout().last_block()
         };
         self.set_position(match prev {
-            Some(ebb) => CursorPosition::After(ebb),
+            Some(block) => CursorPosition::After(block),
             None => CursorPosition::Nowhere,
         });
         prev
     }
 
-    /// Move to the next instruction in the same EBB and return it.
+    /// Move to the next instruction in the same block and return it.
     ///
-    /// - If the cursor was positioned before an EBB, go to the first instruction in that EBB.
-    /// - If there are no more instructions in the EBB, go to the `After(ebb)` position and return
+    /// - If the cursor was positioned before an block, go to the first instruction in that block.
+    /// - If there are no more instructions in the block, go to the `After(block)` position and return
     ///   `None`.
     /// - If the cursor wasn't pointing anywhere, keep doing that.
     ///
-    /// This method will never move the cursor to a different EBB.
+    /// This method will never move the cursor to a different block.
     ///
     /// # Examples
     ///
-    /// The `next_inst()` method is intended for iterating over the instructions in an EBB like
+    /// The `next_inst()` method is intended for iterating over the instructions in an block like
     /// this:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb};
+    /// # use cranelift_codegen::ir::{Function, Block};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
-    /// fn edit_ebb(func: &mut Function, ebb: Ebb) {
-    ///     let mut cursor = FuncCursor::new(func).at_top(ebb);
+    /// fn edit_block(func: &mut Function, block: Block) {
+    ///     let mut cursor = FuncCursor::new(func).at_top(block);
     ///     while let Some(inst) = cursor.next_inst() {
     ///         // Edit instructions...
     ///     }
     /// }
     /// ```
     /// The loop body can insert and remove instructions via the cursor.
     ///
     /// Iterating over all the instructions in a function looks like this:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb};
+    /// # use cranelift_codegen::ir::{Function, Block};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
     /// fn edit_func(func: &mut Function) {
     ///     let mut cursor = FuncCursor::new(func);
-    ///     while let Some(ebb) = cursor.next_ebb() {
+    ///     while let Some(block) = cursor.next_block() {
     ///         while let Some(inst) = cursor.next_inst() {
     ///             // Edit instructions...
     ///         }
     ///     }
     /// }
     /// ```
     fn next_inst(&mut self) -> Option<ir::Inst> {
         use self::CursorPosition::*;
@@ -412,104 +412,104 @@ pub trait Cursor {
             Nowhere | After(..) => None,
             At(inst) => {
                 if let Some(next) = self.layout().next_inst(inst) {
                     self.set_position(At(next));
                     Some(next)
                 } else {
                     let pos = After(
                         self.layout()
-                            .inst_ebb(inst)
+                            .inst_block(inst)
                             .expect("current instruction removed?"),
                     );
                     self.set_position(pos);
                     None
                 }
             }
-            Before(ebb) => {
-                if let Some(next) = self.layout().first_inst(ebb) {
+            Before(block) => {
+                if let Some(next) = self.layout().first_inst(block) {
                     self.set_position(At(next));
                     Some(next)
                 } else {
-                    self.set_position(After(ebb));
+                    self.set_position(After(block));
                     None
                 }
             }
         }
     }
 
-    /// Move to the previous instruction in the same EBB and return it.
+    /// Move to the previous instruction in the same block and return it.
     ///
-    /// - If the cursor was positioned after an EBB, go to the last instruction in that EBB.
-    /// - If there are no more instructions in the EBB, go to the `Before(ebb)` position and return
+    /// - If the cursor was positioned after an block, go to the last instruction in that block.
+    /// - If there are no more instructions in the block, go to the `Before(block)` position and return
     ///   `None`.
     /// - If the cursor wasn't pointing anywhere, keep doing that.
     ///
-    /// This method will never move the cursor to a different EBB.
+    /// This method will never move the cursor to a different block.
     ///
     /// # Examples
     ///
     /// The `prev_inst()` method is intended for iterating backwards over the instructions in an
-    /// EBB like this:
+    /// block like this:
     ///
     /// ```
-    /// # use cranelift_codegen::ir::{Function, Ebb};
+    /// # use cranelift_codegen::ir::{Function, Block};
     /// # use cranelift_codegen::cursor::{Cursor, FuncCursor};
-    /// fn edit_ebb(func: &mut Function, ebb: Ebb) {
-    ///     let mut cursor = FuncCursor::new(func).at_bottom(ebb);
+    /// fn edit_block(func: &mut Function, block: Block) {
+    ///     let mut cursor = FuncCursor::new(func).at_bottom(block);
     ///     while let Some(inst) = cursor.prev_inst() {
     ///         // Edit instructions...
     ///     }
     /// }
     /// ```
     fn prev_inst(&mut self) -> Option<ir::Inst> {
         use self::CursorPosition::*;
         match self.position() {
             Nowhere | Before(..) => None,
             At(inst) => {
                 if let Some(prev) = self.layout().prev_inst(inst) {
                     self.set_position(At(prev));
                     Some(prev)
                 } else {
                     let pos = Before(
                         self.layout()
-                            .inst_ebb(inst)
+                            .inst_block(inst)
                             .expect("current instruction removed?"),
                     );
                     self.set_position(pos);
                     None
                 }
             }
-            After(ebb) => {
-                if let Some(prev) = self.layout().last_inst(ebb) {
+            After(block) => {
+                if let Some(prev) = self.layout().last_inst(block) {
                     self.set_position(At(prev));
                     Some(prev)
                 } else {
-                    self.set_position(Before(ebb));
+                    self.set_position(Before(block));
                     None
                 }
             }
         }
     }
 
     /// Insert an instruction at the current position.
     ///
     /// - If pointing at an instruction, the new instruction is inserted before the current
     ///   instruction.
-    /// - If pointing at the bottom of an EBB, the new instruction is appended to the EBB.
+    /// - If pointing at the bottom of an block, the new instruction is appended to the block.
     /// - Otherwise panic.
     ///
     /// In either case, the cursor is not moved, such that repeated calls to `insert_inst()` causes
-    /// instructions to appear in insertion order in the EBB.
+    /// instructions to appear in insertion order in the block.
     fn insert_inst(&mut self, inst: ir::Inst) {
         use self::CursorPosition::*;
         match self.position() {
             Nowhere | Before(..) => panic!("Invalid insert_inst position"),
             At(cur) => self.layout_mut().insert_inst(inst, cur),
-            After(ebb) => self.layout_mut().append_inst(inst, ebb),
+            After(block) => self.layout_mut().append_inst(inst, block),
         }
     }
 
     /// Remove the instruction under the cursor.
     ///
     /// The cursor is left pointing at the position following the current instruction.
     ///
     /// Return the instruction that was removed.
@@ -527,44 +527,44 @@ pub trait Cursor {
     /// Return the instruction that was removed.
     fn remove_inst_and_step_back(&mut self) -> ir::Inst {
         let inst = self.current_inst().expect("No instruction to remove");
         self.prev_inst();
         self.layout_mut().remove_inst(inst);
         inst
     }
 
-    /// Insert an EBB at the current position and switch to it.
+    /// Insert an block at the current position and switch to it.
     ///
-    /// As far as possible, this method behaves as if the EBB header were an instruction inserted
+    /// As far as possible, this method behaves as if the block header were an instruction inserted
     /// at the current position.
     ///
-    /// - If the cursor is pointing at an existing instruction, *the current EBB is split in two*
-    ///   and the current instruction becomes the first instruction in the inserted EBB.
-    /// - If the cursor points at the bottom of an EBB, the new EBB is inserted after the current
-    ///   one, and moved to the bottom of the new EBB where instructions can be appended.
-    /// - If the cursor points to the top of an EBB, the new EBB is inserted above the current one.
-    /// - If the cursor is not pointing at anything, the new EBB is placed last in the layout.
+    /// - If the cursor is pointing at an existing instruction, *the current block is split in two*
+    ///   and the current instruction becomes the first instruction in the inserted block.
+    /// - If the cursor points at the bottom of an block, the new block is inserted after the current
+    ///   one, and moved to the bottom of the new block where instructions can be appended.
+    /// - If the cursor points to the top of an block, the new block is inserted above the current one.
+    /// - If the cursor is not pointing at anything, the new block is placed last in the layout.
     ///
     /// This means that it is always valid to call this method, and it always leaves the cursor in
-    /// a state that will insert instructions into the new EBB.
-    fn insert_ebb(&mut self, new_ebb: ir::Ebb) {
+    /// a state that will insert instructions into the new block.
+    fn insert_block(&mut self, new_block: ir::Block) {
         use self::CursorPosition::*;
         match self.position() {
             At(inst) => {
-                self.layout_mut().split_ebb(new_ebb, inst);
-                // All other cases move to `After(ebb)`, but in this case we'll stay `At(inst)`.
+                self.layout_mut().split_block(new_block, inst);
+                // All other cases move to `After(block)`, but in this case we'll stay `At(inst)`.
                 return;
             }
-            Nowhere => self.layout_mut().append_ebb(new_ebb),
-            Before(ebb) => self.layout_mut().insert_ebb(new_ebb, ebb),
-            After(ebb) => self.layout_mut().insert_ebb_after(new_ebb, ebb),
+            Nowhere => self.layout_mut().append_block(new_block),
+            Before(block) => self.layout_mut().insert_block(new_block, block),
+            After(block) => self.layout_mut().insert_block_after(new_block, block),
         }
-        // For everything but `At(inst)` we end up appending to the new EBB.
-        self.set_position(After(new_ebb));
+        // For everything but `At(inst)` we end up appending to the new block.
+        self.set_position(After(new_block));
     }
 }
 
 /// Function cursor.
 ///
 /// A `FuncCursor` holds a mutable reference to a whole `ir::Function` while keeping a position
 /// too. The function can be re-borrowed by accessing the public `cur.func` member.
 ///
@@ -631,17 +631,16 @@ impl<'c, 'f> ir::InstInserterBase<'c> fo
     }
 
     fn data_flow_graph_mut(&mut self) -> &mut ir::DataFlowGraph {
         &mut self.func.dfg
     }
 
     fn insert_built_inst(self, inst: ir::Inst, _: ir::Type) -> &'c mut ir::DataFlowGraph {
         // TODO: Remove this assertion once #796 is fixed.
-        #[cfg(feature = "basic-blocks")]
         #[cfg(debug_assertions)]
         {
             if let CursorPosition::At(_) = self.position() {
                 if let Some(curr) = self.current_inst() {
                     if let Some(prev) = self.layout().prev_inst(curr) {
                         let prev_op = self.data_flow_graph()[prev].opcode();
                         let inst_op = self.data_flow_graph()[inst].opcode();
                         let curr_op = self.data_flow_graph()[curr].opcode();
@@ -761,17 +760,16 @@ impl<'c, 'f> ir::InstInserterBase<'c> fo
     }
 
     fn insert_built_inst(
         self,
         inst: ir::Inst,
         ctrl_typevar: ir::Type,
     ) -> &'c mut ir::DataFlowGraph {
         // TODO: Remove this assertion once #796 is fixed.
-        #[cfg(feature = "basic-blocks")]
         #[cfg(debug_assertions)]
         {
             if let CursorPosition::At(_) = self.position() {
                 if let Some(curr) = self.current_inst() {
                     if let Some(prev) = self.layout().prev_inst(curr) {
                         let prev_op = self.data_flow_graph()[prev].opcode();
                         let inst_op = self.data_flow_graph()[inst].opcode();
                         if prev_op.is_branch()
--- a/third_party/rust/cranelift-codegen/src/dce.rs
+++ b/third_party/rust/cranelift-codegen/src/dce.rs
@@ -41,18 +41,18 @@ fn is_load_with_defined_trapping(opcode:
 }
 
 /// Perform DCE on `func`.
 pub fn do_dce(func: &mut Function, domtree: &mut DominatorTree) {
     let _tt = timing::dce();
     debug_assert!(domtree.is_valid());
 
     let mut live = vec![false; func.dfg.num_values()];
-    for &ebb in domtree.cfg_postorder() {
-        let mut pos = FuncCursor::new(func).at_bottom(ebb);
+    for &block in domtree.cfg_postorder() {
+        let mut pos = FuncCursor::new(func).at_bottom(block);
         while let Some(inst) = pos.prev_inst() {
             {
                 let data = &pos.func.dfg[inst];
                 let opcode = data.opcode();
                 if trivially_unsafe_for_dce(opcode)
                     || is_load_with_defined_trapping(opcode, &data)
                     || any_inst_results_used(inst, &live, &pos.func.dfg)
                 {
--- a/third_party/rust/cranelift-codegen/src/dominator_tree.rs
+++ b/third_party/rust/cranelift-codegen/src/dominator_tree.rs
@@ -1,214 +1,216 @@
-//! A Dominator Tree represented as mappings of Ebbs to their immediate dominator.
+//! A Dominator Tree represented as mappings of Blocks to their immediate dominator.
 
 use crate::entity::SecondaryMap;
-use crate::flowgraph::{BasicBlock, ControlFlowGraph};
+use crate::flowgraph::{BlockPredecessor, ControlFlowGraph};
 use crate::ir::instructions::BranchInfo;
-use crate::ir::{Ebb, ExpandedProgramPoint, Function, Inst, Layout, ProgramOrder, Value};
+use crate::ir::{Block, ExpandedProgramPoint, Function, Inst, Layout, ProgramOrder, Value};
 use crate::packed_option::PackedOption;
 use crate::timing;
 use alloc::vec::Vec;
 use core::cmp;
 use core::cmp::Ordering;
 use core::mem;
 
 /// RPO numbers are not first assigned in a contiguous way but as multiples of STRIDE, to leave
 /// room for modifications of the dominator tree.
 const STRIDE: u32 = 4;
 
 /// Special RPO numbers used during `compute_postorder`.
 const DONE: u32 = 1;
 const SEEN: u32 = 2;
 
-/// Dominator tree node. We keep one of these per EBB.
+/// Dominator tree node. We keep one of these per block.
 #[derive(Clone, Default)]
 struct DomNode {
     /// Number of this node in a reverse post-order traversal of the CFG, starting from 1.
     /// This number is monotonic in the reverse postorder but not contiguous, since we leave
     /// holes for later localized modifications of the dominator tree.
     /// Unreachable nodes get number 0, all others are positive.
     rpo_number: u32,
 
-    /// The immediate dominator of this EBB, represented as the branch or jump instruction at the
+    /// The immediate dominator of this block, represented as the branch or jump instruction at the
     /// end of the dominating basic block.
     ///
     /// This is `None` for unreachable blocks and the entry block which doesn't have an immediate
     /// dominator.
     idom: PackedOption<Inst>,
 }
 
 /// The dominator tree for a single function.
 pub struct DominatorTree {
-    nodes: SecondaryMap<Ebb, DomNode>,
+    nodes: SecondaryMap<Block, DomNode>,
 
-    /// CFG post-order of all reachable EBBs.
-    postorder: Vec<Ebb>,
+    /// CFG post-order of all reachable blocks.
+    postorder: Vec<Block>,
 
     /// Scratch memory used by `compute_postorder()`.
-    stack: Vec<Ebb>,
+    stack: Vec<Block>,
 
     valid: bool,
 }
 
 /// Methods for querying the dominator tree.
 impl DominatorTree {
-    /// Is `ebb` reachable from the entry block?
-    pub fn is_reachable(&self, ebb: Ebb) -> bool {
-        self.nodes[ebb].rpo_number != 0
+    /// Is `block` reachable from the entry block?
+    pub fn is_reachable(&self, block: Block) -> bool {
+        self.nodes[block].rpo_number != 0
     }
 
-    /// Get the CFG post-order of EBBs that was used to compute the dominator tree.
+    /// Get the CFG post-order of blocks that was used to compute the dominator tree.
     ///
     /// Note that this post-order is not updated automatically when the CFG is modified. It is
     /// computed from scratch and cached by `compute()`.
-    pub fn cfg_postorder(&self) -> &[Ebb] {
+    pub fn cfg_postorder(&self) -> &[Block] {
         debug_assert!(self.is_valid());
         &self.postorder
     }
 
-    /// Returns the immediate dominator of `ebb`.
+    /// Returns the immediate dominator of `block`.
     ///
-    /// The immediate dominator of an extended basic block is a basic block which we represent by
+    /// The immediate dominator of a basic block is a basic block which we represent by
     /// the branch or jump instruction at the end of the basic block. This does not have to be the
-    /// terminator of its EBB.
+    /// terminator of its block.
     ///
-    /// A branch or jump is said to *dominate* `ebb` if all control flow paths from the function
-    /// entry to `ebb` must go through the branch.
+    /// A branch or jump is said to *dominate* `block` if all control flow paths from the function
+    /// entry to `block` must go through the branch.
     ///
-    /// The *immediate dominator* is the dominator that is closest to `ebb`. All other dominators
+    /// The *immediate dominator* is the dominator that is closest to `block`. All other dominators
     /// also dominate the immediate dominator.
     ///
-    /// This returns `None` if `ebb` is not reachable from the entry EBB, or if it is the entry EBB
+    /// This returns `None` if `block` is not reachable from the entry block, or if it is the entry block
     /// which has no dominators.
-    pub fn idom(&self, ebb: Ebb) -> Option<Inst> {
-        self.nodes[ebb].idom.into()
+    pub fn idom(&self, block: Block) -> Option<Inst> {
+        self.nodes[block].idom.into()
     }
 
-    /// Compare two EBBs relative to the reverse post-order.
-    fn rpo_cmp_ebb(&self, a: Ebb, b: Ebb) -> Ordering {
+    /// Compare two blocks relative to the reverse post-order.
+    fn rpo_cmp_block(&self, a: Block, b: Block) -> Ordering {
         self.nodes[a].rpo_number.cmp(&self.nodes[b].rpo_number)
     }
 
     /// Compare two program points relative to a reverse post-order traversal of the control-flow
     /// graph.
     ///
     /// Return `Ordering::Less` if `a` comes before `b` in the RPO.
     ///
-    /// If `a` and `b` belong to the same EBB, compare their relative position in the EBB.
+    /// If `a` and `b` belong to the same block, compare their relative position in the block.
     pub fn rpo_cmp<A, B>(&self, a: A, b: B, layout: &Layout) -> Ordering
     where
         A: Into<ExpandedProgramPoint>,
         B: Into<ExpandedProgramPoint>,
     {
         let a = a.into();
         let b = b.into();
-        self.rpo_cmp_ebb(layout.pp_ebb(a), layout.pp_ebb(b))
+        self.rpo_cmp_block(layout.pp_block(a), layout.pp_block(b))
             .then(layout.cmp(a, b))
     }
 
     /// Returns `true` if `a` dominates `b`.
     ///
     /// This means that every control-flow path from the function entry to `b` must go through `a`.
     ///
     /// Dominance is ill defined for unreachable blocks. This function can always determine
-    /// dominance for instructions in the same EBB, but otherwise returns `false` if either block
+    /// dominance for instructions in the same block, but otherwise returns `false` if either block
     /// is unreachable.
     ///
     /// An instruction is considered to dominate itself.
     pub fn dominates<A, B>(&self, a: A, b: B, layout: &Layout) -> bool
     where
         A: Into<ExpandedProgramPoint>,
         B: Into<ExpandedProgramPoint>,
     {
         let a = a.into();
         let b = b.into();
         match a {
-            ExpandedProgramPoint::Ebb(ebb_a) => {
-                a == b || self.last_dominator(ebb_a, b, layout).is_some()
+            ExpandedProgramPoint::Block(block_a) => {
+                a == b || self.last_dominator(block_a, b, layout).is_some()
             }
             ExpandedProgramPoint::Inst(inst_a) => {
-                let ebb_a = layout.inst_ebb(inst_a).expect("Instruction not in layout.");
-                match self.last_dominator(ebb_a, b, layout) {
+                let block_a = layout
+                    .inst_block(inst_a)
+                    .expect("Instruction not in layout.");
+                match self.last_dominator(block_a, b, layout) {
                     Some(last) => layout.cmp(inst_a, last) != Ordering::Greater,
                     None => false,
                 }
             }
         }
     }
 
     /// Find the last instruction in `a` that dominates `b`.
     /// If no instructions in `a` dominate `b`, return `None`.
-    pub fn last_dominator<B>(&self, a: Ebb, b: B, layout: &Layout) -> Option<Inst>
+    pub fn last_dominator<B>(&self, a: Block, b: B, layout: &Layout) -> Option<Inst>
     where
         B: Into<ExpandedProgramPoint>,
     {
-        let (mut ebb_b, mut inst_b) = match b.into() {
-            ExpandedProgramPoint::Ebb(ebb) => (ebb, None),
+        let (mut block_b, mut inst_b) = match b.into() {
+            ExpandedProgramPoint::Block(block) => (block, None),
             ExpandedProgramPoint::Inst(inst) => (
-                layout.inst_ebb(inst).expect("Instruction not in layout."),
+                layout.inst_block(inst).expect("Instruction not in layout."),
                 Some(inst),
             ),
         };
         let rpo_a = self.nodes[a].rpo_number;
 
         // Run a finger up the dominator tree from b until we see a.
         // Do nothing if b is unreachable.
-        while rpo_a < self.nodes[ebb_b].rpo_number {
-            let idom = match self.idom(ebb_b) {
+        while rpo_a < self.nodes[block_b].rpo_number {
+            let idom = match self.idom(block_b) {
                 Some(idom) => idom,
                 None => return None, // a is unreachable, so we climbed past the entry
             };
-            ebb_b = layout.inst_ebb(idom).expect("Dominator got removed.");
+            block_b = layout.inst_block(idom).expect("Dominator got removed.");
             inst_b = Some(idom);
         }
-        if a == ebb_b {
+        if a == block_b {
             inst_b
         } else {
             None
         }
     }
 
     /// Compute the common dominator of two basic blocks.
     ///
     /// Both basic blocks are assumed to be reachable.
     pub fn common_dominator(
         &self,
-        mut a: BasicBlock,
-        mut b: BasicBlock,
+        mut a: BlockPredecessor,
+        mut b: BlockPredecessor,
         layout: &Layout,
-    ) -> BasicBlock {
+    ) -> BlockPredecessor {
         loop {
-            match self.rpo_cmp_ebb(a.ebb, b.ebb) {
+            match self.rpo_cmp_block(a.block, b.block) {
                 Ordering::Less => {
                     // `a` comes before `b` in the RPO. Move `b` up.
-                    let idom = self.nodes[b.ebb].idom.expect("Unreachable basic block?");
-                    b = BasicBlock::new(
-                        layout.inst_ebb(idom).expect("Dangling idom instruction"),
+                    let idom = self.nodes[b.block].idom.expect("Unreachable basic block?");
+                    b = BlockPredecessor::new(
+                        layout.inst_block(idom).expect("Dangling idom instruction"),
                         idom,
                     );
                 }
                 Ordering::Greater => {
                     // `b` comes before `a` in the RPO. Move `a` up.
-                    let idom = self.nodes[a.ebb].idom.expect("Unreachable basic block?");
-                    a = BasicBlock::new(
-                        layout.inst_ebb(idom).expect("Dangling idom instruction"),
+                    let idom = self.nodes[a.block].idom.expect("Unreachable basic block?");
+                    a = BlockPredecessor::new(
+                        layout.inst_block(idom).expect("Dangling idom instruction"),
                         idom,
                     );
                 }
                 Ordering::Equal => break,
             }
         }
 
         debug_assert_eq!(
-            a.ebb, b.ebb,
+            a.block, b.block,
             "Unreachable block passed to common_dominator?"
         );
 
-        // We're in the same EBB. The common dominator is the earlier instruction.
+        // We're in the same block. The common dominator is the earlier instruction.
         if layout.cmp(a.inst, b.inst) == Ordering::Less {
             a
         } else {
             b
         }
     }
 }
 
@@ -221,20 +223,20 @@ impl DominatorTree {
             postorder: Vec::new(),
             stack: Vec::new(),
             valid: false,
         }
     }
 
     /// Allocate and compute a dominator tree.
     pub fn with_function(func: &Function, cfg: &ControlFlowGraph) -> Self {
-        let ebb_capacity = func.layout.ebb_capacity();
+        let block_capacity = func.layout.block_capacity();
         let mut domtree = Self {
-            nodes: SecondaryMap::with_capacity(ebb_capacity),
-            postorder: Vec::with_capacity(ebb_capacity),
+            nodes: SecondaryMap::with_capacity(block_capacity),
+            postorder: Vec::with_capacity(block_capacity),
             stack: Vec::new(),
             valid: false,
         };
         domtree.compute(func, cfg);
         domtree
     }
 
     /// Reset and compute a CFG post-order and dominator tree.
@@ -261,222 +263,222 @@ impl DominatorTree {
     /// `compute()` method has been called since the last `clear()`. It does not check that the
     /// dominator tree is consistent with the CFG.
     pub fn is_valid(&self) -> bool {
         self.valid
     }
 
     /// Reset all internal data structures and compute a post-order of the control flow graph.
     ///
-    /// This leaves `rpo_number == 1` for all reachable EBBs, 0 for unreachable ones.
+    /// This leaves `rpo_number == 1` for all reachable blocks, 0 for unreachable ones.
     fn compute_postorder(&mut self, func: &Function) {
         self.clear();
-        self.nodes.resize(func.dfg.num_ebbs());
+        self.nodes.resize(func.dfg.num_blocks());
 
         // This algorithm is a depth first traversal (DFT) of the control flow graph, computing a
-        // post-order of the EBBs that are reachable form the entry block. A DFT post-order is not
+        // post-order of the blocks that are reachable form the entry block. A DFT post-order is not
         // unique. The specific order we get is controlled by two factors:
         //
         // 1. The order each node's children are visited, and
         // 2. The method used for pruning graph edges to get a tree.
         //
         // There are two ways of viewing the CFG as a graph:
         //
-        // 1. Each EBB is a node, with outgoing edges for all the branches in the EBB.
+        // 1. Each block is a node, with outgoing edges for all the branches in the block.
         // 2. Each basic block is a node, with outgoing edges for the single branch at the end of
-        //    the BB. (An EBB is a linear sequence of basic blocks).
+        //    the BB. (An block is a linear sequence of basic blocks).
         //
-        // The first graph is a contraction of the second one. We want to compute an EBB post-order
+        // The first graph is a contraction of the second one. We want to compute an block post-order
         // that is compatible both graph interpretations. That is, if you compute a BB post-order
-        // and then remove those BBs that do not correspond to EBB headers, you get a post-order of
-        // the EBB graph.
+        // and then remove those BBs that do not correspond to block headers, you get a post-order of
+        // the block graph.
         //
         // Node child order:
         //
         //     In the BB graph, we always go down the fall-through path first and follow the branch
         //     destination second.
         //
-        //     In the EBB graph, this is equivalent to visiting EBB successors in a bottom-up
-        //     order, starting from the destination of the EBB's terminating jump, ending at the
-        //     destination of the first branch in the EBB.
+        //     In the block graph, this is equivalent to visiting block successors in a bottom-up
+        //     order, starting from the destination of the block's terminating jump, ending at the
+        //     destination of the first branch in the block.
         //
         // Edge pruning:
         //
-        //     In the BB graph, we keep an edge to an EBB the first time we visit the *source* side
-        //     of the edge. Any subsequent edges to the same EBB are pruned.
+        //     In the BB graph, we keep an edge to an block the first time we visit the *source* side
+        //     of the edge. Any subsequent edges to the same block are pruned.
         //
-        //     The equivalent tree is reached in the EBB graph by keeping the first edge to an EBB
+        //     The equivalent tree is reached in the block graph by keeping the first edge to an block
         //     in a top-down traversal of the successors. (And then visiting edges in a bottom-up
         //     order).
         //
         // This pruning method makes it possible to compute the DFT without storing lots of
-        // information about the progress through an EBB.
+        // information about the progress through an block.
 
         // During this algorithm only, use `rpo_number` to hold the following state:
         //
-        //   0:    EBB has not yet been reached in the pre-order.
-        //   SEEN: EBB has been pushed on the stack but successors not yet pushed.
+        //   0:    block has not yet been reached in the pre-order.
+        //   SEEN: block has been pushed on the stack but successors not yet pushed.
         //   DONE: Successors pushed.
 
         match func.layout.entry_block() {
-            Some(ebb) => {
-                self.stack.push(ebb);
-                self.nodes[ebb].rpo_number = SEEN;
+            Some(block) => {
+                self.stack.push(block);
+                self.nodes[block].rpo_number = SEEN;
             }
             None => return,
         }
 
-        while let Some(ebb) = self.stack.pop() {
-            match self.nodes[ebb].rpo_number {
+        while let Some(block) = self.stack.pop() {
+            match self.nodes[block].rpo_number {
                 SEEN => {
-                    // This is the first time we pop the EBB, so we need to scan its successors and
+                    // This is the first time we pop the block, so we need to scan its successors and
                     // then revisit it.
-                    self.nodes[ebb].rpo_number = DONE;
-                    self.stack.push(ebb);
-                    self.push_successors(func, ebb);
+                    self.nodes[block].rpo_number = DONE;
+                    self.stack.push(block);
+                    self.push_successors(func, block);
                 }
                 DONE => {
-                    // This is the second time we pop the EBB, so all successors have been
+                    // This is the second time we pop the block, so all successors have been
                     // processed.
-                    self.postorder.push(ebb);
+                    self.postorder.push(block);
                 }
                 _ => unreachable!(),
             }
         }
     }
 
-    /// Push `ebb` successors onto `self.stack`, filtering out those that have already been seen.
+    /// Push `block` successors onto `self.stack`, filtering out those that have already been seen.
     ///
     /// The successors are pushed in program order which is important to get a split-invariant
-    /// post-order. Split-invariant means that if an EBB is split in two, we get the same
-    /// post-order except for the insertion of the new EBB header at the split point.
-    fn push_successors(&mut self, func: &Function, ebb: Ebb) {
-        for inst in func.layout.ebb_insts(ebb) {
+    /// post-order. Split-invariant means that if an block is split in two, we get the same
+    /// post-order except for the insertion of the new block header at the split point.
+    fn push_successors(&mut self, func: &Function, block: Block) {
+        for inst in func.layout.block_insts(block) {
             match func.dfg.analyze_branch(inst) {
                 BranchInfo::SingleDest(succ, _) => self.push_if_unseen(succ),
                 BranchInfo::Table(jt, dest) => {
                     for succ in func.jump_tables[jt].iter() {
                         self.push_if_unseen(*succ);
                     }
                     if let Some(dest) = dest {
                         self.push_if_unseen(dest);
                     }
                 }
                 BranchInfo::NotABranch => {}
             }
         }
     }
 
-    /// Push `ebb` onto `self.stack` if it has not already been seen.
-    fn push_if_unseen(&mut self, ebb: Ebb) {
-        if self.nodes[ebb].rpo_number == 0 {
-            self.nodes[ebb].rpo_number = SEEN;
-            self.stack.push(ebb);
+    /// Push `block` onto `self.stack` if it has not already been seen.
+    fn push_if_unseen(&mut self, block: Block) {
+        if self.nodes[block].rpo_number == 0 {
+            self.nodes[block].rpo_number = SEEN;
+            self.stack.push(block);
         }
     }
 
     /// Build a dominator tree from a control flow graph using Keith D. Cooper's
     /// "Simple, Fast Dominator Algorithm."
     fn compute_domtree(&mut self, func: &Function, cfg: &ControlFlowGraph) {
         // During this algorithm, `rpo_number` has the following values:
         //
-        // 0: EBB is not reachable.
-        // 1: EBB is reachable, but has not yet been visited during the first pass. This is set by
+        // 0: block is not reachable.
+        // 1: block is reachable, but has not yet been visited during the first pass. This is set by
         // `compute_postorder`.
-        // 2+: EBB is reachable and has an assigned RPO number.
+        // 2+: block is reachable and has an assigned RPO number.
 
         // We'll be iterating over a reverse post-order of the CFG, skipping the entry block.
         let (entry_block, postorder) = match self.postorder.as_slice().split_last() {
             Some((&eb, rest)) => (eb, rest),
             None => return,
         };
         debug_assert_eq!(Some(entry_block), func.layout.entry_block());
 
         // Do a first pass where we assign RPO numbers to all reachable nodes.
         self.nodes[entry_block].rpo_number = 2 * STRIDE;
-        for (rpo_idx, &ebb) in postorder.iter().rev().enumerate() {
+        for (rpo_idx, &block) in postorder.iter().rev().enumerate() {
             // Update the current node and give it an RPO number.
             // The entry block got 2, the rest start at 3 by multiples of STRIDE to leave
             // room for future dominator tree modifications.
             //
             // Since `compute_idom` will only look at nodes with an assigned RPO number, the
             // function will never see an uninitialized predecessor.
             //
             // Due to the nature of the post-order traversal, every node we visit will have at
             // least one predecessor that has previously been visited during this RPO.
-            self.nodes[ebb] = DomNode {
-                idom: self.compute_idom(ebb, cfg, &func.layout).into(),
+            self.nodes[block] = DomNode {
+                idom: self.compute_idom(block, cfg, &func.layout).into(),
                 rpo_number: (rpo_idx as u32 + 3) * STRIDE,
             }
         }
 
         // Now that we have RPO numbers for everything and initial immediate dominator estimates,
         // iterate until convergence.
         //
         // If the function is free of irreducible control flow, this will exit after one iteration.
         let mut changed = true;
         while changed {
             changed = false;
-            for &ebb in postorder.iter().rev() {
-                let idom = self.compute_idom(ebb, cfg, &func.layout).into();
-                if self.nodes[ebb].idom != idom {
-                    self.nodes[ebb].idom = idom;
+            for &block in postorder.iter().rev() {
+                let idom = self.compute_idom(block, cfg, &func.layout).into();
+                if self.nodes[block].idom != idom {
+                    self.nodes[block].idom = idom;
                     changed = true;
                 }
             }
         }
     }
 
-    // Compute the immediate dominator for `ebb` using the current `idom` states for the reachable
+    // Compute the immediate dominator for `block` using the current `idom` states for the reachable
     // nodes.
-    fn compute_idom(&self, ebb: Ebb, cfg: &ControlFlowGraph, layout: &Layout) -> Inst {
-        // Get an iterator with just the reachable, already visited predecessors to `ebb`.
+    fn compute_idom(&self, block: Block, cfg: &ControlFlowGraph, layout: &Layout) -> Inst {
+        // Get an iterator with just the reachable, already visited predecessors to `block`.
         // Note that during the first pass, `rpo_number` is 1 for reachable blocks that haven't
         // been visited yet, 0 for unreachable blocks.
         let mut reachable_preds = cfg
-            .pred_iter(ebb)
-            .filter(|&BasicBlock { ebb: pred, .. }| self.nodes[pred].rpo_number > 1);
+            .pred_iter(block)
+            .filter(|&BlockPredecessor { block: pred, .. }| self.nodes[pred].rpo_number > 1);
 
         // The RPO must visit at least one predecessor before this node.
         let mut idom = reachable_preds
             .next()
-            .expect("EBB node must have one reachable predecessor");
+            .expect("block node must have one reachable predecessor");
 
         for pred in reachable_preds {
             idom = self.common_dominator(idom, pred, layout);
         }
 
         idom.inst
     }
 }
 
 /// Optional pre-order information that can be computed for a dominator tree.
 ///
 /// This data structure is computed from a `DominatorTree` and provides:
 ///
 /// - A forward traversable dominator tree through the `children()` iterator.
-/// - An ordering of EBBs according to a dominator tree pre-order.
-/// - Constant time dominance checks at the EBB granularity.
+/// - An ordering of blocks according to a dominator tree pre-order.
+/// - Constant time dominance checks at the block granularity.
 ///
 /// The information in this auxiliary data structure is not easy to update when the control flow
 /// graph changes, which is why it is kept separate.
 pub struct DominatorTreePreorder {
-    nodes: SecondaryMap<Ebb, ExtraNode>,
+    nodes: SecondaryMap<Block, ExtraNode>,
 
     // Scratch memory used by `compute_postorder()`.
-    stack: Vec<Ebb>,
+    stack: Vec<Block>,
 }
 
 #[derive(Default, Clone)]
 struct ExtraNode {
     /// First child node in the domtree.
-    child: PackedOption<Ebb>,
+    child: PackedOption<Block>,
 
     /// Next sibling node in the domtree. This linked list is ordered according to the CFG RPO.
-    sibling: PackedOption<Ebb>,
+    sibling: PackedOption<Block>,
 
     /// Sequence number for this node in a pre-order traversal of the dominator tree.
     /// Unreachable blocks have number 0, the entry block is 1.
     pre_number: u32,
 
     /// Maximum `pre_number` for the sub-tree of the dominator tree that is rooted at this node.
     /// This is always >= `pre_number`.
     pre_max: u32,
@@ -496,117 +498,117 @@ impl DominatorTreePreorder {
     pub fn compute(&mut self, domtree: &DominatorTree, layout: &Layout) {
         self.nodes.clear();
         debug_assert_eq!(self.stack.len(), 0);
 
         // Step 1: Populate the child and sibling links.
         //
         // By following the CFG post-order and pushing to the front of the lists, we make sure that
         // sibling lists are ordered according to the CFG reverse post-order.
-        for &ebb in domtree.cfg_postorder() {
-            if let Some(idom_inst) = domtree.idom(ebb) {
-                let idom = layout.pp_ebb(idom_inst);
-                let sib = mem::replace(&mut self.nodes[idom].child, ebb.into());
-                self.nodes[ebb].sibling = sib;
+        for &block in domtree.cfg_postorder() {
+            if let Some(idom_inst) = domtree.idom(block) {
+                let idom = layout.pp_block(idom_inst);
+                let sib = mem::replace(&mut self.nodes[idom].child, block.into());
+                self.nodes[block].sibling = sib;
             } else {
-                // The only EBB without an immediate dominator is the entry.
-                self.stack.push(ebb);
+                // The only block without an immediate dominator is the entry.
+                self.stack.push(block);
             }
         }
 
         // Step 2. Assign pre-order numbers from a DFS of the dominator tree.
         debug_assert!(self.stack.len() <= 1);
         let mut n = 0;
-        while let Some(ebb) = self.stack.pop() {
+        while let Some(block) = self.stack.pop() {
             n += 1;
-            let node = &mut self.nodes[ebb];
+            let node = &mut self.nodes[block];
             node.pre_number = n;
             node.pre_max = n;
             if let Some(n) = node.sibling.expand() {
                 self.stack.push(n);
             }
             if let Some(n) = node.child.expand() {
                 self.stack.push(n);
             }
         }
 
         // Step 3. Propagate the `pre_max` numbers up the tree.
         // The CFG post-order is topologically ordered w.r.t. dominance so a node comes after all
         // its dominator tree children.
-        for &ebb in domtree.cfg_postorder() {
-            if let Some(idom_inst) = domtree.idom(ebb) {
-                let idom = layout.pp_ebb(idom_inst);
-                let pre_max = cmp::max(self.nodes[ebb].pre_max, self.nodes[idom].pre_max);
+        for &block in domtree.cfg_postorder() {
+            if let Some(idom_inst) = domtree.idom(block) {
+                let idom = layout.pp_block(idom_inst);
+                let pre_max = cmp::max(self.nodes[block].pre_max, self.nodes[idom].pre_max);
                 self.nodes[idom].pre_max = pre_max;
             }
         }
     }
 }
 
-/// An iterator that enumerates the direct children of an EBB in the dominator tree.
+/// An iterator that enumerates the direct children of an block in the dominator tree.
 pub struct ChildIter<'a> {
     dtpo: &'a DominatorTreePreorder,
-    next: PackedOption<Ebb>,
+    next: PackedOption<Block>,
 }
 
 impl<'a> Iterator for ChildIter<'a> {
-    type Item = Ebb;
+    type Item = Block;
 
-    fn next(&mut self) -> Option<Ebb> {
+    fn next(&mut self) -> Option<Block> {
         let n = self.next.expand();
-        if let Some(ebb) = n {
-            self.next = self.dtpo.nodes[ebb].sibling;
+        if let Some(block) = n {
+            self.next = self.dtpo.nodes[block].sibling;
         }
         n
     }
 }
 
 /// Query interface for the dominator tree pre-order.
 impl DominatorTreePreorder {
-    /// Get an iterator over the direct children of `ebb` in the dominator tree.
+    /// Get an iterator over the direct children of `block` in the dominator tree.
     ///
-    /// These are the EBB's whose immediate dominator is an instruction in `ebb`, ordered according
+    /// These are the block's whose immediate dominator is an instruction in `block`, ordered according
     /// to the CFG reverse post-order.
-    pub fn children(&self, ebb: Ebb) -> ChildIter {
+    pub fn children(&self, block: Block) -> ChildIter {
         ChildIter {
             dtpo: self,
-            next: self.nodes[ebb].child,
+            next: self.nodes[block].child,
         }
     }
 
-    /// Fast, constant time dominance check with EBB granularity.
+    /// Fast, constant time dominance check with block granularity.
     ///
     /// This computes the same result as `domtree.dominates(a, b)`, but in guaranteed fast constant
-    /// time. This is less general than the `DominatorTree` method because it only works with EBB
+    /// time. This is less general than the `DominatorTree` method because it only works with block
     /// program points.
     ///
-    /// An EBB is considered to dominate itself.
-    pub fn dominates(&self, a: Ebb, b: Ebb) -> bool {
+    /// An block is considered to dominate itself.
+    pub fn dominates(&self, a: Block, b: Block) -> bool {
         let na = &self.nodes[a];
         let nb = &self.nodes[b];
         na.pre_number <= nb.pre_number && na.pre_max >= nb.pre_max
     }
 
-    /// Compare two EBBs according to the dominator pre-order.
-    pub fn pre_cmp_ebb(&self, a: Ebb, b: Ebb) -> Ordering {
+    /// Compare two blocks according to the dominator pre-order.
+    pub fn pre_cmp_block(&self, a: Block, b: Block) -> Ordering {
         self.nodes[a].pre_number.cmp(&self.nodes[b].pre_number)
     }
 
     /// Compare two program points according to the dominator tree pre-order.
     ///
     /// This ordering of program points have the property that given a program point, pp, all the
     /// program points dominated by pp follow immediately and contiguously after pp in the order.
     pub fn pre_cmp<A, B>(&self, a: A, b: B, layout: &Layout) -> Ordering
     where
         A: Into<ExpandedProgramPoint>,
         B: Into<ExpandedProgramPoint>,
     {
         let a = a.into();
         let b = b.into();
-        self.pre_cmp_ebb(layout.pp_ebb(a), layout.pp_ebb(b))
+        self.pre_cmp_block(layout.pp_block(a), layout.pp_block(b))
             .then(layout.cmp(a, b))
     }
 
     /// Compare two value defs according to the dominator tree pre-order.
     ///
     /// Two values defined at the same program point are compared according to their parameter or
     /// result order.
     ///
@@ -638,195 +640,198 @@ mod tests {
 
         let mut dtpo = DominatorTreePreorder::new();
         dtpo.compute(&dtree, &func.layout);
     }
 
     #[test]
     fn unreachable_node() {
         let mut func = Function::new();
-        let ebb0 = func.dfg.make_ebb();
-        let v0 = func.dfg.append_ebb_param(ebb0, I32);
-        let ebb1 = func.dfg.make_ebb();
-        let ebb2 = func.dfg.make_ebb();
+        let block0 = func.dfg.make_block();
+        let v0 = func.dfg.append_block_param(block0, I32);
+        let block1 = func.dfg.make_block();
+        let block2 = func.dfg.make_block();
 
         let mut cur = FuncCursor::new(&mut func);
 
-        cur.insert_ebb(ebb0);
-        cur.ins().brnz(v0, ebb2, &[]);
+        cur.insert_block(block0);
+        cur.ins().brnz(v0, block2, &[]);
         cur.ins().trap(TrapCode::User(0));
 
-        cur.insert_ebb(ebb1);
+        cur.insert_block(block1);
         let v1 = cur.ins().iconst(I32, 1);
         let v2 = cur.ins().iadd(v0, v1);
-        cur.ins().jump(ebb0, &[v2]);
+        cur.ins().jump(block0, &[v2]);
 
-        cur.insert_ebb(ebb2);
+        cur.insert_block(block2);
         cur.ins().return_(&[v0]);
 
         let cfg = ControlFlowGraph::with_function(cur.func);
         let dt = DominatorTree::with_function(cur.func, &cfg);
 
         // Fall-through-first, prune-at-source DFT:
         //
-        // ebb0 {
-        //   brnz ebb2 {
+        // block0 {
+        //   brnz block2 {
         //     trap
-        //     ebb2 {
+        //     block2 {
         //       return
-        //     } ebb2
-        // } ebb0
-        assert_eq!(dt.cfg_postorder(), &[ebb2, ebb0]);
+        //     } block2
+        // } block0
+        assert_eq!(dt.cfg_postorder(), &[block2, block0]);
 
         let v2_def = cur.func.dfg.value_def(v2).unwrap_inst();
-        assert!(!dt.dominates(v2_def, ebb0, &cur.func.layout));
-        assert!(!dt.dominates(ebb0, v2_def, &cur.func.layout));
+        assert!(!dt.dominates(v2_def, block0, &cur.func.layout));
+        assert!(!dt.dominates(block0, v2_def, &cur.func.layout));
 
         let mut dtpo = DominatorTreePreorder::new();
         dtpo.compute(&dt, &cur.func.layout);
-        assert!(dtpo.dominates(ebb0, ebb0));
-        assert!(!dtpo.dominates(ebb0, ebb1));
-        assert!(dtpo.dominates(ebb0, ebb2));
-        assert!(!dtpo.dominates(ebb1, ebb0));
-        assert!(dtpo.dominates(ebb1, ebb1));
-        assert!(!dtpo.dominates(ebb1, ebb2));
-        assert!(!dtpo.dominates(ebb2, ebb0));
-        assert!(!dtpo.dominates(ebb2, ebb1));
-        assert!(dtpo.dominates(ebb2, ebb2));
+        assert!(dtpo.dominates(block0, block0));
+        assert!(!dtpo.dominates(block0, block1));
+        assert!(dtpo.dominates(block0, block2));
+        assert!(!dtpo.dominates(block1, block0));
+        assert!(dtpo.dominates(block1, block1));
+        assert!(!dtpo.dominates(block1, block2));
+        assert!(!dtpo.dominates(block2, block0));
+        assert!(!dtpo.dominates(block2, block1));
+        assert!(dtpo.dominates(block2, block2));
     }
 
     #[test]
     fn non_zero_entry_block() {
         let mut func = Function::new();
-        let ebb0 = func.dfg.make_ebb();
-        let ebb1 = func.dfg.make_ebb();
-        let ebb2 = func.dfg.make_ebb();
-        let ebb3 = func.dfg.make_ebb();
-        let cond = func.dfg.append_ebb_param(ebb3, I32);
+        let block0 = func.dfg.make_block();
+        let block1 = func.dfg.make_block();
+        let block2 = func.dfg.make_block();
+        let block3 = func.dfg.make_block();
+        let cond = func.dfg.append_block_param(block3, I32);
 
         let mut cur = FuncCursor::new(&mut func);
 
-        cur.insert_ebb(ebb3);
-        let jmp_ebb3_ebb1 = cur.ins().jump(ebb1, &[]);
+        cur.insert_block(block3);
+        let jmp_block3_block1 = cur.ins().jump(block1, &[]);
 
-        cur.insert_ebb(ebb1);
-        let br_ebb1_ebb0 = cur.ins().brnz(cond, ebb0, &[]);
-        let jmp_ebb1_ebb2 = cur.ins().jump(ebb2, &[]);
+        cur.insert_block(block1);
+        let br_block1_block0 = cur.ins().brnz(cond, block0, &[]);
+        let jmp_block1_block2 = cur.ins().jump(block2, &[]);
 
-        cur.insert_ebb(ebb2);
-        cur.ins().jump(ebb0, &[]);
+        cur.insert_block(block2);
+        cur.ins().jump(block0, &[]);
 
-        cur.insert_ebb(ebb0);
+        cur.insert_block(block0);
 
         let cfg = ControlFlowGraph::with_function(cur.func);
         let dt = DominatorTree::with_function(cur.func, &cfg);
 
         // Fall-through-first, prune-at-source DFT:
         //
-        // ebb3 {
-        //   ebb3:jump ebb1 {
-        //     ebb1 {
-        //       ebb1:brnz ebb0 {
-        //         ebb1:jump ebb2 {
-        //           ebb2 {
-        //             ebb2:jump ebb0 (seen)
-        //           } ebb2
-        //         } ebb1:jump ebb2
-        //         ebb0 {
-        //         } ebb0
-        //       } ebb1:brnz ebb0
-        //     } ebb1
-        //   } ebb3:jump ebb1
-        // } ebb3
+        // block3 {
+        //   block3:jump block1 {
+        //     block1 {
+        //       block1:brnz block0 {
+        //         block1:jump block2 {
+        //           block2 {
+        //             block2:jump block0 (seen)
+        //           } block2
+        //         } block1:jump block2
+        //         block0 {
+        //         } block0
+        //       } block1:brnz block0
+        //     } block1
+        //   } block3:jump block1
+        // } block3
+
+        assert_eq!(dt.cfg_postorder(), &[block2, block0, block1, block3]);
 
-        assert_eq!(dt.cfg_postorder(), &[ebb2, ebb0, ebb1, ebb3]);
-
-        assert_eq!(cur.func.layout.entry_block().unwrap(), ebb3);
-        assert_eq!(dt.idom(ebb3), None);
-        assert_eq!(dt.idom(ebb1).unwrap(), jmp_ebb3_ebb1);
-        assert_eq!(dt.idom(ebb2).unwrap(), jmp_ebb1_ebb2);
-        assert_eq!(dt.idom(ebb0).unwrap(), br_ebb1_ebb0);
+        assert_eq!(cur.func.layout.entry_block().unwrap(), block3);
+        assert_eq!(dt.idom(block3), None);
+        assert_eq!(dt.idom(block1).unwrap(), jmp_block3_block1);
+        assert_eq!(dt.idom(block2).unwrap(), jmp_block1_block2);
+        assert_eq!(dt.idom(block0).unwrap(), br_block1_block0);
 
-        assert!(dt.dominates(br_ebb1_ebb0, br_ebb1_ebb0, &cur.func.layout));
-        assert!(!dt.dominates(br_ebb1_ebb0, jmp_ebb3_ebb1, &cur.func.layout));
-        assert!(dt.dominates(jmp_ebb3_ebb1, br_ebb1_ebb0, &cur.func.layout));
+        assert!(dt.dominates(br_block1_block0, br_block1_block0, &cur.func.layout));
+        assert!(!dt.dominates(br_block1_block0, jmp_block3_block1, &cur.func.layout));
+        assert!(dt.dominates(jmp_block3_block1, br_block1_block0, &cur.func.layout));
 
-        assert_eq!(dt.rpo_cmp(ebb3, ebb3, &cur.func.layout), Ordering::Equal);
-        assert_eq!(dt.rpo_cmp(ebb3, ebb1, &cur.func.layout), Ordering::Less);
         assert_eq!(
-            dt.rpo_cmp(ebb3, jmp_ebb3_ebb1, &cur.func.layout),
+            dt.rpo_cmp(block3, block3, &cur.func.layout),
+            Ordering::Equal
+        );
+        assert_eq!(dt.rpo_cmp(block3, block1, &cur.func.layout), Ordering::Less);
+        assert_eq!(
+            dt.rpo_cmp(block3, jmp_block3_block1, &cur.func.layout),
             Ordering::Less
         );
         assert_eq!(
-            dt.rpo_cmp(jmp_ebb3_ebb1, jmp_ebb1_ebb2, &cur.func.layout),
+            dt.rpo_cmp(jmp_block3_block1, jmp_block1_block2, &cur.func.layout),
             Ordering::Less
         );
     }
 
     #[test]
     fn backwards_layout() {
         let mut func = Function::new();
-        let ebb0 = func.dfg.make_ebb();
-        let ebb1 = func.dfg.make_ebb();
-        let ebb2 = func.dfg.make_ebb();
+        let block0 = func.dfg.make_block();
+        let block1 = func.dfg.make_block();
+        let block2 = func.dfg.make_block();
 
         let mut cur = FuncCursor::new(&mut func);
 
-        cur.insert_ebb(ebb0);
-        let jmp02 = cur.ins().jump(ebb2, &[]);
+        cur.insert_block(block0);
+        let jmp02 = cur.ins().jump(block2, &[]);
 
-        cur.insert_ebb(ebb1);
+        cur.insert_block(block1);
         let trap = cur.ins().trap(TrapCode::User(5));
 
-        cur.insert_ebb(ebb2);
-        let jmp21 = cur.ins().jump(ebb1, &[]);
+        cur.insert_block(block2);
+        let jmp21 = cur.ins().jump(block1, &[]);
 
         let cfg = ControlFlowGraph::with_function(cur.func);
         let dt = DominatorTree::with_function(cur.func, &cfg);
 
-        assert_eq!(cur.func.layout.entry_block(), Some(ebb0));
-        assert_eq!(dt.idom(ebb0), None);
-        assert_eq!(dt.idom(ebb1), Some(jmp21));
-        assert_eq!(dt.idom(ebb2), Some(jmp02));
+        assert_eq!(cur.func.layout.entry_block(), Some(block0));
+        assert_eq!(dt.idom(block0), None);
+        assert_eq!(dt.idom(block1), Some(jmp21));
+        assert_eq!(dt.idom(block2), Some(jmp02));
 
-        assert!(dt.dominates(ebb0, ebb0, &cur.func.layout));
-        assert!(dt.dominates(ebb0, jmp02, &cur.func.layout));
-        assert!(dt.dominates(ebb0, ebb1, &cur.func.layout));
-        assert!(dt.dominates(ebb0, trap, &cur.func.layout));
-        assert!(dt.dominates(ebb0, ebb2, &cur.func.layout));
-        assert!(dt.dominates(ebb0, jmp21, &cur.func.layout));
+        assert!(dt.dominates(block0, block0, &cur.func.layout));
+        assert!(dt.dominates(block0, jmp02, &cur.func.layout));
+        assert!(dt.dominates(block0, block1, &cur.func.layout));
+        assert!(dt.dominates(block0, trap, &cur.func.layout));
+        assert!(dt.dominates(block0, block2, &cur.func.layout));
+        assert!(dt.dominates(block0, jmp21, &cur.func.layout));
 
-        assert!(!dt.dominates(jmp02, ebb0, &cur.func.layout));
+        assert!(!dt.dominates(jmp02, block0, &cur.func.layout));
         assert!(dt.dominates(jmp02, jmp02, &cur.func.layout));
-        assert!(dt.dominates(jmp02, ebb1, &cur.func.layout));
+        assert!(dt.dominates(jmp02, block1, &cur.func.layout));
         assert!(dt.dominates(jmp02, trap, &cur.func.layout));
-        assert!(dt.dominates(jmp02, ebb2, &cur.func.layout));
+        assert!(dt.dominates(jmp02, block2, &cur.func.layout));
         assert!(dt.dominates(jmp02, jmp21, &cur.func.layout));
 
-        assert!(!dt.dominates(ebb1, ebb0, &cur.func.layout));
-        assert!(!dt.dominates(ebb1, jmp02, &cur.func.layout));
-        assert!(dt.dominates(ebb1, ebb1, &cur.func.layout));
-        assert!(dt.dominates(ebb1, trap, &cur.func.layout));
-        assert!(!dt.dominates(ebb1, ebb2, &cur.func.layout));
-        assert!(!dt.dominates(ebb1, jmp21, &cur.func.layout));
+        assert!(!dt.dominates(block1, block0, &cur.func.layout));
+        assert!(!dt.dominates(block1, jmp02, &cur.func.layout));
+        assert!(dt.dominates(block1, block1, &cur.func.layout));
+        assert!(dt.dominates(block1, trap, &cur.func.layout));
+        assert!(!dt.dominates(block1, block2, &cur.func.layout));
+        assert!(!dt.dominates(block1, jmp21, &cur.func.layout));
 
-        assert!(!dt.dominates(trap, ebb0, &cur.func.layout));
+        assert!(!dt.dominates(trap, block0, &cur.func.layout));
         assert!(!dt.dominates(trap, jmp02, &cur.func.layout));
-        assert!(!dt.dominates(trap, ebb1, &cur.func.layout));
+        assert!(!dt.dominates(trap, block1, &cur.func.layout));
         assert!(dt.dominates(trap, trap, &cur.func.layout));
-        assert!(!dt.dominates(trap, ebb2, &cur.func.layout));
+        assert!(!dt.dominates(trap, block2, &cur.func.layout));
         assert!(!dt.dominates(trap, jmp21, &cur.func.layout));
 
-        assert!(!dt.dominates(ebb2, ebb0, &cur.func.layout));
-        assert!(!dt.dominates(ebb2, jmp02, &cur.func.layout));
-        assert!(dt.dominates(ebb2, ebb1, &cur.func.layout));
-        assert!(dt.dominates(ebb2, trap, &cur.func.layout));
-        assert!(dt.dominates(ebb2, ebb2, &cur.func.layout));
-        assert!(dt.dominates(ebb2, jmp21, &cur.func.layout));
+        assert!(!dt.dominates(block2, block0, &cur.func.layout));
+        assert!(!dt.dominates(block2, jmp02, &cur.func.layout));
+        assert!(dt.dominates(block2, block1, &cur.func.layout));
+        assert!(dt.dominates(block2, trap, &cur.func.layout));
+        assert!(dt.dominates(block2, block2, &cur.func.layout));
+        assert!(dt.dominates(block2, jmp21, &cur.func.layout));
 
-        assert!(!dt.dominates(jmp21, ebb0, &cur.func.layout));
+        assert!(!dt.dominates(jmp21, block0, &cur.func.layout));
         assert!(!dt.dominates(jmp21, jmp02, &cur.func.layout));
-        assert!(dt.dominates(jmp21, ebb1, &cur.func.layout));
+        assert!(dt.dominates(jmp21, block1, &cur.func.layout));
         assert!(dt.dominates(jmp21, trap, &cur.func.layout));
-        assert!(!dt.dominates(jmp21, ebb2, &cur.func.layout));
+        assert!(!dt.dominates(jmp21, block2, &cur.func.layout));
         assert!(dt.dominates(jmp21, jmp21, &cur.func.layout));
     }
 }
--- a/third_party/rust/cranelift-codegen/src/flowgraph.rs
+++ b/third_party/rust/cranelift-codegen/src/flowgraph.rs
@@ -1,85 +1,85 @@
-//! A control flow graph represented as mappings of extended basic blocks to their predecessors
+//! A control flow graph represented as mappings of basic blocks to their predecessors
 //! and successors.
 //!
-//! Successors are represented as extended basic blocks while predecessors are represented by basic
-//! blocks. Basic blocks are denoted by tuples of EBB and branch/jump instructions. Each
+//! Successors are represented as basic blocks while predecessors are represented by basic
+//! blocks. Basic blocks are denoted by tuples of block and branch/jump instructions. Each
 //! predecessor tuple corresponds to the end of a basic block.
 //!
 //! ```c
-//!     Ebb0:
+//!     Block0:
 //!         ...          ; beginning of basic block
 //!
 //!         ...
 //!
-//!         brz vx, Ebb1 ; end of basic block
+//!         brz vx, Block1 ; end of basic block
 //!
 //!         ...          ; beginning of basic block
 //!
 //!         ...
 //!
-//!         jmp Ebb2     ; end of basic block
+//!         jmp Block2     ; end of basic block
 //! ```
 //!
-//! Here `Ebb1` and `Ebb2` would each have a single predecessor denoted as `(Ebb0, brz)`
-//! and `(Ebb0, jmp Ebb2)` respectively.
+//! Here `Block1` and `Block2` would each have a single predecessor denoted as `(Block0, brz)`
+//! and `(Block0, jmp Block2)` respectively.
 
 use crate::bforest;
 use crate::entity::SecondaryMap;
 use crate::ir::instructions::BranchInfo;
-use crate::ir::{Ebb, Function, Inst};
+use crate::ir::{Block, Function, Inst};
 use crate::timing;
 use core::mem;
 
-/// A basic block denoted by its enclosing Ebb and last instruction.
+/// A basic block denoted by its enclosing Block and last instruction.
 #[derive(Debug, PartialEq, Eq)]
-pub struct BasicBlock {
-    /// Enclosing Ebb key.
-    pub ebb: Ebb,
+pub struct BlockPredecessor {
+    /// Enclosing Block key.
+    pub block: Block,
     /// Last instruction in the basic block.
     pub inst: Inst,
 }
 
-impl BasicBlock {
-    /// Convenient method to construct new BasicBlock.
-    pub fn new(ebb: Ebb, inst: Inst) -> Self {
-        Self { ebb, inst }
+impl BlockPredecessor {
+    /// Convenient method to construct new BlockPredecessor.
+    pub fn new(block: Block, inst: Inst) -> Self {
+        Self { block, inst }
     }
 }
 
-/// A container for the successors and predecessors of some Ebb.
+/// A container for the successors and predecessors of some Block.
 #[derive(Clone, Default)]
 struct CFGNode {
-    /// Instructions that can branch or jump to this EBB.
+    /// Instructions that can branch or jump to this block.
     ///
-    /// This maps branch instruction -> predecessor EBB which is redundant since the EBB containing
-    /// the branch instruction is available from the `layout.inst_ebb()` method. We store the
+    /// This maps branch instruction -> predecessor block which is redundant since the block containing
+    /// the branch instruction is available from the `layout.inst_block()` method. We store the
     /// redundant information because:
     ///
-    /// 1. Many `pred_iter()` consumers want the EBB anyway, so it is handily available.
-    /// 2. The `invalidate_ebb_successors()` may be called *after* branches have been removed from
-    ///    their EBB, but we still need to remove them form the old EBB predecessor map.
+    /// 1. Many `pred_iter()` consumers want the block anyway, so it is handily available.
+    /// 2. The `invalidate_block_successors()` may be called *after* branches have been removed from
+    ///    their block, but we still need to remove them form the old block predecessor map.
     ///
-    /// The redundant EBB stored here is always consistent with the CFG successor lists, even after
+    /// The redundant block stored here is always consistent with the CFG successor lists, even after
     /// the IR has been edited.
-    pub predecessors: bforest::Map<Inst, Ebb>,
+    pub predecessors: bforest::Map<Inst, Block>,
 
-    /// Set of EBBs that are the targets of branches and jumps in this EBB.
-    /// The set is ordered by EBB number, indicated by the `()` comparator type.
-    pub successors: bforest::Set<Ebb>,
+    /// Set of blocks that are the targets of branches and jumps in this block.
+    /// The set is ordered by block number, indicated by the `()` comparator type.
+    pub successors: bforest::Set<Block>,
 }
 
-/// The Control Flow Graph maintains a mapping of ebbs to their predecessors
+/// The Control Flow Graph maintains a mapping of blocks to their predecessors
 /// and successors where predecessors are basic blocks and successors are
-/// extended basic blocks.
+/// basic blocks.
 pub struct ControlFlowGraph {
-    data: SecondaryMap<Ebb, CFGNode>,
-    pred_forest: bforest::MapForest<Inst, Ebb>,
-    succ_forest: bforest::SetForest<Ebb>,
+    data: SecondaryMap<Block, CFGNode>,
+    pred_forest: bforest::MapForest<Inst, Block>,
+    succ_forest: bforest::SetForest<Block>,
     valid: bool,
 }
 
 impl ControlFlowGraph {
     /// Allocate a new blank control flow graph.
     pub fn new() -> Self {
         Self {
             data: SecondaryMap::new(),
@@ -105,114 +105,114 @@ impl ControlFlowGraph {
     }
 
     /// Compute the control flow graph of `func`.
     ///
     /// This will clear and overwrite any information already stored in this data structure.
     pub fn compute(&mut self, func: &Function) {
         let _tt = timing::flowgraph();
         self.clear();
-        self.data.resize(func.dfg.num_ebbs());
+        self.data.resize(func.dfg.num_blocks());
 
-        for ebb in &func.layout {
-            self.compute_ebb(func, ebb);
+        for block in &func.layout {
+            self.compute_block(func, block);
         }
 
         self.valid = true;
     }
 
-    fn compute_ebb(&mut self, func: &Function, ebb: Ebb) {
-        for inst in func.layout.ebb_insts(ebb) {
+    fn compute_block(&mut self, func: &Function, block: Block) {
+        for inst in func.layout.block_insts(block) {
             match func.dfg.analyze_branch(inst) {
                 BranchInfo::SingleDest(dest, _) => {
-                    self.add_edge(ebb, inst, dest);
+                    self.add_edge(block, inst, dest);
                 }
                 BranchInfo::Table(jt, dest) => {
                     if let Some(dest) = dest {
-                        self.add_edge(ebb, inst, dest);
+                        self.add_edge(block, inst, dest);
                     }
                     for dest in func.jump_tables[jt].iter() {
-                        self.add_edge(ebb, inst, *dest);
+                        self.add_edge(block, inst, *dest);
                     }
                 }
                 BranchInfo::NotABranch => {}
             }
         }
     }
 
-    fn invalidate_ebb_successors(&mut self, ebb: Ebb) {
+    fn invalidate_block_successors(&mut self, block: Block) {
         // Temporarily take ownership because we need mutable access to self.data inside the loop.
         // Unfortunately borrowck cannot see that our mut accesses to predecessors don't alias
         // our iteration over successors.
-        let mut successors = mem::replace(&mut self.data[ebb].successors, Default::default());
+        let mut successors = mem::replace(&mut self.data[block].successors, Default::default());
         for succ in successors.iter(&self.succ_forest) {
             self.data[succ]
                 .predecessors
-                .retain(&mut self.pred_forest, |_, &mut e| e != ebb);
+                .retain(&mut self.pred_forest, |_, &mut e| e != block);
         }
         successors.clear(&mut self.succ_forest);
     }
 
-    /// Recompute the control flow graph of `ebb`.
+    /// Recompute the control flow graph of `block`.
     ///
-    /// This is for use after modifying instructions within a specific EBB. It recomputes all edges
-    /// from `ebb` while leaving edges to `ebb` intact. Its functionality a subset of that of the
+    /// This is for use after modifying instructions within a specific block. It recomputes all edges
+    /// from `block` while leaving edges to `block` intact. Its functionality a subset of that of the
     /// more expensive `compute`, and should be used when we know we don't need to recompute the CFG
-    /// from scratch, but rather that our changes have been restricted to specific EBBs.
-    pub fn recompute_ebb(&mut self, func: &Function, ebb: Ebb) {
+    /// from scratch, but rather that our changes have been restricted to specific blocks.
+    pub fn recompute_block(&mut self, func: &Function, block: Block) {
         debug_assert!(self.is_valid());
-        self.invalidate_ebb_successors(ebb);
-        self.compute_ebb(func, ebb);
+        self.invalidate_block_successors(block);
+        self.compute_block(func, block);
     }
 
-    fn add_edge(&mut self, from: Ebb, from_inst: Inst, to: Ebb) {
+    fn add_edge(&mut self, from: Block, from_inst: Inst, to: Block) {
         self.data[from]
             .successors
             .insert(to, &mut self.succ_forest, &());
         self.data[to]
             .predecessors
             .insert(from_inst, from, &mut self.pred_forest, &());
     }
 
-    /// Get an iterator over the CFG predecessors to `ebb`.
-    pub fn pred_iter(&self, ebb: Ebb) -> PredIter {
-        PredIter(self.data[ebb].predecessors.iter(&self.pred_forest))
+    /// Get an iterator over the CFG predecessors to `block`.
+    pub fn pred_iter(&self, block: Block) -> PredIter {
+        PredIter(self.data[block].predecessors.iter(&self.pred_forest))
     }
 
-    /// Get an iterator over the CFG successors to `ebb`.
-    pub fn succ_iter(&self, ebb: Ebb) -> SuccIter {
+    /// Get an iterator over the CFG successors to `block`.
+    pub fn succ_iter(&self, block: Block) -> SuccIter {
         debug_assert!(self.is_valid());
-        self.data[ebb].successors.iter(&self.succ_forest)
+        self.data[block].successors.iter(&self.succ_forest)
     }
 
     /// Check if the CFG is in a valid state.
     ///
     /// Note that this doesn't perform any kind of validity checks. It simply checks if the
     /// `compute()` method has been called since the last `clear()`. It does not check that the
     /// CFG is consistent with the function.
     pub fn is_valid(&self) -> bool {
         self.valid
     }
 }
 
-/// An iterator over EBB predecessors. The iterator type is `BasicBlock`.
+/// An iterator over block predecessors. The iterator type is `BlockPredecessor`.
 ///
-/// Each predecessor is an instruction that branches to the EBB.
-pub struct PredIter<'a>(bforest::MapIter<'a, Inst, Ebb>);
+/// Each predecessor is an instruction that branches to the block.
+pub struct PredIter<'a>(bforest::MapIter<'a, Inst, Block>);
 
 impl<'a> Iterator for PredIter<'a> {
-    type Item = BasicBlock;
+    type Item = BlockPredecessor;
 
-    fn next(&mut self) -> Option<BasicBlock> {
-        self.0.next().map(|(i, e)| BasicBlock::new(e, i))
+    fn next(&mut self) -> Option<BlockPredecessor> {
+        self.0.next().map(|(i, e)| BlockPredecessor::new(e, i))
     }
 }
 
-/// An iterator over EBB successors. The iterator type is `Ebb`.
-pub type SuccIter<'a> = bforest::SetIter<'a, Ebb>;
+/// An iterator over block successors. The iterator type is `Block`.
+pub type SuccIter<'a> = bforest::SetIter<'a, Block>;
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::cursor::{Cursor, FuncCursor};
     use crate::ir::{types, Function, InstBuilder};
     use alloc::vec::Vec;
 
@@ -220,131 +220,131 @@ mod tests {
     fn empty() {
         let func = Function::new();
         ControlFlowGraph::with_function(&func);
     }
 
     #[test]
     fn no_predecessors() {
         let mut func = Function::new();
-        let ebb0 = func.dfg.make_ebb();
-        let ebb1 = func.dfg.make_ebb();
-        let ebb2 = func.dfg.make_ebb();
-        func.layout.append_ebb(ebb0);
-        func.layout.append_ebb(ebb1);
-        func.layout.append_ebb(ebb2);
+        let block0 = func.dfg.make_block();
+        let block1 = func.dfg.make_block();
+        let block2 = func.dfg.make_block();
+        func.layout.append_block(block0);
+        func.layout.append_block(block1);
+        func.layout.append_block(block2);
 
         let cfg = ControlFlowGraph::with_function(&func);
 
-        let mut fun_ebbs = func.layout.ebbs();
-        for ebb in func.layout.ebbs() {
-            assert_eq!(ebb, fun_ebbs.next().unwrap());
-            assert_eq!(cfg.pred_iter(ebb).count(), 0);
-            assert_eq!(cfg.succ_iter(ebb).count(), 0);
+        let mut fun_blocks = func.layout.blocks();
+        for block in func.layout.blocks() {
+            assert_eq!(block, fun_blocks.next().unwrap());
+            assert_eq!(cfg.pred_iter(block).count(), 0);
+            assert_eq!(cfg.succ_iter(block).count(), 0);
         }
     }
 
     #[test]
     fn branches_and_jumps() {
         let mut func = Function::new();
-        let ebb0 = func.dfg.make_ebb();
-        let cond = func.dfg.append_ebb_param(ebb0, types::I32);
-        let ebb1 = func.dfg.make_ebb();
-        let ebb2 = func.dfg.make_ebb();
+        let block0 = func.dfg.make_block();
+        let cond = func.dfg.append_block_param(block0, types::I32);
+        let block1 = func.dfg.make_block();
+        let block2 = func.dfg.make_block();
 
-        let br_ebb0_ebb2;
-        let br_ebb1_ebb1;
-        let jmp_ebb0_ebb1;
-        let jmp_ebb1_ebb2;
+        let br_block0_block2;
+        let br_block1_block1;
+        let jmp_block0_block1;
+        let jmp_block1_block2;
 
         {
             let mut cur = FuncCursor::new(&mut func);
 
-            cur.insert_ebb(ebb0);
-            br_ebb0_ebb2 = cur.ins().brnz(cond, ebb2, &[]);
-            jmp_ebb0_ebb1 = cur.ins().jump(ebb1, &[]);
+            cur.insert_block(block0);
+            br_block0_block2 = cur.ins().brnz(cond, block2, &[]);
+            jmp_block0_block1 = cur.ins().jump(block1, &[]);
 
-            cur.insert_ebb(ebb1);
-            br_ebb1_ebb1 = cur.ins().brnz(cond, ebb1, &[]);
-            jmp_ebb1_ebb2 = cur.ins().jump(ebb2, &[]);
+            cur.insert_block(block1);
+            br_block1_block1 = cur.ins().brnz(cond, block1, &[]);
+            jmp_block1_block2 = cur.ins().jump(block2, &[]);
 
-            cur.insert_ebb(ebb2);
+            cur.insert_block(block2);
         }
 
         let mut cfg = ControlFlowGraph::with_function(&func);
 
         {
-            let ebb0_predecessors = cfg.pred_iter(ebb0).collect::<Vec<_>>();
-            let ebb1_predecessors = cfg.pred_iter(ebb1).collect::<Vec<_>>();
-            let ebb2_predecessors = cfg.pred_iter(ebb2).collect::<Vec<_>>();
+            let block0_predecessors = cfg.pred_iter(block0).collect::<Vec<_>>();
+            let block1_predecessors = cfg.pred_iter(block1).collect::<Vec<_>>();
+            let block2_predecessors = cfg.pred_iter(block2).collect::<Vec<_>>();
 
-            let ebb0_successors = cfg.succ_iter(ebb0).collect::<Vec<_>>();
-            let ebb1_successors = cfg.succ_iter(ebb1).collect::<Vec<_>>();
-            let ebb2_successors = cfg.succ_iter(ebb2).collect::<Vec<_>>();
+            let block0_successors = cfg.succ_iter(block0).collect::<Vec<_>>();
+            let block1_successors = cfg.succ_iter(block1).collect::<Vec<_>>();
+            let block2_successors = cfg.succ_iter(block2).collect::<Vec<_>>();
 
-            assert_eq!(ebb0_predecessors.len(), 0);
-            assert_eq!(ebb1_predecessors.len(), 2);
-            assert_eq!(ebb2_predecessors.len(), 2);
+            assert_eq!(block0_predecessors.len(), 0);
+            assert_eq!(block1_predecessors.len(), 2);
+            assert_eq!(block2_predecessors.len(), 2);
 
             assert_eq!(
-                ebb1_predecessors.contains(&BasicBlock::new(ebb0, jmp_ebb0_ebb1)),
+                block1_predecessors.contains(&BlockPredecessor::new(block0, jmp_block0_block1)),
                 true
             );
             assert_eq!(
-                ebb1_predecessors.contains(&BasicBlock::new(ebb1, br_ebb1_ebb1)),
+                block1_predecessors.contains(&BlockPredecessor::new(block1, br_block1_block1)),
                 true
             );
             assert_eq!(
-                ebb2_predecessors.contains(&BasicBlock::new(ebb0, br_ebb0_ebb2)),
+                block2_predecessors.contains(&BlockPredecessor::new(block0, br_block0_block2)),
                 true
             );
             assert_eq!(
-                ebb2_predecessors.contains(&BasicBlock::new(ebb1, jmp_ebb1_ebb2)),
+                block2_predecessors.contains(&BlockPredecessor::new(block1, jmp_block1_block2)),
                 true
             );
 
-            assert_eq!(ebb0_successors, [ebb1, ebb2]);
-            assert_eq!(ebb1_successors, [ebb1, ebb2]);
-            assert_eq!(ebb2_successors, []);
+            assert_eq!(block0_successors, [block1, block2]);
+            assert_eq!(block1_successors, [block1, block2]);
+            assert_eq!(block2_successors, []);
         }
 
-        // Change some instructions and recompute ebb0
-        func.dfg.replace(br_ebb0_ebb2).brnz(cond, ebb1, &[]);
-        func.dfg.replace(jmp_ebb0_ebb1).return_(&[]);
-        cfg.recompute_ebb(&mut func, ebb0);
-        let br_ebb0_ebb1 = br_ebb0_ebb2;
+        // Change some instructions and recompute block0
+        func.dfg.replace(br_block0_block2).brnz(cond, block1, &[]);
+        func.dfg.replace(jmp_block0_block1).return_(&[]);
+        cfg.recompute_block(&mut func, block0);
+        let br_block0_block1 = br_block0_block2;
 
         {
-            let ebb0_predecessors = cfg.pred_iter(ebb0).collect::<Vec<_>>();
-            let ebb1_predecessors = cfg.pred_iter(ebb1).collect::<Vec<_>>();
-            let ebb2_predecessors = cfg.pred_iter(ebb2).collect::<Vec<_>>();
+            let block0_predecessors = cfg.pred_iter(block0).collect::<Vec<_>>();
+            let block1_predecessors = cfg.pred_iter(block1).collect::<Vec<_>>();
+            let block2_predecessors = cfg.pred_iter(block2).collect::<Vec<_>>();
 
-            let ebb0_successors = cfg.succ_iter(ebb0);
-            let ebb1_successors = cfg.succ_iter(ebb1);
-            let ebb2_successors = cfg.succ_iter(ebb2);
+            let block0_successors = cfg.succ_iter(block0);
+            let block1_successors = cfg.succ_iter(block1);
+            let block2_successors = cfg.succ_iter(block2);
 
-            assert_eq!(ebb0_predecessors.len(), 0);
-            assert_eq!(ebb1_predecessors.len(), 2);
-            assert_eq!(ebb2_predecessors.len(), 1);
+            assert_eq!(block0_predecessors.len(), 0);
+            assert_eq!(block1_predecessors.len(), 2);
+            assert_eq!(block2_predecessors.len(), 1);
 
             assert_eq!(
-                ebb1_predecessors.contains(&BasicBlock::new(ebb0, br_ebb0_ebb1)),
+                block1_predecessors.contains(&BlockPredecessor::new(block0, br_block0_block1)),
                 true
             );
             assert_eq!(
-                ebb1_predecessors.contains(&BasicBlock::new(ebb1, br_ebb1_ebb1)),
+                block1_predecessors.contains(&BlockPredecessor::new(block1, br_block1_block1)),
                 true
             );
             assert_eq!(
-                ebb2_predecessors.contains(&BasicBlock::new(ebb0, br_ebb0_ebb2)),
+                block2_predecessors.contains(&BlockPredecessor::new(block0, br_block0_block2)),
                 false
             );
             assert_eq!(
-                ebb2_predecessors.contains(&BasicBlock::new(ebb1, jmp_ebb1_ebb2)),
+                block2_predecessors.contains(&BlockPredecessor::new(block1, jmp_block1_block2)),
                 true
             );
 
-            assert_eq!(ebb0_successors.collect::<Vec<_>>(), [ebb1]);
-            assert_eq!(ebb1_successors.collect::<Vec<_>>(), [ebb1, ebb2]);
-            assert_eq!(ebb2_successors.collect::<Vec<_>>(), []);
+            assert_eq!(block0_successors.collect::<Vec<_>>(), [block1]);
+            assert_eq!(block1_successors.collect::<Vec<_>>(), [block1, block2]);
+            assert_eq!(block2_successors.collect::<Vec<_>>(), []);
         }
     }
 }
--- a/third_party/rust/cranelift-codegen/src/ir/builder.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/builder.rs
@@ -218,20 +218,20 @@ mod tests {
     use crate::cursor::{Cursor, FuncCursor};
     use crate::ir::condcodes::*;
     use crate::ir::types::*;
     use crate::ir::{Function, InstBuilder, ValueDef};
 
     #[test]
     fn types() {
         let mut func = Function::new();
-        let ebb0 = func.dfg.make_ebb();
-        let arg0 = func.dfg.append_ebb_param(ebb0, I32);
+        let block0 = func.dfg.make_block();
+        let arg0 = func.dfg.append_block_param(block0, I32);
         let mut pos = FuncCursor::new(&mut func);
-        pos.insert_ebb(ebb0);
+        pos.insert_block(block0);
 
         // Explicit types.
         let v0 = pos.ins().iconst(I32, 3);
         assert_eq!(pos.func.dfg.value_type(v0), I32);
 
         // Inferred from inputs.
         let v1 = pos.ins().iadd(arg0, v0);
         assert_eq!(pos.func.dfg.value_type(v1), I32);
@@ -239,20 +239,20 @@ mod tests {
         // Formula.
         let cmp = pos.ins().icmp(IntCC::Equal, arg0, v0);
         assert_eq!(pos.func.dfg.value_type(cmp), B1);
     }
 
     #[test]
     fn reuse_results() {
         let mut func = Function::new();
-        let ebb0 = func.dfg.make_ebb();
-        let arg0 = func.dfg.append_ebb_param(ebb0, I32);
+        let block0 = func.dfg.make_block();
+        let arg0 = func.dfg.append_block_param(block0, I32);
         let mut pos = FuncCursor::new(&mut func);
-        pos.insert_ebb(ebb0);
+        pos.insert_block(block0);
 
         let v0 = pos.ins().iadd_imm(arg0, 17);
         assert_eq!(pos.func.dfg.value_type(v0), I32);
         let iadd = pos.prev_inst().unwrap();
         assert_eq!(pos.func.dfg.value_def(v0), ValueDef::Result(iadd, 0));
 
         // Detach v0 and reuse it for a different instruction.
         pos.func.dfg.clear_results(iadd);
--- a/third_party/rust/cranelift-codegen/src/ir/dfg.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/dfg.rs
@@ -1,64 +1,64 @@
-//! Data flow graph tracking Instructions, Values, and EBBs.
+//! Data flow graph tracking Instructions, Values, and blocks.
 
 use crate::entity::{self, PrimaryMap, SecondaryMap};
 use crate::ir;
 use crate::ir::builder::ReplaceBuilder;
 use crate::ir::extfunc::ExtFuncData;
 use crate::ir::instructions::{BranchInfo, CallInfo, InstructionData};
 use crate::ir::{types, ConstantData, ConstantPool, Immediate};
 use crate::ir::{
-    Ebb, FuncRef, Inst, SigRef, Signature, Type, Value, ValueLabelAssignments, ValueList,
+    Block, FuncRef, Inst, SigRef, Signature, Type, Value, ValueLabelAssignments, ValueList,
     ValueListPool,
 };
 use crate::isa::TargetIsa;
 use crate::packed_option::ReservedValue;
 use crate::write::write_operands;
 use crate::HashMap;
 use alloc::vec::Vec;
 use core::fmt;
 use core::iter;
 use core::mem;
 use core::ops::{Index, IndexMut};
 use core::u16;
 
-/// A data flow graph defines all instructions and extended basic blocks in a function as well as
+/// A data flow graph defines all instructions and basic blocks in a function as well as
 /// the data flow dependencies between them. The DFG also tracks values which can be either
-/// instruction results or EBB parameters.
+/// instruction results or block parameters.
 ///
-/// The layout of EBBs in the function and of instructions in each EBB is recorded by the
+/// The layout of blocks in the function and of instructions in each block is recorded by the
 /// `Layout` data structure which forms the other half of the function representation.
 ///
 #[derive(Clone)]
 pub struct DataFlowGraph {
     /// Data about all of the instructions in the function, including opcodes and operands.
     /// The instructions in this map are not in program order. That is tracked by `Layout`, along
-    /// with the EBB containing each instruction.
+    /// with the block containing each instruction.
     insts: PrimaryMap<Inst, InstructionData>,
 
     /// List of result values for each instruction.
     ///
     /// This map gets resized automatically by `make_inst()` so it is always in sync with the
     /// primary `insts` map.
     results: SecondaryMap<Inst, ValueList>,
 
-    /// Extended basic blocks in the function and their parameters.
+    /// basic blocks in the function and their parameters.
     ///
     /// This map is not in program order. That is handled by `Layout`, and so is the sequence of
-    /// instructions contained in each EBB.
-    ebbs: PrimaryMap<Ebb, EbbData>,
+    /// instructions contained in each block.
+    blocks: PrimaryMap<Block, BlockData>,
 
     /// Memory pool of value lists.
     ///
     /// The `ValueList` references into this pool appear in many places:
     ///
     /// - Instructions in `insts` that don't have room for their entire argument list inline.
     /// - Instruction result values in `results`.
-    /// - EBB parameters in `ebbs`.
+    /// - block parameters in `blocks`.
     pub value_lists: ValueListPool,
 
     /// Primary value table with entries for all values.
     values: PrimaryMap<Value, ValueData>,
 
     /// Function signature table. These signatures are referenced by indirect call instructions as
     /// well as the external function references.
     pub signatures: PrimaryMap<SigRef, Signature>,
@@ -80,33 +80,33 @@ pub struct DataFlowGraph {
 }
 
 impl DataFlowGraph {
     /// Create a new empty `DataFlowGraph`.
     pub fn new() -> Self {
         Self {
             insts: PrimaryMap::new(),
             results: SecondaryMap::new(),
-            ebbs: PrimaryMap::new(),
+            blocks: PrimaryMap::new(),
             value_lists: ValueListPool::new(),
             values: PrimaryMap::new(),
             signatures: PrimaryMap::new(),
             old_signatures: SecondaryMap::new(),
             ext_funcs: PrimaryMap::new(),
             values_labels: None,
             constants: ConstantPool::new(),
             immediates: PrimaryMap::new(),
         }
     }
 
     /// Clear everything.
     pub fn clear(&mut self) {
         self.insts.clear();
         self.results.clear();
-        self.ebbs.clear();
+        self.blocks.clear();
         self.value_lists.clear();
         self.values.clear();
         self.signatures.clear();
         self.old_signatures.clear();
         self.ext_funcs.clear();
         self.values_labels = None;
         self.constants.clear();
         self.immediates.clear();
@@ -120,27 +120,27 @@ impl DataFlowGraph {
         self.insts.len()
     }
 
     /// Returns `true` if the given instruction reference is valid.
     pub fn inst_is_valid(&self, inst: Inst) -> bool {
         self.insts.is_valid(inst)
     }
 
-    /// Get the total number of extended basic blocks created in this function, whether they are
+    /// Get the total number of basic blocks created in this function, whether they are
     /// currently inserted in the layout or not.
     ///
     /// This is intended for use with `SecondaryMap::with_capacity`.
-    pub fn num_ebbs(&self) -> usize {
-        self.ebbs.len()
+    pub fn num_blocks(&self) -> usize {
+        self.blocks.len()
     }
 
-    /// Returns `true` if the given ebb reference is valid.
-    pub fn ebb_is_valid(&self, ebb: Ebb) -> bool {
-        self.ebbs.is_valid(ebb)
+    /// Returns `true` if the given block reference is valid.
+    pub fn block_is_valid(&self, block: Block) -> bool {
+        self.blocks.is_valid(block)
     }
 
     /// Get the total number of values.
     pub fn num_values(&self) -> usize {
         self.values.len()
     }
 
     /// Starts collection of debug information.
@@ -208,17 +208,17 @@ impl<'a> Iterator for Values<'a> {
             .by_ref()
             .find(|kv| valid_valuedata(kv.1))
             .map(|kv| kv.0)
     }
 }
 
 /// Handling values.
 ///
-/// Values are either EBB parameters or instruction results.
+/// Values are either block parameters or instruction results.
 impl DataFlowGraph {
     /// Allocate an extended value entry.
     fn make_value(&mut self, data: ValueData) -> Value {
         self.values.push(data)
     }
 
     /// Get an iterator over all values.
     pub fn values<'a>(&'a self) -> Values {
@@ -238,41 +238,41 @@ impl DataFlowGraph {
             ValueData::Inst { ty, .. }
             | ValueData::Param { ty, .. }
             | ValueData::Alias { ty, .. } => ty,
         }
     }
 
     /// Get the definition of a value.
     ///
-    /// This is either the instruction that defined it or the Ebb that has the value as an
+    /// This is either the instruction that defined it or the Block that has the value as an
     /// parameter.
     pub fn value_def(&self, v: Value) -> ValueDef {
         match self.values[v] {
             ValueData::Inst { inst, num, .. } => ValueDef::Result(inst, num as usize),
-            ValueData::Param { ebb, num, .. } => ValueDef::Param(ebb, num as usize),
+            ValueData::Param { block, num, .. } => ValueDef::Param(block, num as usize),
             ValueData::Alias { original, .. } => {
                 // Make sure we only recurse one level. `resolve_aliases` has safeguards to
                 // detect alias loops without overrunning the stack.
                 self.value_def(self.resolve_aliases(original))
             }
         }
     }
 
-    /// Determine if `v` is an attached instruction result / EBB parameter.
+    /// Determine if `v` is an attached instruction result / block parameter.
     ///
     /// An attached value can't be attached to something else without first being detached.
     ///
     /// Value aliases are not considered to be attached to anything. Use `resolve_aliases()` to
     /// determine if the original aliased value is attached.
     pub fn value_is_attached(&self, v: Value) -> bool {
         use self::ValueData::*;
         match self.values[v] {
             Inst { inst, num, .. } => Some(&v) == self.inst_results(inst).get(num as usize),
-            Param { ebb, num, .. } => Some(&v) == self.ebb_params(ebb).get(num as usize),
+            Param { block, num, .. } => Some(&v) == self.block_params(block).get(num as usize),
             Alias { .. } => false,
         }
     }
 
     /// Resolve value aliases.
     ///
     /// Find the original SSA value that `value` aliases.
     pub fn resolve_aliases(&self, value: Value) -> Value {
@@ -292,17 +292,17 @@ impl DataFlowGraph {
         }
     }
 
     /// Turn a value into an alias of another.
     ///
     /// Change the `dest` value to behave as an alias of `src`. This means that all uses of `dest`
     /// will behave as if they used that value `src`.
     ///
-    /// The `dest` value can't be attached to an instruction or EBB.
+    /// The `dest` value can't be attached to an instruction or block.
     pub fn change_to_alias(&mut self, dest: Value, src: Value) {
         debug_assert!(!self.value_is_attached(dest));
         // Try to create short alias chains by finding the original source value.
         // This also avoids the creation of loops.
         let original = self.resolve_aliases(src);
         debug_assert_ne!(
             dest, original,
             "Aliasing {} to {} would create a loop",
@@ -371,34 +371,34 @@ impl DataFlowGraph {
     }
 }
 
 /// Where did a value come from?
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ValueDef {
     /// Value is the n'th result of an instruction.
     Result(Inst, usize),
-    /// Value is the n'th parameter to an EBB.
-    Param(Ebb, usize),
+    /// Value is the n'th parameter to an block.
+    Param(Block, usize),
 }
 
 impl ValueDef {
     /// Unwrap the instruction where the value was defined, or panic.
     pub fn unwrap_inst(&self) -> Inst {
         match *self {
             Self::Result(inst, _) => inst,
             _ => panic!("Value is not an instruction result"),
         }
     }
 
-    /// Unwrap the EBB there the parameter is defined, or panic.
-    pub fn unwrap_ebb(&self) -> Ebb {
+    /// Unwrap the block there the parameter is defined, or panic.
+    pub fn unwrap_block(&self) -> Block {
         match *self {
-            Self::Param(ebb, _) => ebb,
-            _ => panic!("Value is not an EBB parameter"),
+            Self::Param(block, _) => block,
+            _ => panic!("Value is not an block parameter"),
         }
     }
 
     /// Get the program point where the value was defined.
     pub fn pp(self) -> ir::ExpandedProgramPoint {
         self.into()
     }
 
@@ -414,22 +414,22 @@ impl ValueDef {
 }
 
 /// Internal table storage for extended values.
 #[derive(Clone, Debug)]
 enum ValueData {
     /// Value is defined by an instruction.
     Inst { ty: Type, num: u16, inst: Inst },
 
-    /// Value is an EBB parameter.
-    Param { ty: Type, num: u16, ebb: Ebb },
+    /// Value is an block parameter.
+    Param { ty: Type, num: u16, block: Block },
 
     /// Value is an alias of another value.
-    /// An alias value can't be linked as an instruction result or EBB parameter. It is used as a
-    /// placeholder when the original instruction or EBB has been rewritten or modified.
+    /// An alias value can't be linked as an instruction result or block parameter. It is used as a
+    /// placeholder when the original instruction or block has been rewritten or modified.
     Alias { ty: Type, original: Value },
 }
 
 /// Instructions.
 ///
 impl DataFlowGraph {
     /// Create a new instruction.
     ///
@@ -755,181 +755,186 @@ impl Index<Inst> for DataFlowGraph {
 
 /// Allow mutable access to instructions via indexing.
 impl IndexMut<Inst> for DataFlowGraph {
     fn index_mut(&mut self, inst: Inst) -> &mut InstructionData {
         &mut self.insts[inst]
     }
 }
 
-/// Extended basic blocks.
+/// basic blocks.
 impl DataFlowGraph {
     /// Create a new basic block.
-    pub fn make_ebb(&mut self) -> Ebb {
-        self.ebbs.push(EbbData::new())
+    pub fn make_block(&mut self) -> Block {
+        self.blocks.push(BlockData::new())
     }
 
-    /// Get the number of parameters on `ebb`.
-    pub fn num_ebb_params(&self, ebb: Ebb) -> usize {
-        self.ebbs[ebb].params.len(&self.value_lists)
+    /// Get the number of parameters on `block`.
+    pub fn num_block_params(&self, block: Block) -> usize {
+        self.blocks[block].params.len(&self.value_lists)
     }
 
-    /// Get the parameters on `ebb`.
-    pub fn ebb_params(&self, ebb: Ebb) -> &[Value] {
-        self.ebbs[ebb].params.as_slice(&self.value_lists)
+    /// Get the parameters on `block`.
+    pub fn block_params(&self, block: Block) -> &[Value] {
+        self.blocks[block].params.as_slice(&self.value_lists)
     }
 
-    /// Get the types of the parameters on `ebb`.
-    pub fn ebb_param_types(&self, ebb: Ebb) -> Vec<Type> {
-        self.ebb_params(ebb)
+    /// Get the types of the parameters on `block`.
+    pub fn block_param_types(&self, block: Block) -> Vec<Type> {
+        self.block_params(block)
             .iter()
             .map(|&v| self.value_type(v))
             .collect()
     }
 
-    /// Append a parameter with type `ty` to `ebb`.
-    pub fn append_ebb_param(&mut self, ebb: Ebb, ty: Type) -> Value {
+    /// Append a parameter with type `ty` to `block`.
+    pub fn append_block_param(&mut self, block: Block, ty: Type) -> Value {
         let param = self.values.next_key();
-        let num = self.ebbs[ebb].params.push(param, &mut self.value_lists);
-        debug_assert!(num <= u16::MAX as usize, "Too many parameters on EBB");
+        let num = self.blocks[block].params.push(param, &mut self.value_lists);
+        debug_assert!(num <= u16::MAX as usize, "Too many parameters on block");
         self.make_value(ValueData::Param {
             ty,
             num: num as u16,
-            ebb,
+            block,
         })
     }
 
-    /// Removes `val` from `ebb`'s parameters by swapping it with the last parameter on `ebb`.
+    /// Removes `val` from `block`'s parameters by swapping it with the last parameter on `block`.
     /// Returns the position of `val` before removal.
     ///
     /// *Important*: to ensure O(1) deletion, this method swaps the removed parameter with the
-    /// last `ebb` parameter. This can disrupt all the branch instructions jumping to this
-    /// `ebb` for which you have to change the branch argument order if necessary.
+    /// last `block` parameter. This can disrupt all the branch instructions jumping to this
+    /// `block` for which you have to change the branch argument order if necessary.
     ///
-    /// Panics if `val` is not an EBB parameter.
-    pub fn swap_remove_ebb_param(&mut self, val: Value) -> usize {
-        let (ebb, num) = if let ValueData::Param { num, ebb, .. } = self.values[val] {
-            (ebb, num)
+    /// Panics if `val` is not an block parameter.
+    pub fn swap_remove_block_param(&mut self, val: Value) -> usize {
+        let (block, num) = if let ValueData::Param { num, block, .. } = self.values[val] {
+            (block, num)
         } else {
-            panic!("{} must be an EBB parameter", val);
+            panic!("{} must be an block parameter", val);
         };
-        self.ebbs[ebb]
+        self.blocks[block]
             .params
             .swap_remove(num as usize, &mut self.value_lists);
-        if let Some(last_arg_val) = self.ebbs[ebb].params.get(num as usize, &self.value_lists) {
+        if let Some(last_arg_val) = self.blocks[block]
+            .params
+            .get(num as usize, &self.value_lists)
+        {
             // We update the position of the old last arg.
             if let ValueData::Param {
                 num: ref mut old_num,
                 ..
             } = self.values[last_arg_val]
             {
                 *old_num = num;
             } else {
-                panic!("{} should be an Ebb parameter", last_arg_val);
+                panic!("{} should be an Block parameter", last_arg_val);
             }
         }
         num as usize
     }
 
-    /// Removes `val` from `ebb`'s parameters by a standard linear time list removal which
+    /// Removes `val` from `block`'s parameters by a standard linear time list removal which
     /// preserves ordering. Also updates the values' data.
-    pub fn remove_ebb_param(&mut self, val: Value) {
-        let (ebb, num) = if let ValueData::Param { num, ebb, .. } = self.values[val] {
-            (ebb, num)
+    pub fn remove_block_param(&mut self, val: Value) {
+        let (block, num) = if let ValueData::Param { num, block, .. } = self.values[val] {
+            (block, num)
         } else {
-            panic!("{} must be an EBB parameter", val);
+            panic!("{} must be an block parameter", val);
         };
-        self.ebbs[ebb]
+        self.blocks[block]
             .params
             .remove(num as usize, &mut self.value_lists);
-        for index in num..(self.num_ebb_params(ebb) as u16) {
-            match self.values[self.ebbs[ebb]
+        for index in num..(self.num_block_params(block) as u16) {
+            match self.values[self.blocks[block]
                 .params
                 .get(index as usize, &self.value_lists)
                 .unwrap()]
             {
                 ValueData::Param { ref mut num, .. } => {
                     *num -= 1;
                 }
                 _ => panic!(
-                    "{} must be an EBB parameter",
-                    self.ebbs[ebb]
+                    "{} must be an block parameter",
+                    self.blocks[block]
                         .params
                         .get(index as usize, &self.value_lists)
                         .unwrap()
                 ),
             }
         }
     }
 
-    /// Append an existing value to `ebb`'s parameters.
+    /// Append an existing value to `block`'s parameters.
     ///
     /// The appended value can't already be attached to something else.
     ///
-    /// In almost all cases, you should be using `append_ebb_param()` instead of this method.
-    pub fn attach_ebb_param(&mut self, ebb: Ebb, param: Value) {
+    /// In almost all cases, you should be using `append_block_param()` instead of this method.
+    pub fn attach_block_param(&mut self, block: Block, param: Value) {
         debug_assert!(!self.value_is_attached(param));
-        let num = self.ebbs[ebb].params.push(param, &mut self.value_lists);
-        debug_assert!(num <= u16::MAX as usize, "Too many parameters on EBB");
+        let num = self.blocks[block].params.push(param, &mut self.value_lists);
+        debug_assert!(num <= u16::MAX as usize, "Too many parameters on block");
         let ty = self.value_type(param);
         self.values[param] = ValueData::Param {
             ty,
             num: num as u16,
-            ebb,
+            block,
         };
     }
 
-    /// Replace an EBB parameter with a new value of type `ty`.
+    /// Replace an block parameter with a new value of type `ty`.
     ///
-    /// The `old_value` must be an attached EBB parameter. It is removed from its place in the list
+    /// The `old_value` must be an attached block parameter. It is removed from its place in the list
     /// of parameters and replaced by a new value of type `new_type`. The new value gets the same
     /// position in the list, and other parameters are not disturbed.
     ///
     /// The old value is left detached, so it should probably be changed into something else.
     ///
     /// Returns the new value.
-    pub fn replace_ebb_param(&mut self, old_value: Value, new_type: Type) -> Value {
+    pub fn replace_block_param(&mut self, old_value: Value, new_type: Type) -> Value {
         // Create new value identical to the old one except for the type.
-        let (ebb, num) = if let ValueData::Param { num, ebb, .. } = self.values[old_value] {
-            (ebb, num)
+        let (block, num) = if let ValueData::Param { num, block, .. } = self.values[old_value] {
+            (block, num)
         } else {
-            panic!("{} must be an EBB parameter", old_value);
+            panic!("{} must be an block parameter", old_value);
         };
         let new_arg = self.make_value(ValueData::Param {
             ty: new_type,
             num,
-            ebb,
+            block,
         });
 
-        self.ebbs[ebb].params.as_mut_slice(&mut self.value_lists)[num as usize] = new_arg;
+        self.blocks[block]
+            .params
+            .as_mut_slice(&mut self.value_lists)[num as usize] = new_arg;
         new_arg
     }
 
-    /// Detach all the parameters from `ebb` and return them as a `ValueList`.
+    /// Detach all the parameters from `block` and return them as a `ValueList`.
     ///
-    /// This is a quite low-level operation. Sensible things to do with the detached EBB parameters
-    /// is to put them back on the same EBB with `attach_ebb_param()` or change them into aliases
+    /// This is a quite low-level operation. Sensible things to do with the detached block parameters
+    /// is to put them back on the same block with `attach_block_param()` or change them into aliases
     /// with `change_to_alias()`.
-    pub fn detach_ebb_params(&mut self, ebb: Ebb) -> ValueList {
-        self.ebbs[ebb].params.take()
+    pub fn detach_block_params(&mut self, block: Block) -> ValueList {
+        self.blocks[block].params.take()
     }
 }
 
-/// Contents of an extended basic block.
+/// Contents of a basic block.
 ///
-/// Parameters on an extended basic block are values that dominate everything in the EBB. All
-/// branches to this EBB must provide matching arguments, and the arguments to the entry EBB must
+/// Parameters on a basic block are values that dominate everything in the block. All
+/// branches to this block must provide matching arguments, and the arguments to the entry block must
 /// match the function arguments.
 #[derive(Clone)]
-struct EbbData {
-    /// List of parameters to this EBB.
+struct BlockData {
+    /// List of parameters to this block.
     params: ValueList,
 }
 
-impl EbbData {
+impl BlockData {
     fn new() -> Self {
         Self {
             params: ValueList::new(),
         }
     }
 }
 
 /// Object that can display an instruction.
@@ -1007,27 +1012,27 @@ impl DataFlowGraph {
                     self.set_value_type_for_parser(*v, ty);
                 }
             }
         }
 
         self.make_inst_results_reusing(inst, ctrl_typevar, reuse.iter().map(|x| Some(*x)))
     }
 
-    /// Similar to `append_ebb_param`, append a parameter with type `ty` to
-    /// `ebb`, but using value `val`. This is only for use by the parser to
+    /// Similar to `append_block_param`, append a parameter with type `ty` to
+    /// `block`, but using value `val`. This is only for use by the parser to
     /// create parameters with specific values.
     #[cold]
-    pub fn append_ebb_param_for_parser(&mut self, ebb: Ebb, ty: Type, val: Value) {
-        let num = self.ebbs[ebb].params.push(val, &mut self.value_lists);
-        assert!(num <= u16::MAX as usize, "Too many parameters on EBB");
+    pub fn append_block_param_for_parser(&mut self, block: Block, ty: Type, val: Value) {
+        let num = self.blocks[block].params.push(val, &mut self.value_lists);
+        assert!(num <= u16::MAX as usize, "Too many parameters on block");
         self.values[val] = ValueData::Param {
             ty,
             num: num as u16,
-            ebb,
+            block,
         };
     }
 
     /// Create a new value alias. This is only for use by the parser to create
     /// aliases with specific values, and the printer for testing.
     #[cold]
     pub fn make_value_alias_for_serialization(&mut self, src: Value, dest: Value) {
         assert_ne!(src, Value::reserved_value());
@@ -1160,123 +1165,123 @@ mod tests {
         let inst = dfg.make_inst(idata);
         assert_eq!(dfg.display_inst(inst, None).to_string(), "trap user0");
 
         // Result slice should be empty.
         assert_eq!(dfg.inst_results(inst), &[]);
     }
 
     #[test]
-    fn ebb() {
+    fn block() {
         let mut dfg = DataFlowGraph::new();
 
-        let ebb = dfg.make_ebb();
-        assert_eq!(ebb.to_string(), "ebb0");
-        assert_eq!(dfg.num_ebb_params(ebb), 0);
-        assert_eq!(dfg.ebb_params(ebb), &[]);
-        assert!(dfg.detach_ebb_params(ebb).is_empty());
-        assert_eq!(dfg.num_ebb_params(ebb), 0);
-        assert_eq!(dfg.ebb_params(ebb), &[]);
+        let block = dfg.make_block();
+        assert_eq!(block.to_string(), "block0");
+        assert_eq!(dfg.num_block_params(block), 0);
+        assert_eq!(dfg.block_params(block), &[]);
+        assert!(dfg.detach_block_params(block).is_empty());
+        assert_eq!(dfg.num_block_params(block), 0);
+        assert_eq!(dfg.block_params(block), &[]);
 
-        let arg1 = dfg.append_ebb_param(ebb, types::F32);
+        let arg1 = dfg.append_block_param(block, types::F32);
         assert_eq!(arg1.to_string(), "v0");
-        assert_eq!(dfg.num_ebb_params(ebb), 1);
-        assert_eq!(dfg.ebb_params(ebb), &[arg1]);
+        assert_eq!(dfg.num_block_params(block), 1);
+        assert_eq!(dfg.block_params(block), &[arg1]);
 
-        let arg2 = dfg.append_ebb_param(ebb, types::I16);
+        let arg2 = dfg.append_block_param(block, types::I16);
         assert_eq!(arg2.to_string(), "v1");
-        assert_eq!(dfg.num_ebb_params(ebb), 2);
-        assert_eq!(dfg.ebb_params(ebb), &[arg1, arg2]);
+        assert_eq!(dfg.num_block_params(block), 2);
+        assert_eq!(dfg.block_params(block), &[arg1, arg2]);
 
-        assert_eq!(dfg.value_def(arg1), ValueDef::Param(ebb, 0));
-        assert_eq!(dfg.value_def(arg2), ValueDef::Param(ebb, 1));
+        assert_eq!(dfg.value_def(arg1), ValueDef::Param(block, 0));
+        assert_eq!(dfg.value_def(arg2), ValueDef::Param(block, 1));
         assert_eq!(dfg.value_type(arg1), types::F32);
         assert_eq!(dfg.value_type(arg2), types::I16);
 
-        // Swap the two EBB parameters.
-        let vlist = dfg.detach_ebb_params(ebb);
-        assert_eq!(dfg.num_ebb_params(ebb), 0);
-        assert_eq!(dfg.ebb_params(ebb), &[]);
+        // Swap the two block parameters.
+        let vlist = dfg.detach_block_params(block);
+        assert_eq!(dfg.num_block_params(block), 0);
+        assert_eq!(dfg.block_params(block), &[]);
         assert_eq!(vlist.as_slice(&dfg.value_lists), &[arg1, arg2]);
-        dfg.attach_ebb_param(ebb, arg2);
-        let arg3 = dfg.append_ebb_param(ebb, types::I32);
-        dfg.attach_ebb_param(ebb, arg1);
-        assert_eq!(dfg.ebb_params(ebb), &[arg2, arg3, arg1]);
+        dfg.attach_block_param(block, arg2);
+        let arg3 = dfg.append_block_param(block, types::I32);
+        dfg.attach_block_param(block, arg1);
+        assert_eq!(dfg.block_params(block), &[arg2, arg3, arg1]);
     }
 
     #[test]
-    fn replace_ebb_params() {
+    fn replace_block_params() {
         let mut dfg = DataFlowGraph::new();
 
-        let ebb = dfg.make_ebb();
-        let arg1 = dfg.append_ebb_param(ebb, types::F32);
+        let block = dfg.make_block();
+        let arg1 = dfg.append_block_param(block, types::F32);
 
-        let new1 = dfg.replace_ebb_param(arg1, types::I64);
+        let new1 = dfg.replace_block_param(arg1, types::I64);
         assert_eq!(dfg.value_type(arg1), types::F32);
         assert_eq!(dfg.value_type(new1), types::I64);
-        assert_eq!(dfg.ebb_params(ebb), &[new1]);
+        assert_eq!(dfg.block_params(block), &[new1]);
 
-        dfg.attach_ebb_param(ebb, arg1);
-        assert_eq!(dfg.ebb_params(ebb), &[new1, arg1]);
+        dfg.attach_block_param(block, arg1);
+        assert_eq!(dfg.block_params(block), &[new1, arg1]);
 
-        let new2 = dfg.replace_ebb_param(arg1, types::I8);
+        let new2 = dfg.replace_block_param(arg1, types::I8);
         assert_eq!(dfg.value_type(arg1), types::F32);
         assert_eq!(dfg.value_type(new2), types::I8);
-        assert_eq!(dfg.ebb_params(ebb), &[new1, new2]);
+        assert_eq!(dfg.block_params(block), &[new1, new2]);
 
-        dfg.attach_ebb_param(ebb, arg1);
-        assert_eq!(dfg.ebb_params(ebb), &[new1, new2, arg1]);
+        dfg.attach_block_param(block, arg1);
+        assert_eq!(dfg.block_params(block), &[new1, new2, arg1]);
 
-        let new3 = dfg.replace_ebb_param(new2, types::I16);
+        let new3 = dfg.replace_block_param(new2, types::I16);
         assert_eq!(dfg.value_type(new1), types::I64);
         assert_eq!(dfg.value_type(new2), types::I8);
         assert_eq!(dfg.value_type(new3), types::I16);
-        assert_eq!(dfg.ebb_params(ebb), &[new1, new3, arg1]);
+        assert_eq!(dfg.block_params(block), &[new1, new3, arg1]);
     }
 
     #[test]
-    fn swap_remove_ebb_params() {
+    fn swap_remove_block_params() {
         let mut dfg = DataFlowGraph::new();
 
-        let ebb = dfg.make_ebb();
-        let arg1 = dfg.append_ebb_param(ebb, types::F32);
-        let arg2 = dfg.append_ebb_param(ebb, types::F32);
-        let arg3 = dfg.append_ebb_param(ebb, types::F32);
-        assert_eq!(dfg.ebb_params(ebb), &[arg1, arg2, arg3]);
+        let block = dfg.make_block();
+        let arg1 = dfg.append_block_param(block, types::F32);
+        let arg2 = dfg.append_block_param(block, types::F32);
+        let arg3 = dfg.append_block_param(block, types::F32);
+        assert_eq!(dfg.block_params(block), &[arg1, arg2, arg3]);
 
-        dfg.swap_remove_ebb_param(arg1);
+        dfg.swap_remove_block_param(arg1);
         assert_eq!(dfg.value_is_attached(arg1), false);
         assert_eq!(dfg.value_is_attached(arg2), true);
         assert_eq!(dfg.value_is_attached(arg3), true);
-        assert_eq!(dfg.ebb_params(ebb), &[arg3, arg2]);
-        dfg.swap_remove_ebb_param(arg2);
+        assert_eq!(dfg.block_params(block), &[arg3, arg2]);
+        dfg.swap_remove_block_param(arg2);
         assert_eq!(dfg.value_is_attached(arg2), false);
         assert_eq!(dfg.value_is_attached(arg3), true);
-        assert_eq!(dfg.ebb_params(ebb), &[arg3]);
-        dfg.swap_remove_ebb_param(arg3);
+        assert_eq!(dfg.block_params(block), &[arg3]);
+        dfg.swap_remove_block_param(arg3);
         assert_eq!(dfg.value_is_attached(arg3), false);
-        assert_eq!(dfg.ebb_params(ebb), &[]);
+        assert_eq!(dfg.block_params(block), &[]);
     }
 
     #[test]
     fn aliases() {
         use crate::ir::InstBuilder;
 
         let mut func = Function::new();
-        let ebb0 = func.dfg.make_ebb();
+        let block0 = func.dfg.make_block();
         let mut pos = FuncCursor::new(&mut func);
-        pos.insert_ebb(ebb0);
+        pos.insert_block(block0);
 
         // Build a little test program.
         let v1 = pos.ins().iconst(types::I32, 42);
 
         // Make sure we can resolve value aliases even when values is empty.
         assert_eq!(pos.func.dfg.resolve_aliases(v1), v1);
 
-        let arg0 = pos.func.dfg.append_ebb_param(ebb0, types::I32);
+        let arg0 = pos.func.dfg.append_block_param(block0, types::I32);
         let (s, c) = pos.ins().iadd_ifcout(v1, arg0);
         let iadd = match pos.func.dfg.value_def(s) {
             ValueDef::Result(i, 0) => i,
             _ => panic!(),
         };
 
         // Remove `c` from the result list.
         pos.func.dfg.clear_results(iadd);
--- a/third_party/rust/cranelift-codegen/src/ir/entities.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/entities.rs
@@ -1,12 +1,12 @@
 //! Cranelift IR entity references.
 //!
 //! Instructions in Cranelift IR need to reference other entities in the function. This can be other
-//! parts of the function like extended basic blocks or stack slots, or it can be external entities
+//! parts of the function like basic blocks or stack slots, or it can be external entities
 //! that are declared in the function preamble in the text format.
 //!
 //! These entity references in instruction operands are not implemented as Rust references both
 //! because Rust's ownership and mutability rules make it difficult, and because 64-bit pointers
 //! take up a lot of space, and we want a compact in-memory representation. Instead, entity
 //! references are structs wrapping a `u32` index into a table in the `Function` main data
 //! structure. There is a separate index type for each entity type, so we don't lose type safety.
 //!
@@ -20,30 +20,29 @@
 //! format.
 
 use crate::entity::entity_impl;
 use core::fmt;
 use core::u32;
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 
-/// An opaque reference to an [extended basic
-/// block](https://en.wikipedia.org/wiki/Extended_basic_block) in a
+/// An opaque reference to a [basic block](https://en.wikipedia.org/wiki/Basic_block) in a
 /// [`Function`](super::function::Function).
 ///
-/// You can get an `Ebb` using
-/// [`FunctionBuilder::create_ebb`](https://docs.rs/cranelift-frontend/*/cranelift_frontend/struct.FunctionBuilder.html#method.create_ebb)
+/// You can get a `Block` using
+/// [`FunctionBuilder::create_block`](https://docs.rs/cranelift-frontend/*/cranelift_frontend/struct.FunctionBuilder.html#method.create_block)
 ///
 /// While the order is stable, it is arbitrary and does not necessarily resemble the layout order.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct Ebb(u32);
-entity_impl!(Ebb, "ebb");
+pub struct Block(u32);
+entity_impl!(Block, "block");
 
-impl Ebb {
-    /// Create a new EBB reference from its number. This corresponds to the `ebbNN` representation.
+impl Block {
+    /// Create a new block reference from its number. This corresponds to the `blockNN` representation.
     ///
     /// This method is for use by the parser.
     pub fn with_number(n: u32) -> Option<Self> {
         if n < u32::MAX {
             Some(Self(n))
         } else {
             None
         }
@@ -366,18 +365,18 @@ impl Table {
     }
 }
 
 /// An opaque reference to any of the entities defined in this module that can appear in CLIF IR.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum AnyEntity {
     /// The whole function.
     Function,
-    /// An extended basic block.
-    Ebb(Ebb),
+    /// a basic block.
+    Block(Block),
     /// An instruction.
     Inst(Inst),
     /// An SSA value.
     Value(Value),
     /// A stack slot.
     StackSlot(StackSlot),
     /// A Global value.
     GlobalValue(GlobalValue),
@@ -392,17 +391,17 @@ pub enum AnyEntity {
     /// A table.
     Table(Table),
 }
 
 impl fmt::Display for AnyEntity {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Self::Function => write!(f, "function"),
-            Self::Ebb(r) => r.fmt(f),
+            Self::Block(r) => r.fmt(f),
             Self::Inst(r) => r.fmt(f),
             Self::Value(r) => r.fmt(f),
             Self::StackSlot(r) => r.fmt(f),
             Self::GlobalValue(r) => r.fmt(f),
             Self::JumpTable(r) => r.fmt(f),
             Self::FuncRef(r) => r.fmt(f),
             Self::SigRef(r) => r.fmt(f),
             Self::Heap(r) => r.fmt(f),
@@ -412,19 +411,19 @@ impl fmt::Display for AnyEntity {
 }
 
 impl fmt::Debug for AnyEntity {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         (self as &dyn fmt::Display).fmt(f)
     }
 }
 
-impl From<Ebb> for AnyEntity {
-    fn from(r: Ebb) -> Self {
-        Self::Ebb(r)
+impl From<Block> for AnyEntity {
+    fn from(r: Block) -> Self {
+        Self::Block(r)
     }
 }
 
 impl From<Inst> for AnyEntity {
     fn from(r: Inst) -> Self {
         Self::Inst(r)
     }
 }
--- a/third_party/rust/cranelift-codegen/src/ir/extname.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/extname.rs
@@ -27,18 +27,18 @@ pub enum ExternalName {
     /// A name in a user-defined symbol table. Cranelift does not interpret
     /// these numbers in any way.
     User {
         /// Arbitrary.
         namespace: u32,
         /// Arbitrary.
         index: u32,
     },
-    /// A test case function name of up to 10 ascii characters. This is
-    /// not intended to be used outside test cases.
+    /// A test case function name of up to a hardcoded amount of ascii
+    /// characters. This is not intended to be used outside test cases.
     TestCase {
         /// How many of the bytes in `ascii` are valid?
         length: u8,
         /// Ascii bytes of the name.
         ascii: [u8; TESTCASE_NAME_LENGTH],
     },
     /// A well-known runtime library function.
     LibCall(LibCall),
--- a/third_party/rust/cranelift-codegen/src/ir/function.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/function.rs
@@ -1,32 +1,29 @@
 //! Intermediate representation of a function.
 //!
-//! The `Function` struct defined in this module owns all of its extended basic blocks and
+//! The `Function` struct defined in this module owns all of its basic blocks and
 //! instructions.
 
 use crate::binemit::CodeOffset;
 use crate::entity::{PrimaryMap, SecondaryMap};
 use crate::ir;
+use crate::ir::{
+    Block, ExtFuncData, FuncRef, GlobalValue, GlobalValueData, Heap, HeapData, Inst, JumpTable,
+    JumpTableData, Opcode, SigRef, StackSlot, StackSlotData, Table, TableData,
+};
+use crate::ir::{BlockOffsets, FrameLayout, InstEncodings, SourceLocs, StackSlots, ValueLocations};
 use crate::ir::{DataFlowGraph, ExternalName, Layout, Signature};
-use crate::ir::{
-    Ebb, ExtFuncData, FuncRef, GlobalValue, GlobalValueData, Heap, HeapData, Inst, JumpTable,
-    JumpTableData, SigRef, StackSlot, StackSlotData, Table, TableData,
-};
-use crate::ir::{EbbOffsets, FrameLayout, InstEncodings, SourceLocs, StackSlots, ValueLocations};
 use crate::ir::{JumpTableOffsets, JumpTables};
 use crate::isa::{CallConv, EncInfo, Encoding, Legalize, TargetIsa};
 use crate::regalloc::{EntryRegDiversions, RegDiversions};
 use crate::value_label::ValueLabelsRanges;
 use crate::write::write_function;
 use core::fmt;
 
-#[cfg(feature = "basic-blocks")]
-use crate::ir::Opcode;
-
 /// A function.
 ///
 /// Functions can be cloned, but it is not a very fast operation.
 /// The clone will have all the same entity numbers as the original.
 #[derive(Clone)]
 pub struct Function {
     /// Name of this function. Mostly used by `.clif` files.
     pub name: ExternalName,
@@ -48,41 +45,41 @@ pub struct Function {
     pub heaps: PrimaryMap<ir::Heap, ir::HeapData>,
 
     /// Tables referenced.
     pub tables: PrimaryMap<ir::Table, ir::TableData>,
 
     /// Jump tables used in this function.
     pub jump_tables: JumpTables,
 
-    /// Data flow graph containing the primary definition of all instructions, EBBs and values.
+    /// Data flow graph containing the primary definition of all instructions, blocks and values.
     pub dfg: DataFlowGraph,
 
-    /// Layout of EBBs and instructions in the function body.
+    /// Layout of blocks and instructions in the function body.
     pub layout: Layout,
 
     /// Encoding recipe and bits for the legal instructions.
     /// Illegal instructions have the `Encoding::default()` value.
     pub encodings: InstEncodings,
 
     /// Location assigned to every value.
     pub locations: ValueLocations,
 
     /// Non-default locations assigned to value at the entry of basic blocks.
     ///
     /// At the entry of each basic block, we might have values which are not in their default
     /// ValueLocation. This field records these register-to-register moves as Diversions.
     pub entry_diversions: EntryRegDiversions,
 
-    /// Code offsets of the EBB headers.
+    /// Code offsets of the block headers.
     ///
     /// This information is only transiently available after the `binemit::relax_branches` function
     /// computes it, and it can easily be recomputed by calling that function. It is not included
     /// in the textual IR format.
-    pub offsets: EbbOffsets,
+    pub offsets: BlockOffsets,
 
     /// Code offsets of Jump Table headers.
     pub jt_offsets: JumpTableOffsets,
 
     /// Source locations.
     ///
     /// Track the original source location for each instruction. The source locations are not
     /// interpreted by Cranelift, only preserved.
@@ -205,42 +202,42 @@ impl Function {
 
     /// Find a presumed unique special-purpose function parameter value.
     ///
     /// Returns the value of the last `purpose` parameter, or `None` if no such parameter exists.
     pub fn special_param(&self, purpose: ir::ArgumentPurpose) -> Option<ir::Value> {
         let entry = self.layout.entry_block().expect("Function is empty");
         self.signature
             .special_param_index(purpose)
-            .map(|i| self.dfg.ebb_params(entry)[i])
+            .map(|i| self.dfg.block_params(entry)[i])
     }
 
-    /// Get an iterator over the instructions in `ebb`, including offsets and encoded instruction
+    /// Get an iterator over the instructions in `block`, including offsets and encoded instruction
     /// sizes.
     ///
     /// The iterator returns `(offset, inst, size)` tuples, where `offset` if the offset in bytes
     /// from the beginning of the function to the instruction, and `size` is the size of the
     /// instruction in bytes, or 0 for unencoded instructions.
     ///
     /// This function can only be used after the code layout has been computed by the
     /// `binemit::relax_branches()` function.
-    pub fn inst_offsets<'a>(&'a self, ebb: Ebb, encinfo: &EncInfo) -> InstOffsetIter<'a> {
+    pub fn inst_offsets<'a>(&'a self, block: Block, encinfo: &EncInfo) -> InstOffsetIter<'a> {
         assert!(
             !self.offsets.is_empty(),
             "Code layout must be computed first"
         );
         let mut divert = RegDiversions::new();
-        divert.at_ebb(&self.entry_diversions, ebb);
+        divert.at_block(&self.entry_diversions, block);
         InstOffsetIter {
             encinfo: encinfo.clone(),
             func: self,
             divert,
             encodings: &self.encodings,
-            offset: self.offsets[ebb],
-            iter: self.layout.ebb_insts(ebb),
+            offset: self.offsets[block],
+            iter: self.layout.block_insts(block),
         }
     }
 
     /// Wrapper around `encode` which assigns `inst` the resulting encoding.
     pub fn update_encoding(&mut self, inst: ir::Inst, isa: &dyn TargetIsa) -> Result<(), Legalize> {
         self.encode(inst, isa).map(|e| self.encodings[inst] = e)
     }
 
@@ -258,30 +255,29 @@ impl Function {
 
     /// Starts collection of frame layout information.
     pub fn collect_frame_layout_info(&mut self) {
         self.frame_layout = Some(FrameLayout::new());
     }
 
     /// Changes the destination of a jump or branch instruction.
     /// Does nothing if called with a non-jump or non-branch instruction.
-    pub fn change_branch_destination(&mut self, inst: Inst, new_dest: Ebb) {
+    pub fn change_branch_destination(&mut self, inst: Inst, new_dest: Block) {
         match self.dfg[inst].branch_destination_mut() {
             None => (),
             Some(inst_dest) => *inst_dest = new_dest,
         }
     }
 
-    /// Checks that the specified EBB can be encoded as a basic block.
+    /// Checks that the specified block can be encoded as a basic block.
     ///
     /// On error, returns the first invalid instruction and an error message.
-    #[cfg(feature = "basic-blocks")]
-    pub fn is_ebb_basic(&self, ebb: Ebb) -> Result<(), (Inst, &'static str)> {
+    pub fn is_block_basic(&self, block: Block) -> Result<(), (Inst, &'static str)> {
         let dfg = &self.dfg;
-        let inst_iter = self.layout.ebb_insts(ebb);
+        let inst_iter = self.layout.block_insts(block);
 
         // Ignore all instructions prior to the first branch.
         let mut inst_iter = inst_iter.skip_while(|&inst| !dfg[inst].opcode().is_branch());
 
         // A conditional branch is permitted in a basic block only when followed
         // by a terminal jump or fallthrough instruction.
         if let Some(_branch) = inst_iter.next() {
             if let Some(next) = inst_iter.next() {
--- a/third_party/rust/cranelift-codegen/src/ir/instructions.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/instructions.rs
@@ -8,17 +8,17 @@
 
 use alloc::vec::Vec;
 use core::fmt::{self, Display, Formatter};
 use core::ops::{Deref, DerefMut};
 use core::str::FromStr;
 
 use crate::ir;
 use crate::ir::types;
-use crate::ir::{Ebb, FuncRef, JumpTable, SigRef, Type, Value};
+use crate::ir::{Block, FuncRef, JumpTable, SigRef, Type, Value};
 use crate::isa;
 
 use crate::bitset::BitSet;
 use crate::entity;
 
 /// Some instructions use an external list of argument values because there is not enough space in
 /// the 16-byte `InstructionData` struct. These value lists are stored in a memory pool in
 /// `dfg.value_lists`.
@@ -159,17 +159,17 @@ impl Default for VariableArgs {
 
 /// Analyzing an instruction.
 ///
 /// Avoid large matches on instruction formats by using the methods defined here to examine
 /// instructions.
 impl InstructionData {
     /// Return information about the destination of a branch or jump instruction.
     ///
-    /// Any instruction that can transfer control to another EBB reveals its possible destinations
+    /// Any instruction that can transfer control to another block reveals its possible destinations
     /// here.
     pub fn analyze_branch<'a>(&'a self, pool: &'a ValueListPool) -> BranchInfo<'a> {
         match *self {
             Self::Jump {
                 destination,
                 ref args,
                 ..
             } => BranchInfo::SingleDest(destination, args.as_slice(pool)),
@@ -203,17 +203,17 @@ impl InstructionData {
             }
         }
     }
 
     /// Get the single destination of this branch instruction, if it is a single destination
     /// branch or jump.
     ///
     /// Multi-destination branches like `br_table` return `None`.
-    pub fn branch_destination(&self) -> Option<Ebb> {
+    pub fn branch_destination(&self) -> Option<Block> {
         match *self {
             Self::Jump { destination, .. }
             | Self::Branch { destination, .. }
             | Self::BranchInt { destination, .. }
             | Self::BranchFloat { destination, .. }
             | Self::BranchIcmp { destination, .. } => Some(destination),
             Self::BranchTable { .. } | Self::IndirectJump { .. } => None,
             _ => {
@@ -222,17 +222,17 @@ impl InstructionData {
             }
         }
     }
 
     /// Get a mutable reference to the single destination of this branch instruction, if it is a
     /// single destination branch or jump.
     ///
     /// Multi-destination branches like `br_table` return `None`.
-    pub fn branch_destination_mut(&mut self) -> Option<&mut Ebb> {
+    pub fn branch_destination_mut(&mut self) -> Option<&mut Block> {
         match *self {
             Self::Jump {
                 ref mut destination,
                 ..
             }
             | Self::Branch {
                 ref mut destination,
                 ..
@@ -274,25 +274,25 @@ impl InstructionData {
             }
         }
     }
 }
 
 /// Information about branch and jump instructions.
 pub enum BranchInfo<'a> {
     /// This is not a branch or jump instruction.
-    /// This instruction will not transfer control to another EBB in the function, but it may still
+    /// This instruction will not transfer control to another block in the function, but it may still
     /// affect control flow by returning or trapping.
     NotABranch,
 
-    /// This is a branch or jump to a single destination EBB, possibly taking value arguments.
-    SingleDest(Ebb, &'a [Value]),
+    /// This is a branch or jump to a single destination block, possibly taking value arguments.
+    SingleDest(Block, &'a [Value]),
 
-    /// This is a jump table branch which can have many destination EBBs and maybe one default EBB.
-    Table(JumpTable, Option<Ebb>),
+    /// This is a jump table branch which can have many destination blocks and maybe one default block.
+    Table(JumpTable, Option<Block>),
 }
 
 /// Information about call instructions.
 pub enum CallInfo<'a> {
     /// This is not a call instruction.
     NotACall,
 
     /// This is a direct call to an external function declared in the preamble. See
--- a/third_party/rust/cranelift-codegen/src/ir/jumptable.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/jumptable.rs
@@ -1,25 +1,25 @@
 //! Jump table representation.
 //!
 //! Jump tables are declared in the preamble and assigned an `ir::entities::JumpTable` reference.
 //! The actual table of destinations is stored in a `JumpTableData` struct defined in this module.
 
-use crate::ir::entities::Ebb;
+use crate::ir::entities::Block;
 use alloc::vec::Vec;
 use core::fmt::{self, Display, Formatter};
 use core::slice::{Iter, IterMut};
 
 /// Contents of a jump table.
 ///
 /// All jump tables use 0-based indexing and are densely populated.
 #[derive(Clone)]
 pub struct JumpTableData {
     // Table entries.
-    table: Vec<Ebb>,
+    table: Vec<Block>,
 }
 
 impl JumpTableData {
     /// Create a new empty jump table.
     pub fn new() -> Self {
         Self { table: Vec::new() }
     }
 
@@ -31,65 +31,65 @@ impl JumpTableData {
     }
 
     /// Get the number of table entries.
     pub fn len(&self) -> usize {
         self.table.len()
     }
 
     /// Append a table entry.
-    pub fn push_entry(&mut self, dest: Ebb) {
+    pub fn push_entry(&mut self, dest: Block) {
         self.table.push(dest)
     }
 
-    /// Checks if any of the entries branch to `ebb`.
-    pub fn branches_to(&self, ebb: Ebb) -> bool {
-        self.table.iter().any(|target_ebb| *target_ebb == ebb)
+    /// Checks if any of the entries branch to `block`.
+    pub fn branches_to(&self, block: Block) -> bool {
+        self.table.iter().any(|target_block| *target_block == block)
     }
 
     /// Access the whole table as a slice.
-    pub fn as_slice(&self) -> &[Ebb] {
+    pub fn as_slice(&self) -> &[Block] {
         self.table.as_slice()
     }
 
     /// Access the whole table as a mutable slice.
-    pub fn as_mut_slice(&mut self) -> &mut [Ebb] {
+    pub fn as_mut_slice(&mut self) -> &mut [Block] {
         self.table.as_mut_slice()
     }
 
     /// Returns an iterator over the table.
-    pub fn iter(&self) -> Iter<Ebb> {
+    pub fn iter(&self) -> Iter<Block> {
         self.table.iter()
     }
 
     /// Returns an iterator that allows modifying each value.
-    pub fn iter_mut(&mut self) -> IterMut<Ebb> {
+    pub fn iter_mut(&mut self) -> IterMut<Block> {
         self.table.iter_mut()
     }
 }
 
 impl Display for JumpTableData {
     fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
         write!(fmt, "jump_table [")?;
         match self.table.first() {
             None => (),
             Some(first) => write!(fmt, "{}", first)?,
         }
-        for ebb in self.table.iter().skip(1) {
-            write!(fmt, ", {}", ebb)?;
+        for block in self.table.iter().skip(1) {
+            write!(fmt, ", {}", block)?;
         }
         write!(fmt, "]")
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::JumpTableData;
     use crate::entity::EntityRef;
-    use crate::ir::Ebb;
+    use crate::ir::Block;
     use alloc::string::ToString;
 
     #[test]
     fn empty() {
         let jt = JumpTableData::new();
 
         assert_eq!(jt.as_slice().get(0), None);
         assert_eq!(jt.as_slice().get(10), None);
@@ -97,23 +97,23 @@ mod tests {
         assert_eq!(jt.to_string(), "jump_table []");
 
         let v = jt.as_slice();
         assert_eq!(v, []);
     }
 
     #[test]
     fn insert() {
-        let e1 = Ebb::new(1);
-        let e2 = Ebb::new(2);
+        let e1 = Block::new(1);
+        let e2 = Block::new(2);
 
         let mut jt = JumpTableData::new();
 
         jt.push_entry(e1);
         jt.push_entry(e2);
         jt.push_entry(e1);
 
-        assert_eq!(jt.to_string(), "jump_table [ebb1, ebb2, ebb1]");
+        assert_eq!(jt.to_string(), "jump_table [block1, block2, block1]");
 
         let v = jt.as_slice();
         assert_eq!(v, [e1, e2, e1]);
     }
 }
--- a/third_party/rust/cranelift-codegen/src/ir/layout.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/layout.rs
@@ -1,87 +1,87 @@
 //! Function layout.
 //!
-//! The order of extended basic blocks in a function and the order of instructions in an EBB is
+//! The order of basic blocks in a function and the order of instructions in an block is
 //! determined by the `Layout` data structure defined in this module.
 
 use crate::entity::SecondaryMap;
 use crate::ir::dfg::DataFlowGraph;
 use crate::ir::progpoint::{ExpandedProgramPoint, ProgramOrder};
-use crate::ir::{Ebb, Inst};
+use crate::ir::{Block, Inst};
 use crate::packed_option::PackedOption;
 use crate::timing;
 use core::cmp;
 use core::iter::{IntoIterator, Iterator};
 use log::debug;
 
-/// The `Layout` struct determines the layout of EBBs and instructions in a function. It does not
-/// contain definitions of instructions or EBBs, but depends on `Inst` and `Ebb` entity references
+/// The `Layout` struct determines the layout of blocks and instructions in a function. It does not
+/// contain definitions of instructions or blocks, but depends on `Inst` and `Block` entity references
 /// being defined elsewhere.
 ///
 /// This data structure determines:
 ///
-/// - The order of EBBs in the function.
-/// - Which EBB contains a given instruction.
-/// - The order of instructions with an EBB.
+/// - The order of blocks in the function.
+/// - Which block contains a given instruction.
+/// - The order of instructions with an block.
 ///
 /// While data dependencies are not recorded, instruction ordering does affect control
 /// dependencies, so part of the semantics of the program are determined by the layout.
 ///
 #[derive(Clone)]
 pub struct Layout {
-    /// Linked list nodes for the layout order of EBBs Forms a doubly linked list, terminated in
+    /// Linked list nodes for the layout order of blocks Forms a doubly linked list, terminated in
     /// both ends by `None`.
-    ebbs: SecondaryMap<Ebb, EbbNode>,
+    blocks: SecondaryMap<Block, BlockNode>,
 
-    /// Linked list nodes for the layout order of instructions. Forms a double linked list per EBB,
+    /// Linked list nodes for the layout order of instructions. Forms a double linked list per block,
     /// terminated in both ends by `None`.
     insts: SecondaryMap<Inst, InstNode>,
 
-    /// First EBB in the layout order, or `None` when no EBBs have been laid out.
-    first_ebb: Option<Ebb>,
+    /// First block in the layout order, or `None` when no blocks have been laid out.
+    first_block: Option<Block>,
 
-    /// Last EBB in the layout order, or `None` when no EBBs have been laid out.
-    last_ebb: Option<Ebb>,
+    /// Last block in the layout order, or `None` when no blocks have been laid out.
+    last_block: Option<Block>,
 }
 
 impl Layout {
     /// Create a new empty `Layout`.
     pub fn new() -> Self {
         Self {
-            ebbs: SecondaryMap::new(),
+            blocks: SecondaryMap::new(),
             insts: SecondaryMap::new(),
-            first_ebb: None,
-            last_ebb: None,
+            first_block: None,
+            last_block: None,
         }
     }
 
     /// Clear the layout.
     pub fn clear(&mut self) {
-        self.ebbs.clear();
+        self.blocks.clear();
         self.insts.clear();
-        self.first_ebb = None;
-        self.last_ebb = None;
+        self.first_block = None;
+        self.last_block = None;
     }
 
-    /// Returns the capacity of the `EbbData` map.
-    pub fn ebb_capacity(&self) -> usize {
-        self.ebbs.capacity()
+    /// Returns the capacity of the `BlockData` map.
+    pub fn block_capacity(&self) -> usize {
+        self.blocks.capacity()
     }
 }
 
 /// Sequence numbers.
 ///
-/// All instructions and EBBs are given a sequence number that can be used to quickly determine
+/// All instructions and blocks are given a sequence number that can be used to quickly determine
 /// their relative position in the layout. The sequence numbers are not contiguous, but are assigned
 /// like line numbers in BASIC: 10, 20, 30, ...
 ///
-/// The EBB sequence numbers are strictly increasing, and so are the instruction sequence numbers
-/// within an EBB. The instruction sequence numbers are all between the sequence number of their
-/// containing EBB and the following EBB.
+/// The block sequence numbers are strictly increasing, and so are the instruction sequence numbers
+/// within an block. The instruction sequence numbers are all between the sequence number of their
+/// containing block and the following block.
 ///
 /// The result is that sequence numbers work like BASIC line numbers for the textual form of the IR.
 type SequenceNumber = u32;
 
 /// Initial stride assigned to new sequence numbers.
 const MAJOR_STRIDE: SequenceNumber = 10;
 
 /// Secondary stride used when renumbering locally.
@@ -122,109 +122,109 @@ impl ProgramOrder for Layout {
         A: Into<ExpandedProgramPoint>,
         B: Into<ExpandedProgramPoint>,
     {
         let a_seq = self.seq(a);
         let b_seq = self.seq(b);
         a_seq.cmp(&b_seq)
     }
 
-    fn is_ebb_gap(&self, inst: Inst, ebb: Ebb) -> bool {
+    fn is_block_gap(&self, inst: Inst, block: Block) -> bool {
         let i = &self.insts[inst];
-        let e = &self.ebbs[ebb];
+        let e = &self.blocks[block];
 
-        i.next.is_none() && i.ebb == e.prev
+        i.next.is_none() && i.block == e.prev
     }
 }
 
 // Private methods for dealing with sequence numbers.
 impl Layout {
     /// Get the sequence number of a program point that must correspond to an entity in the layout.
     fn seq<PP: Into<ExpandedProgramPoint>>(&self, pp: PP) -> SequenceNumber {
-        // When `PP = Inst` or `PP = Ebb`, we expect this dynamic type check to be optimized out.
+        // When `PP = Inst` or `PP = Block`, we expect this dynamic type check to be optimized out.
         match pp.into() {
-            ExpandedProgramPoint::Ebb(ebb) => self.ebbs[ebb].seq,
+            ExpandedProgramPoint::Block(block) => self.blocks[block].seq,
             ExpandedProgramPoint::Inst(inst) => self.insts[inst].seq,
         }
     }
 
-    /// Get the last sequence number in `ebb`.
-    fn last_ebb_seq(&self, ebb: Ebb) -> SequenceNumber {
-        // Get the seq of the last instruction if it exists, otherwise use the EBB header seq.
-        self.ebbs[ebb]
+    /// Get the last sequence number in `block`.
+    fn last_block_seq(&self, block: Block) -> SequenceNumber {
+        // Get the seq of the last instruction if it exists, otherwise use the block header seq.
+        self.blocks[block]
             .last_inst
             .map(|inst| self.insts[inst].seq)
-            .unwrap_or(self.ebbs[ebb].seq)
+            .unwrap_or(self.blocks[block].seq)
     }
 
-    /// Assign a valid sequence number to `ebb` such that the numbers are still monotonic. This may
+    /// Assign a valid sequence number to `block` such that the numbers are still monotonic. This may
     /// require renumbering.
-    fn assign_ebb_seq(&mut self, ebb: Ebb) {
-        debug_assert!(self.is_ebb_inserted(ebb));
+    fn assign_block_seq(&mut self, block: Block) {
+        debug_assert!(self.is_block_inserted(block));
 
-        // Get the sequence number immediately before `ebb`, or 0.
-        let prev_seq = self.ebbs[ebb]
+        // Get the sequence number immediately before `block`, or 0.
+        let prev_seq = self.blocks[block]
             .prev
-            .map(|prev_ebb| self.last_ebb_seq(prev_ebb))
+            .map(|prev_block| self.last_block_seq(prev_block))
             .unwrap_or(0);
 
-        // Get the sequence number immediately following `ebb`.
-        let next_seq = if let Some(inst) = self.ebbs[ebb].first_inst.expand() {
+        // Get the sequence number immediately following `block`.
+        let next_seq = if let Some(inst) = self.blocks[block].first_inst.expand() {
             self.insts[inst].seq
-        } else if let Some(next_ebb) = self.ebbs[ebb].next.expand() {
-            self.ebbs[next_ebb].seq
+        } else if let Some(next_block) = self.blocks[block].next.expand() {
+            self.blocks[next_block].seq
         } else {
-            // There is nothing after `ebb`. We can just use a major stride.
-            self.ebbs[ebb].seq = prev_seq + MAJOR_STRIDE;
+            // There is nothing after `block`. We can just use a major stride.
+            self.blocks[block].seq = prev_seq + MAJOR_STRIDE;
             return;
         };
 
         // Check if there is room between these sequence numbers.
         if let Some(seq) = midpoint(prev_seq, next_seq) {
-            self.ebbs[ebb].seq = seq;
+            self.blocks[block].seq = seq;
         } else {
             // No available integers between `prev_seq` and `next_seq`. We have to renumber.
-            self.renumber_from_ebb(ebb, prev_seq + MINOR_STRIDE, prev_seq + LOCAL_LIMIT);
+            self.renumber_from_block(block, prev_seq + MINOR_STRIDE, prev_seq + LOCAL_LIMIT);
         }
     }
 
     /// Assign a valid sequence number to `inst` such that the numbers are still monotonic. This may
     /// require renumbering.
     fn assign_inst_seq(&mut self, inst: Inst) {
-        let ebb = self
-            .inst_ebb(inst)
+        let block = self
+            .inst_block(inst)
             .expect("inst must be inserted before assigning an seq");
 
         // Get the sequence number immediately before `inst`.
         let prev_seq = match self.insts[inst].prev.expand() {
             Some(prev_inst) => self.insts[prev_inst].seq,
-            None => self.ebbs[ebb].seq,
+            None => self.blocks[block].seq,
         };
 
         // Get the sequence number immediately following `inst`.
         let next_seq = if let Some(next_inst) = self.insts[inst].next.expand() {
             self.insts[next_inst].seq
-        } else if let Some(next_ebb) = self.ebbs[ebb].next.expand() {
-            self.ebbs[next_ebb].seq
+        } else if let Some(next_block) = self.blocks[block].next.expand() {
+            self.blocks[next_block].seq
         } else {
             // There is nothing after `inst`. We can just use a major stride.
             self.insts[inst].seq = prev_seq + MAJOR_STRIDE;
             return;
         };
 
         // Check if there is room between these sequence numbers.
         if let Some(seq) = midpoint(prev_seq, next_seq) {
             self.insts[inst].seq = seq;
         } else {
             // No available integers between `prev_seq` and `next_seq`. We have to renumber.
             self.renumber_from_inst(inst, prev_seq + MINOR_STRIDE, prev_seq + LOCAL_LIMIT);
         }
     }
 
-    /// Renumber instructions starting from `inst` until the end of the EBB or until numbers catch
+    /// Renumber instructions starting from `inst` until the end of the block or until numbers catch
     /// up.
     ///
     /// Return `None` if renumbering has caught up and the sequence is monotonic again. Otherwise
     /// return the last used sequence number.
     ///
     /// If sequence numbers exceed `limit`, switch to a full function renumbering and return `None`.
     fn renumber_insts(
         &mut self,
@@ -255,476 +255,481 @@ impl Layout {
                 self.full_renumber();
                 return None;
             }
 
             seq += MINOR_STRIDE;
         }
     }
 
-    /// Renumber starting from `ebb` to `seq` and continuing until the sequence numbers are
+    /// Renumber starting from `block` to `seq` and continuing until the sequence numbers are
     /// monotonic again.
-    fn renumber_from_ebb(&mut self, ebb: Ebb, first_seq: SequenceNumber, limit: SequenceNumber) {
-        let mut ebb = ebb;
+    fn renumber_from_block(
+        &mut self,
+        block: Block,
+        first_seq: SequenceNumber,
+        limit: SequenceNumber,
+    ) {
+        let mut block = block;
         let mut seq = first_seq;
 
         loop {
-            self.ebbs[ebb].seq = seq;
+            self.blocks[block].seq = seq;
 
-            // Renumber instructions in `ebb`. Stop when the numbers catch up.
-            if let Some(inst) = self.ebbs[ebb].first_inst.expand() {
+            // Renumber instructions in `block`. Stop when the numbers catch up.
+            if let Some(inst) = self.blocks[block].first_inst.expand() {
                 seq = match self.renumber_insts(inst, seq + MINOR_STRIDE, limit) {
                     Some(s) => s,
                     None => return,
                 }
             }
 
-            // Advance to the next EBB.
-            ebb = match self.ebbs[ebb].next.expand() {
+            // Advance to the next block.
+            block = match self.blocks[block].next.expand() {
                 Some(next) => next,
                 None => return,
             };
 
             // Stop renumbering once the numbers catch up.
-            if seq < self.ebbs[ebb].seq {
+            if seq < self.blocks[block].seq {
                 return;
             }
 
             seq += MINOR_STRIDE;
         }
     }
 
     /// Renumber starting from `inst` to `seq` and continuing until the sequence numbers are
     /// monotonic again.
     fn renumber_from_inst(&mut self, inst: Inst, first_seq: SequenceNumber, limit: SequenceNumber) {
         if let Some(seq) = self.renumber_insts(inst, first_seq, limit) {
-            // Renumbering spills over into next EBB.
-            if let Some(next_ebb) = self.ebbs[self.inst_ebb(inst).unwrap()].next.expand() {
-                self.renumber_from_ebb(next_ebb, seq + MINOR_STRIDE, limit);
+            // Renumbering spills over into next block.
+            if let Some(next_block) = self.blocks[self.inst_block(inst).unwrap()].next.expand() {
+                self.renumber_from_block(next_block, seq + MINOR_STRIDE, limit);
             }
         }
     }
 
-    /// Renumber all EBBs and instructions in the layout.
+    /// Renumber all blocks and instructions in the layout.
     ///
     /// This doesn't affect the position of anything, but it gives more room in the internal
     /// sequence numbers for inserting instructions later.
     fn full_renumber(&mut self) {
         let _tt = timing::layout_renumber();
         let mut seq = 0;
-        let mut next_ebb = self.first_ebb;
-        while let Some(ebb) = next_ebb {
-            self.ebbs[ebb].seq = seq;
+        let mut next_block = self.first_block;
+        while let Some(block) = next_block {
+            self.blocks[block].seq = seq;
             seq += MAJOR_STRIDE;
-            next_ebb = self.ebbs[ebb].next.expand();
+            next_block = self.blocks[block].next.expand();
 
-            let mut next_inst = self.ebbs[ebb].first_inst.expand();
+            let mut next_inst = self.blocks[block].first_inst.expand();
             while let Some(inst) = next_inst {
                 self.insts[inst].seq = seq;
                 seq += MAJOR_STRIDE;
                 next_inst = self.insts[inst].next.expand();
             }
         }
         debug!("Renumbered {} program points", seq / MAJOR_STRIDE);
     }
 }
 
-/// Methods for laying out EBBs.
+/// Methods for laying out blocks.
 ///
-/// An unknown EBB starts out as *not inserted* in the EBB layout. The layout is a linear order of
-/// inserted EBBs. Once an EBB has been inserted in the layout, instructions can be added. An EBB
+/// An unknown block starts out as *not inserted* in the block layout. The layout is a linear order of
+/// inserted blocks. Once an block has been inserted in the layout, instructions can be added. An block
 /// can only be removed from the layout when it is empty.
 ///
-/// Since every EBB must end with a terminator instruction which cannot fall through, the layout of
-/// EBBs do not affect the semantics of the program.
+/// Since every block must end with a terminator instruction which cannot fall through, the layout of
+/// blocks do not affect the semantics of the program.
 ///
 impl Layout {
-    /// Is `ebb` currently part of the layout?
-    pub fn is_ebb_inserted(&self, ebb: Ebb) -> bool {
-        Some(ebb) == self.first_ebb || self.ebbs[ebb].prev.is_some()
+    /// Is `block` currently part of the layout?
+    pub fn is_block_inserted(&self, block: Block) -> bool {
+        Some(block) == self.first_block || self.blocks[block].prev.is_some()
     }
 
-    /// Insert `ebb` as the last EBB in the layout.
-    pub fn append_ebb(&mut self, ebb: Ebb) {
+    /// Insert `block` as the last block in the layout.
+    pub fn append_block(&mut self, block: Block) {
         debug_assert!(
-            !self.is_ebb_inserted(ebb),
-            "Cannot append EBB that is already in the layout"
+            !self.is_block_inserted(block),
+            "Cannot append block that is already in the layout"
         );
         {
-            let node = &mut self.ebbs[ebb];
+            let node = &mut self.blocks[block];
             debug_assert!(node.first_inst.is_none() && node.last_inst.is_none());
-            node.prev = self.last_ebb.into();
+            node.prev = self.last_block.into();
             node.next = None.into();
         }
-        if let Some(last) = self.last_ebb {
-            self.ebbs[last].next = ebb.into();
+        if let Some(last) = self.last_block {
+            self.blocks[last].next = block.into();
         } else {
-            self.first_ebb = Some(ebb);
+            self.first_block = Some(block);
         }
-        self.last_ebb = Some(ebb);
-        self.assign_ebb_seq(ebb);
+        self.last_block = Some(block);
+        self.assign_block_seq(block);
     }
 
-    /// Insert `ebb` in the layout before the existing EBB `before`.
-    pub fn insert_ebb(&mut self, ebb: Ebb, before: Ebb) {
+    /// Insert `block` in the layout before the existing block `before`.
+    pub fn insert_block(&mut self, block: Block, before: Block) {
         debug_assert!(
-            !self.is_ebb_inserted(ebb),
-            "Cannot insert EBB that is already in the layout"
+            !self.is_block_inserted(block),
+            "Cannot insert block that is already in the layout"
         );
         debug_assert!(
-            self.is_ebb_inserted(before),
-            "EBB Insertion point not in the layout"
+            self.is_block_inserted(before),
+            "block Insertion point not in the layout"
         );
-        let after = self.ebbs[before].prev;
+        let after = self.blocks[before].prev;
         {
-            let node = &mut self.ebbs[ebb];
+            let node = &mut self.blocks[block];
             node.next = before.into();
             node.prev = after;
         }
-        self.ebbs[before].prev = ebb.into();
+        self.blocks[before].prev = block.into();
         match after.expand() {
-            None => self.first_ebb = Some(ebb),
-            Some(a) => self.ebbs[a].next = ebb.into(),
+            None => self.first_block = Some(block),
+            Some(a) => self.blocks[a].next = block.into(),
         }
-        self.assign_ebb_seq(ebb);
+        self.assign_block_seq(block);
     }
 
-    /// Insert `ebb` in the layout *after* the existing EBB `after`.
-    pub fn insert_ebb_after(&mut self, ebb: Ebb, after: Ebb) {
+    /// Insert `block` in the layout *after* the existing block `after`.
+    pub fn insert_block_after(&mut self, block: Block, after: Block) {
         debug_assert!(
-            !self.is_ebb_inserted(ebb),
-            "Cannot insert EBB that is already in the layout"
+            !self.is_block_inserted(block),
+            "Cannot insert block that is already in the layout"
         );
         debug_assert!(
-            self.is_ebb_inserted(after),
-            "EBB Insertion point not in the layout"
+            self.is_block_inserted(after),
+            "block Insertion point not in the layout"
         );
-        let before = self.ebbs[after].next;
+        let before = self.blocks[after].next;
         {
-            let node = &mut self.ebbs[ebb];
+            let node = &mut self.blocks[block];
             node.next = before;
             node.prev = after.into();
         }
-        self.ebbs[after].next = ebb.into();
+        self.blocks[after].next = block.into();
         match before.expand() {
-            None => self.last_ebb = Some(ebb),
-            Some(b) => self.ebbs[b].prev = ebb.into(),
+            None => self.last_block = Some(block),
+            Some(b) => self.blocks[b].prev = block.into(),
         }
-        self.assign_ebb_seq(ebb);
+        self.assign_block_seq(block);
     }
 
-    /// Remove `ebb` from the layout.
-    pub fn remove_ebb(&mut self, ebb: Ebb) {
-        debug_assert!(self.is_ebb_inserted(ebb), "EBB not in the layout");
-        debug_assert!(self.first_inst(ebb).is_none(), "EBB must be empty.");
+    /// Remove `block` from the layout.
+    pub fn remove_block(&mut self, block: Block) {
+        debug_assert!(self.is_block_inserted(block), "block not in the layout");
+        debug_assert!(self.first_inst(block).is_none(), "block must be empty.");
 
-        // Clear the `ebb` node and extract links.
+        // Clear the `block` node and extract links.
         let prev;
         let next;
         {
-            let n = &mut self.ebbs[ebb];
+            let n = &mut self.blocks[block];
             prev = n.prev;
             next = n.next;
             n.prev = None.into();
             n.next = None.into();
         }
-        // Fix up links to `ebb`.
+        // Fix up links to `block`.
         match prev.expand() {
-            None => self.first_ebb = next.expand(),
-            Some(p) => self.ebbs[p].next = next,
+            None => self.first_block = next.expand(),
+            Some(p) => self.blocks[p].next = next,
         }
         match next.expand() {
-            None => self.last_ebb = prev.expand(),
-            Some(n) => self.ebbs[n].prev = prev,
+            None => self.last_block = prev.expand(),
+            Some(n) => self.blocks[n].prev = prev,
         }
     }
 
-    /// Return an iterator over all EBBs in layout order.
-    pub fn ebbs(&self) -> Ebbs {
-        Ebbs {
+    /// Return an iterator over all blocks in layout order.
+    pub fn blocks(&self) -> Blocks {
+        Blocks {
             layout: self,
-            next: self.first_ebb,
+            next: self.first_block,
         }
     }
 
     /// Get the function's entry block.
-    /// This is simply the first EBB in the layout order.
-    pub fn entry_block(&self) -> Option<Ebb> {
-        self.first_ebb
+    /// This is simply the first block in the layout order.
+    pub fn entry_block(&self) -> Option<Block> {
+        self.first_block
     }
 
-    /// Get the last EBB in the layout.
-    pub fn last_ebb(&self) -> Option<Ebb> {
-        self.last_ebb
+    /// Get the last block in the layout.
+    pub fn last_block(&self) -> Option<Block> {
+        self.last_block
     }
 
-    /// Get the block preceding `ebb` in the layout order.
-    pub fn prev_ebb(&self, ebb: Ebb) -> Option<Ebb> {
-        self.ebbs[ebb].prev.expand()
+    /// Get the block preceding `block` in the layout order.
+    pub fn prev_block(&self, block: Block) -> Option<Block> {
+        self.blocks[block].prev.expand()
     }
 
-    /// Get the block following `ebb` in the layout order.
-    pub fn next_ebb(&self, ebb: Ebb) -> Option<Ebb> {
-        self.ebbs[ebb].next.expand()
+    /// Get the block following `block` in the layout order.
+    pub fn next_block(&self, block: Block) -> Option<Block> {
+        self.blocks[block].next.expand()
     }
 }
 
 #[derive(Clone, Debug, Default)]
-struct EbbNode {
-    prev: PackedOption<Ebb>,
-    next: PackedOption<Ebb>,
+struct BlockNode {
+    prev: PackedOption<Block>,
+    next: PackedOption<Block>,
     first_inst: PackedOption<Inst>,
     last_inst: PackedOption<Inst>,
     seq: SequenceNumber,
 }
 
-/// Iterate over EBBs in layout order. See `Layout::ebbs()`.
-pub struct Ebbs<'f> {
+/// Iterate over blocks in layout order. See `Layout::blocks()`.
+pub struct Blocks<'f> {
     layout: &'f Layout,
-    next: Option<Ebb>,
+    next: Option<Block>,
 }
 
-impl<'f> Iterator for Ebbs<'f> {
-    type Item = Ebb;
+impl<'f> Iterator for Blocks<'f> {
+    type Item = Block;
 
-    fn next(&mut self) -> Option<Ebb> {
+    fn next(&mut self) -> Option<Block> {
         match self.next {
-            Some(ebb) => {
-                self.next = self.layout.next_ebb(ebb);
-                Some(ebb)
+            Some(block) => {
+                self.next = self.layout.next_block(block);
+                Some(block)
             }
             None => None,
         }
     }
 }
 
 /// Use a layout reference in a for loop.
 impl<'f> IntoIterator for &'f Layout {
-    type Item = Ebb;
-    type IntoIter = Ebbs<'f>;
+    type Item = Block;
+    type IntoIter = Blocks<'f>;
 
-    fn into_iter(self) -> Ebbs<'f> {
-        self.ebbs()
+    fn into_iter(self) -> Blocks<'f> {
+        self.blocks()
     }
 }
 
 /// Methods for arranging instructions.
 ///
 /// An instruction starts out as *not inserted* in the layout. An instruction can be inserted into
-/// an EBB at a given position.
+/// an block at a given position.
 impl Layout {
-    /// Get the EBB containing `inst`, or `None` if `inst` is not inserted in the layout.
-    pub fn inst_ebb(&self, inst: Inst) -> Option<Ebb> {
-        self.insts[inst].ebb.into()
+    /// Get the block containing `inst`, or `None` if `inst` is not inserted in the layout.
+    pub fn inst_block(&self, inst: Inst) -> Option<Block> {
+        self.insts[inst].block.into()
     }
 
-    /// Get the EBB containing the program point `pp`. Panic if `pp` is not in the layout.
-    pub fn pp_ebb<PP>(&self, pp: PP) -> Ebb
+    /// Get the block containing the program point `pp`. Panic if `pp` is not in the layout.
+    pub fn pp_block<PP>(&self, pp: PP) -> Block
     where
         PP: Into<ExpandedProgramPoint>,
     {
         match pp.into() {
-            ExpandedProgramPoint::Ebb(ebb) => ebb,
+            ExpandedProgramPoint::Block(block) => block,
             ExpandedProgramPoint::Inst(inst) => {
-                self.inst_ebb(inst).expect("Program point not in layout")
+                self.inst_block(inst).expect("Program point not in layout")
             }
         }
     }
 
-    /// Append `inst` to the end of `ebb`.
-    pub fn append_inst(&mut self, inst: Inst, ebb: Ebb) {
-        debug_assert_eq!(self.inst_ebb(inst), None);
+    /// Append `inst` to the end of `block`.
+    pub fn append_inst(&mut self, inst: Inst, block: Block) {
+        debug_assert_eq!(self.inst_block(inst), None);
         debug_assert!(
-            self.is_ebb_inserted(ebb),
-            "Cannot append instructions to EBB not in layout"
+            self.is_block_inserted(block),
+            "Cannot append instructions to block not in layout"
         );
         {
-            let ebb_node = &mut self.ebbs[ebb];
+            let block_node = &mut self.blocks[block];
             {
                 let inst_node = &mut self.insts[inst];
-                inst_node.ebb = ebb.into();
-                inst_node.prev = ebb_node.last_inst;
+                inst_node.block = block.into();
+                inst_node.prev = block_node.last_inst;
                 debug_assert!(inst_node.next.is_none());
             }
-            if ebb_node.first_inst.is_none() {
-                ebb_node.first_inst = inst.into();
+            if block_node.first_inst.is_none() {
+                block_node.first_inst = inst.into();
             } else {
-                self.insts[ebb_node.last_inst.unwrap()].next = inst.into();
+                self.insts[block_node.last_inst.unwrap()].next = inst.into();
             }
-            ebb_node.last_inst = inst.into();
+            block_node.last_inst = inst.into();
         }
         self.assign_inst_seq(inst);
     }
 
-    /// Fetch an ebb's first instruction.
-    pub fn first_inst(&self, ebb: Ebb) -> Option<Inst> {
-        self.ebbs[ebb].first_inst.into()
+    /// Fetch an block's first instruction.
+    pub fn first_inst(&self, block: Block) -> Option<Inst> {
+        self.blocks[block].first_inst.into()
     }
 
-    /// Fetch an ebb's last instruction.
-    pub fn last_inst(&self, ebb: Ebb) -> Option<Inst> {
-        self.ebbs[ebb].last_inst.into()
+    /// Fetch an block's last instruction.
+    pub fn last_inst(&self, block: Block) -> Option<Inst> {
+        self.blocks[block].last_inst.into()
     }
 
     /// Fetch the instruction following `inst`.
     pub fn next_inst(&self, inst: Inst) -> Option<Inst> {
         self.insts[inst].next.expand()
     }
 
     /// Fetch the instruction preceding `inst`.
     pub fn prev_inst(&self, inst: Inst) -> Option<Inst> {
         self.insts[inst].prev.expand()
     }
 
-    /// Fetch the first instruction in an ebb's terminal branch group.
-    pub fn canonical_branch_inst(&self, dfg: &DataFlowGraph, ebb: Ebb) -> Option<Inst> {
+    /// Fetch the first instruction in an block's terminal branch group.
+    pub fn canonical_branch_inst(&self, dfg: &DataFlowGraph, block: Block) -> Option<Inst> {
         // Basic blocks permit at most two terminal branch instructions.
         // If two, the former is conditional and the latter is unconditional.
-        let last = self.last_inst(ebb)?;
+        let last = self.last_inst(block)?;
         if let Some(prev) = self.prev_inst(last) {
             if dfg[prev].opcode().is_branch() {
                 return Some(prev);
             }
         }
         Some(last)
     }
 
-    /// Insert `inst` before the instruction `before` in the same EBB.
+    /// Insert `inst` before the instruction `before` in the same block.
     pub fn insert_inst(&mut self, inst: Inst, before: Inst) {
-        debug_assert_eq!(self.inst_ebb(inst), None);
-        let ebb = self
-            .inst_ebb(before)
+        debug_assert_eq!(self.inst_block(inst), None);
+        let block = self
+            .inst_block(before)
             .expect("Instruction before insertion point not in the layout");
         let after = self.insts[before].prev;
         {
             let inst_node = &mut self.insts[inst];
-            inst_node.ebb = ebb.into();
+            inst_node.block = block.into();
             inst_node.next = before.into();
             inst_node.prev = after;
         }
         self.insts[before].prev = inst.into();
         match after.expand() {
-            None => self.ebbs[ebb].first_inst = inst.into(),
+            None => self.blocks[block].first_inst = inst.into(),
             Some(a) => self.insts[a].next = inst.into(),
         }
         self.assign_inst_seq(inst);
     }
 
     /// Remove `inst` from the layout.
     pub fn remove_inst(&mut self, inst: Inst) {
-        let ebb = self.inst_ebb(inst).expect("Instruction already removed.");
+        let block = self.inst_block(inst).expect("Instruction already removed.");
         // Clear the `inst` node and extract links.
         let prev;
         let next;
         {
             let n = &mut self.insts[inst];
             prev = n.prev;
             next = n.next;
-            n.ebb = None.into();
+            n.block = None.into();
             n.prev = None.into();
             n.next = None.into();
         }
         // Fix up links to `inst`.
         match prev.expand() {
-            None => self.ebbs[ebb].first_inst = next,
+            None => self.blocks[block].first_inst = next,
             Some(p) => self.insts[p].next = next,
         }
         match next.expand() {
-            None => self.ebbs[ebb].last_inst = prev,
+            None => self.blocks[block].last_inst = prev,
             Some(n) => self.insts[n].prev = prev,
         }
     }
 
-    /// Iterate over the instructions in `ebb` in layout order.
-    pub fn ebb_insts(&self, ebb: Ebb) -> Insts {
+    /// Iterate over the instructions in `block` in layout order.
+    pub fn block_insts(&self, block: Block) -> Insts {
         Insts {
             layout: self,
-            head: self.ebbs[ebb].first_inst.into(),
-            tail: self.ebbs[ebb].last_inst.into(),
+            head: self.blocks[block].first_inst.into(),
+            tail: self.blocks[block].last_inst.into(),
         }
     }
 
-    /// Split the EBB containing `before` in two.
+    /// Split the block containing `before` in two.
     ///
-    /// Insert `new_ebb` after the old EBB and move `before` and the following instructions to
-    /// `new_ebb`:
+    /// Insert `new_block` after the old block and move `before` and the following instructions to
+    /// `new_block`:
     ///
     /// ```text
-    /// old_ebb:
+    /// old_block:
     ///     i1
     ///     i2
     ///     i3 << before
     ///     i4
     /// ```
     /// becomes:
     ///
     /// ```text
-    /// old_ebb:
+    /// old_block:
     ///     i1
     ///     i2
-    /// new_ebb:
+    /// new_block:
     ///     i3 << before
     ///     i4
     /// ```
-    pub fn split_ebb(&mut self, new_ebb: Ebb, before: Inst) {
-        let old_ebb = self
-            .inst_ebb(before)
+    pub fn split_block(&mut self, new_block: Block, before: Inst) {
+        let old_block = self
+            .inst_block(before)
             .expect("The `before` instruction must be in the layout");
-        debug_assert!(!self.is_ebb_inserted(new_ebb));
+        debug_assert!(!self.is_block_inserted(new_block));
 
-        // Insert new_ebb after old_ebb.
-        let next_ebb = self.ebbs[old_ebb].next;
-        let last_inst = self.ebbs[old_ebb].last_inst;
+        // Insert new_block after old_block.
+        let next_block = self.blocks[old_block].next;
+        let last_inst = self.blocks[old_block].last_inst;
         {
-            let node = &mut self.ebbs[new_ebb];
-            node.prev = old_ebb.into();
-            node.next = next_ebb;
+            let node = &mut self.blocks[new_block];
+            node.prev = old_block.into();
+            node.next = next_block;
             node.first_inst = before.into();
             node.last_inst = last_inst;
         }
-        self.ebbs[old_ebb].next = new_ebb.into();
+        self.blocks[old_block].next = new_block.into();
 
         // Fix backwards link.
-        if Some(old_ebb) == self.last_ebb {
-            self.last_ebb = Some(new_ebb);
+        if Some(old_block) == self.last_block {
+            self.last_block = Some(new_block);
         } else {
-            self.ebbs[next_ebb.unwrap()].prev = new_ebb.into();
+            self.blocks[next_block.unwrap()].prev = new_block.into();
         }
 
         // Disconnect the instruction links.
         let prev_inst = self.insts[before].prev;
         self.insts[before].prev = None.into();
-        self.ebbs[old_ebb].last_inst = prev_inst;
+        self.blocks[old_block].last_inst = prev_inst;
         match prev_inst.expand() {
-            None => self.ebbs[old_ebb].first_inst = None.into(),
+            None => self.blocks[old_block].first_inst = None.into(),
             Some(pi) => self.insts[pi].next = None.into(),
         }
 
-        // Fix the instruction -> ebb pointers.
+        // Fix the instruction -> block pointers.
         let mut opt_i = Some(before);
         while let Some(i) = opt_i {
-            debug_assert_eq!(self.insts[i].ebb.expand(), Some(old_ebb));
-            self.insts[i].ebb = new_ebb.into();
+            debug_assert_eq!(self.insts[i].block.expand(), Some(old_block));
+            self.insts[i].block = new_block.into();
             opt_i = self.insts[i].next.into();
         }
 
-        self.assign_ebb_seq(new_ebb);
+        self.assign_block_seq(new_block);
     }
 }
 
 #[derive(Clone, Debug, Default)]
 struct InstNode {
-    /// The Ebb containing this instruction, or `None` if the instruction is not yet inserted.
-    ebb: PackedOption<Ebb>,
+    /// The Block containing this instruction, or `None` if the instruction is not yet inserted.
+    block: PackedOption<Block>,
     prev: PackedOption<Inst>,
     next: PackedOption<Inst>,
     seq: SequenceNumber,
 }
 
-/// Iterate over instructions in an EBB in layout order. See `Layout::ebb_insts()`.
+/// Iterate over instructions in an block in layout order. See `Layout::block_insts()`.
 pub struct Insts<'f> {
     layout: &'f Layout,
     head: Option<Inst>,
     tail: Option<Inst>,
 }
 
 impl<'f> Iterator for Insts<'f> {
     type Item = Inst;
@@ -758,17 +763,17 @@ impl<'f> DoubleEndedIterator for Insts<'
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::Layout;
     use crate::cursor::{Cursor, CursorPosition};
     use crate::entity::EntityRef;
-    use crate::ir::{Ebb, Inst, ProgramOrder, SourceLoc};
+    use crate::ir::{Block, Inst, ProgramOrder, SourceLoc};
     use alloc::vec::Vec;
     use core::cmp::Ordering;
 
     struct LayoutCursor<'f> {
         /// Borrowed function layout. Public so it can be re-borrowed from this cursor.
         pub layout: &'f mut Layout,
         pos: CursorPosition,
     }
@@ -805,86 +810,86 @@ mod tests {
         pub fn new(layout: &'f mut Layout) -> Self {
             Self {
                 layout,
                 pos: CursorPosition::Nowhere,
             }
         }
     }
 
-    fn verify(layout: &mut Layout, ebbs: &[(Ebb, &[Inst])]) {
-        // Check that EBBs are inserted and instructions belong the right places.
+    fn verify(layout: &mut Layout, blocks: &[(Block, &[Inst])]) {
+        // Check that blocks are inserted and instructions belong the right places.
         // Check forward linkage with iterators.
         // Check that layout sequence numbers are strictly monotonic.
         {
             let mut seq = 0;
-            let mut ebb_iter = layout.ebbs();
-            for &(ebb, insts) in ebbs {
-                assert!(layout.is_ebb_inserted(ebb));
-                assert_eq!(ebb_iter.next(), Some(ebb));
-                assert!(layout.ebbs[ebb].seq > seq);
-                seq = layout.ebbs[ebb].seq;
+            let mut block_iter = layout.blocks();
+            for &(block, insts) in blocks {
+                assert!(layout.is_block_inserted(block));
+                assert_eq!(block_iter.next(), Some(block));
+                assert!(layout.blocks[block].seq > seq);
+                seq = layout.blocks[block].seq;
 
-                let mut inst_iter = layout.ebb_insts(ebb);
+                let mut inst_iter = layout.block_insts(block);
                 for &inst in insts {
-                    assert_eq!(layout.inst_ebb(inst), Some(ebb));
+                    assert_eq!(layout.inst_block(inst), Some(block));
                     assert_eq!(inst_iter.next(), Some(inst));
                     assert!(layout.insts[inst].seq > seq);
                     seq = layout.insts[inst].seq;
                 }
                 assert_eq!(inst_iter.next(), None);
             }
-            assert_eq!(ebb_iter.next(), None);
+            assert_eq!(block_iter.next(), None);
         }
 
         // Check backwards linkage with a cursor.
         let mut cur = LayoutCursor::new(layout);
-        for &(ebb, insts) in ebbs.into_iter().rev() {
-            assert_eq!(cur.prev_ebb(), Some(ebb));
+        for &(block, insts) in blocks.into_iter().rev() {
+            assert_eq!(cur.prev_block(), Some(block));
             for &inst in insts.into_iter().rev() {
                 assert_eq!(cur.prev_inst(), Some(inst));
             }
             assert_eq!(cur.prev_inst(), None);
         }
-        assert_eq!(cur.prev_ebb(), None);
+        assert_eq!(cur.prev_block(), None);
     }
 
     #[test]
-    fn append_ebb() {
+    fn append_block() {
         let mut layout = Layout::new();
-        let e0 = Ebb::new(0);
-        let e1 = Ebb::new(1);
-        let e2 = Ebb::new(2);
+        let e0 = Block::new(0);
+        let e1 = Block::new(1);
+        let e2 = Block::new(2);
 
         {
             let imm = &layout;
-            assert!(!imm.is_ebb_inserted(e0));
-            assert!(!imm.is_ebb_inserted(e1));
+            assert!(!imm.is_block_inserted(e0));
+            assert!(!imm.is_block_inserted(e1));
         }
         verify(&mut layout, &[]);
 
-        layout.append_ebb(e1);
-        assert!(!layout.is_ebb_inserted(e0));
-        assert!(layout.is_ebb_inserted(e1));
-        assert!(!layout.is_ebb_inserted(e2));
-        let v: Vec<Ebb> = layout.ebbs().collect();
+        layout.append_block(e1);
+        assert!(!layout.is_block_inserted(e0));
+        assert!(layout.is_block_inserted(e1));
+        assert!(!layout.is_block_inserted(e2));
+        let v: Vec<Block> = layout.blocks().collect();
         assert_eq!(v, [e1]);
 
-        layout.append_ebb(e2);
-        assert!(!layout.is_ebb_inserted(e0));
-        assert!(layout.is_ebb_inserted(e1));
-        assert!(layout.is_ebb_inserted(e2));
-        let v: Vec<Ebb> = layout.ebbs().collect();
+        layout.append_block(e2);
+        assert!(!layout.is_block_inserted(e0));
+        assert!(layout.is_block_inserted(e1));
+        assert!(layout.is_block_inserted(e2));
+        let v: Vec<Block> = layout.blocks().collect();
         assert_eq!(v, [e1, e2]);
 
-        layout.append_ebb(e0);
-        assert!(layout.is_ebb_inserted(e0));
-        assert!(layout.is_ebb_inserted(e1));
-        assert!(layout.is_ebb_inserted(e2));
-        let v: Vec<Ebb> = layout.ebbs().collect();
+        layout.append_block(e0);
+        assert!(layout.is_block_inserted(e0));
+        assert!(layout.is_block_inserted(e1));
+        assert!(layout.is_block_inserted(e2));
+        let v: Vec<Block> = layout.blocks().collect();
         assert_eq!(v, [e1, e2, e0]);
 
         {
             let imm = &layout;
             let mut v = Vec::new();
             for e in imm {
                 v.push(e);
             }
@@ -894,121 +899,121 @@ mod tests {
         // Test cursor positioning.
         let mut cur = LayoutCursor::new(&mut layout);
         assert_eq!(cur.position(), CursorPosition::Nowhere);
         assert_eq!(cur.next_inst(), None);
         assert_eq!(cur.position(), CursorPosition::Nowhere);
         assert_eq!(cur.prev_inst(), None);
         assert_eq!(cur.position(), CursorPosition::Nowhere);
 
-        assert_eq!(cur.next_ebb(), Some(e1));
+        assert_eq!(cur.next_block(), Some(e1));
         assert_eq!(cur.position(), CursorPosition::Before(e1));
         assert_eq!(cur.next_inst(), None);
         assert_eq!(cur.position(), CursorPosition::After(e1));
         assert_eq!(cur.next_inst(), None);
         assert_eq!(cur.position(), CursorPosition::After(e1));
-        assert_eq!(cur.next_ebb(), Some(e2));
+        assert_eq!(cur.next_block(), Some(e2));
         assert_eq!(cur.prev_inst(), None);
         assert_eq!(cur.position(), CursorPosition::Before(e2));
-        assert_eq!(cur.next_ebb(), Some(e0));
-        assert_eq!(cur.next_ebb(), None);
+        assert_eq!(cur.next_block(), Some(e0));
+        assert_eq!(cur.next_block(), None);
         assert_eq!(cur.position(), CursorPosition::Nowhere);
 
-        // Backwards through the EBBs.
-        assert_eq!(cur.prev_ebb(), Some(e0));
+        // Backwards through the blocks.
+        assert_eq!(cur.prev_block(), Some(e0));
         assert_eq!(cur.position(), CursorPosition::After(e0));
-        assert_eq!(cur.prev_ebb(), Some(e2));
-        assert_eq!(cur.prev_ebb(), Some(e1));
-        assert_eq!(cur.prev_ebb(), None);
+        assert_eq!(cur.prev_block(), Some(e2));
+        assert_eq!(cur.prev_block(), Some(e1));
+        assert_eq!(cur.prev_block(), None);
         assert_eq!(cur.position(), CursorPosition::Nowhere);
     }
 
     #[test]
-    fn insert_ebb() {
+    fn insert_block() {
         let mut layout = Layout::new();
-        let e0 = Ebb::new(0);
-        let e1 = Ebb::new(1);
-        let e2 = Ebb::new(2);
+        let e0 = Block::new(0);
+        let e1 = Block::new(1);
+        let e2 = Block::new(2);
 
         {
             let imm = &layout;
-            assert!(!imm.is_ebb_inserted(e0));
-            assert!(!imm.is_ebb_inserted(e1));
+            assert!(!imm.is_block_inserted(e0));
+            assert!(!imm.is_block_inserted(e1));
 
-            let v: Vec<Ebb> = layout.ebbs().collect();
+            let v: Vec<Block> = layout.blocks().collect();
             assert_eq!(v, []);
         }
 
-        layout.append_ebb(e1);
-        assert!(!layout.is_ebb_inserted(e0));
-        assert!(layout.is_ebb_inserted(e1));
-        assert!(!layout.is_ebb_inserted(e2));
+        layout.append_block(e1);
+        assert!(!layout.is_block_inserted(e0));
+        assert!(layout.is_block_inserted(e1));
+        assert!(!layout.is_block_inserted(e2));
         verify(&mut layout, &[(e1, &[])]);
 
-        layout.insert_ebb(e2, e1);
-        assert!(!layout.is_ebb_inserted(e0));
-        assert!(layout.is_ebb_inserted(e1));
-        assert!(layout.is_ebb_inserted(e2));
+        layout.insert_block(e2, e1);
+        assert!(!layout.is_block_inserted(e0));
+        assert!(layout.is_block_inserted(e1));
+        assert!(layout.is_block_inserted(e2));
         verify(&mut layout, &[(e2, &[]), (e1, &[])]);
 
-        layout.insert_ebb(e0, e1);
-        assert!(layout.is_ebb_inserted(e0));
-        assert!(layout.is_ebb_inserted(e1));
-        assert!(layout.is_ebb_inserted(e2));
+        layout.insert_block(e0, e1);
+        assert!(layout.is_block_inserted(e0));
+        assert!(layout.is_block_inserted(e1));
+        assert!(layout.is_block_inserted(e2));
         verify(&mut layout, &[(e2, &[]), (e0, &[]), (e1, &[])]);
     }
 
     #[test]
-    fn insert_ebb_after() {
+    fn insert_block_after() {
         let mut layout = Layout::new();
-        let e0 = Ebb::new(0);
-        let e1 = Ebb::new(1);
-        let e2 = Ebb::new(2);
+        let e0 = Block::new(0);
+        let e1 = Block::new(1);
+        let e2 = Block::new(2);
 
-        layout.append_ebb(e1);
-        layout.insert_ebb_after(e2, e1);
+        layout.append_block(e1);
+        layout.insert_block_after(e2, e1);
         verify(&mut layout, &[(e1, &[]), (e2, &[])]);
 
-        layout.insert_ebb_after(e0, e1);
+        layout.insert_block_after(e0, e1);
         verify(&mut layout, &[(e1, &[]), (e0, &[]), (e2, &[])]);
     }
 
     #[test]
     fn append_inst() {
         let mut layout = Layout::new();
-        let e1 = Ebb::new(1);
+        let e1 = Block::new(1);
 
-        layout.append_ebb(e1);
-        let v: Vec<Inst> = layout.ebb_insts(e1).collect();
+        layout.append_block(e1);
+        let v: Vec<Inst> = layout.block_insts(e1).collect();
         assert_eq!(v, []);
 
         let i0 = Inst::new(0);
         let i1 = Inst::new(1);
         let i2 = Inst::new(2);
 
-        assert_eq!(layout.inst_ebb(i0), None);
-        assert_eq!(layout.inst_ebb(i1), None);
-        assert_eq!(layout.inst_ebb(i2), None);
+        assert_eq!(layout.inst_block(i0), None);
+        assert_eq!(layout.inst_block(i1), None);
+        assert_eq!(layout.inst_block(i2), None);
 
         layout.append_inst(i1, e1);
-        assert_eq!(layout.inst_ebb(i0), None);
-        assert_eq!(layout.inst_ebb(i1), Some(e1));
-        assert_eq!(layout.inst_ebb(i2), None);
-        let v: Vec<Inst> = layout.ebb_insts(e1).collect();
+        assert_eq!(layout.inst_block(i0), None);
+        assert_eq!(layout.inst_block(i1), Some(e1));
+        assert_eq!(layout.inst_block(i2), None);
+        let v: Vec<Inst> = layout.block_insts(e1).collect();
         assert_eq!(v, [i1]);
 
         layout.append_inst(i2, e1);
-        assert_eq!(layout.inst_ebb(i0), None);
-        assert_eq!(layout.inst_ebb(i1), Some(e1));
-        assert_eq!(layout.inst_ebb(i2), Some(e1));
-        let v: Vec<Inst> = layout.ebb_insts(e1).collect();
+        assert_eq!(layout.inst_block(i0), None);
+        assert_eq!(layout.inst_block(i1), Some(e1));
+        assert_eq!(layout.inst_block(i2), Some(e1));
+        let v: Vec<Inst> = layout.block_insts(e1).collect();
         assert_eq!(v, [i1, i2]);
 
         // Test double-ended instruction iterator.
-        let v: Vec<Inst> = layout.ebb_insts(e1).rev().collect();
+        let v: Vec<Inst> = layout.block_insts(e1).rev().collect();
         assert_eq!(v, [i2, i1]);
 
         layout.append_inst(i0, e1);
         verify(&mut layout, &[(e1, &[i1, i2, i0])]);
 
         // Test cursor positioning.
         let mut cur = LayoutCursor::new(&mut layout).at_top(e1);
         assert_eq!(cur.position(), CursorPosition::Before(e1));
@@ -1031,167 +1036,167 @@ mod tests {
         assert_eq!(cur.prev_inst(), Some(i1));
         assert_eq!(cur.prev_inst(), None);
         assert_eq!(cur.position(), CursorPosition::Before(e1));
 
         // Test remove_inst.
         cur.goto_inst(i2);
         assert_eq!(cur.remove_inst(), i2);
         verify(cur.layout, &[(e1, &[i1, i0])]);
-        assert_eq!(cur.layout.inst_ebb(i2), None);
+        assert_eq!(cur.layout.inst_block(i2), None);
         assert_eq!(cur.remove_inst(), i0);
         verify(cur.layout, &[(e1, &[i1])]);
-        assert_eq!(cur.layout.inst_ebb(i0), None);
+        assert_eq!(cur.layout.inst_block(i0), None);
         assert_eq!(cur.position(), CursorPosition::After(e1));
         cur.layout.remove_inst(i1);
         verify(cur.layout, &[(e1, &[])]);
-        assert_eq!(cur.layout.inst_ebb(i1), None);
+        assert_eq!(cur.layout.inst_block(i1), None);
     }
 
     #[test]
     fn insert_inst() {
         let mut layout = Layout::new();
-        let e1 = Ebb::new(1);
+        let e1 = Block::new(1);
 
-        layout.append_ebb(e1);
-        let v: Vec<Inst> = layout.ebb_insts(e1).collect();
+        layout.append_block(e1);
+        let v: Vec<Inst> = layout.block_insts(e1).collect();
         assert_eq!(v, []);
 
         let i0 = Inst::new(0);
         let i1 = Inst::new(1);
         let i2 = Inst::new(2);
 
-        assert_eq!(layout.inst_ebb(i0), None);
-        assert_eq!(layout.inst_ebb(i1), None);
-        assert_eq!(layout.inst_ebb(i2), None);
+        assert_eq!(layout.inst_block(i0), None);
+        assert_eq!(layout.inst_block(i1), None);
+        assert_eq!(layout.inst_block(i2), None);
 
         layout.append_inst(i1, e1);
-        assert_eq!(layout.inst_ebb(i0), None);
-        assert_eq!(layout.inst_ebb(i1), Some(e1));
-        assert_eq!(layout.inst_ebb(i2), None);
-        let v: Vec<Inst> = layout.ebb_insts(e1).collect();
+        assert_eq!(layout.inst_block(i0), None);
+        assert_eq!(layout.inst_block(i1), Some(e1));
+        assert_eq!(layout.inst_block(i2), None);
+        let v: Vec<Inst> = layout.block_insts(e1).collect();
         assert_eq!(v, [i1]);
 
         layout.insert_inst(i2, i1);
-        assert_eq!(layout.inst_ebb(i0), None);
-        assert_eq!(layout.inst_ebb(i1), Some(e1));
-        assert_eq!(layout.inst_ebb(i2), Some(e1));
-        let v: Vec<Inst> = layout.ebb_insts(e1).collect();
+        assert_eq!(layout.inst_block(i0), None);
+        assert_eq!(layout.inst_block(i1), Some(e1));
+        assert_eq!(layout.inst_block(i2), Some(e1));
+        let v: Vec<Inst> = layout.block_insts(e1).collect();
         assert_eq!(v, [i2, i1]);
 
         layout.insert_inst(i0, i1);
         verify(&mut layout, &[(e1, &[i2, i0, i1])]);
     }
 
     #[test]
-    fn multiple_ebbs() {
+    fn multiple_blocks() {
         let mut layout = Layout::new();
 
-        let e0 = Ebb::new(0);
-        let e1 = Ebb::new(1);
+        let e0 = Block::new(0);
+        let e1 = Block::new(1);
 
         assert_eq!(layout.entry_block(), None);
-        layout.append_ebb(e0);
+        layout.append_block(e0);
         assert_eq!(layout.entry_block(), Some(e0));
-        layout.append_ebb(e1);
+        layout.append_block(e1);
         assert_eq!(layout.entry_block(), Some(e0));
 
         let i0 = Inst::new(0);
         let i1 = Inst::new(1);
         let i2 = Inst::new(2);
         let i3 = Inst::new(3);
 
         layout.append_inst(i0, e0);
         layout.append_inst(i1, e0);
         layout.append_inst(i2, e1);
         layout.append_inst(i3, e1);
 
-        let v0: Vec<Inst> = layout.ebb_insts(e0).collect();
-        let v1: Vec<Inst> = layout.ebb_insts(e1).collect();
+        let v0: Vec<Inst> = layout.block_insts(e0).collect();
+        let v1: Vec<Inst> = layout.block_insts(e1).collect();
         assert_eq!(v0, [i0, i1]);
         assert_eq!(v1, [i2, i3]);
     }
 
     #[test]
-    fn split_ebb() {
+    fn split_block() {
         let mut layout = Layout::new();
 
-        let e0 = Ebb::new(0);
-        let e1 = Ebb::new(1);
-        let e2 = Ebb::new(2);
+        let e0 = Block::new(0);
+        let e1 = Block::new(1);
+        let e2 = Block::new(2);
 
         let i0 = Inst::new(0);
         let i1 = Inst::new(1);
         let i2 = Inst::new(2);
         let i3 = Inst::new(3);
 
-        layout.append_ebb(e0);
+        layout.append_block(e0);
         layout.append_inst(i0, e0);
-        assert_eq!(layout.inst_ebb(i0), Some(e0));
-        layout.split_ebb(e1, i0);
-        assert_eq!(layout.inst_ebb(i0), Some(e1));
+        assert_eq!(layout.inst_block(i0), Some(e0));
+        layout.split_block(e1, i0);
+        assert_eq!(layout.inst_block(i0), Some(e1));
 
         {
             let mut cur = LayoutCursor::new(&mut layout);
-            assert_eq!(cur.next_ebb(), Some(e0));
+            assert_eq!(cur.next_block(), Some(e0));
             assert_eq!(cur.next_inst(), None);
-            assert_eq!(cur.next_ebb(), Some(e1));
+            assert_eq!(cur.next_block(), Some(e1));
             assert_eq!(cur.next_inst(), Some(i0));
             assert_eq!(cur.next_inst(), None);
-            assert_eq!(cur.next_ebb(), None);
+            assert_eq!(cur.next_block(), None);
 
             // Check backwards links.
-            assert_eq!(cur.prev_ebb(), Some(e1));
+            assert_eq!(cur.prev_block(), Some(e1));
             assert_eq!(cur.prev_inst(), Some(i0));
             assert_eq!(cur.prev_inst(), None);
-            assert_eq!(cur.prev_ebb(), Some(e0));
+            assert_eq!(cur.prev_block(), Some(e0));
             assert_eq!(cur.prev_inst(), None);
-            assert_eq!(cur.prev_ebb(), None);
+            assert_eq!(cur.prev_block(), None);
         }
 
         layout.append_inst(i1, e0);
         layout.append_inst(i2, e0);
         layout.append_inst(i3, e0);
-        layout.split_ebb(e2, i2);
+        layout.split_block(e2, i2);
 
-        assert_eq!(layout.inst_ebb(i0), Some(e1));
-        assert_eq!(layout.inst_ebb(i1), Some(e0));
-        assert_eq!(layout.inst_ebb(i2), Some(e2));
-        assert_eq!(layout.inst_ebb(i3), Some(e2));
+        assert_eq!(layout.inst_block(i0), Some(e1));
+        assert_eq!(layout.inst_block(i1), Some(e0));
+        assert_eq!(layout.inst_block(i2), Some(e2));
+        assert_eq!(layout.inst_block(i3), Some(e2));
 
         {
             let mut cur = LayoutCursor::new(&mut layout);
-            assert_eq!(cur.next_ebb(), Some(e0));
+            assert_eq!(cur.next_block(), Some(e0));
             assert_eq!(cur.next_inst(), Some(i1));
             assert_eq!(cur.next_inst(), None);
-            assert_eq!(cur.next_ebb(), Some(e2));
+            assert_eq!(cur.next_block(), Some(e2));
             assert_eq!(cur.next_inst(), Some(i2));
             assert_eq!(cur.next_inst(), Some(i3));
             assert_eq!(cur.next_inst(), None);
-            assert_eq!(cur.next_ebb(), Some(e1));
+            assert_eq!(cur.next_block(), Some(e1));
             assert_eq!(cur.next_inst(), Some(i0));
             assert_eq!(cur.next_inst(), None);
-            assert_eq!(cur.next_ebb(), None);
+            assert_eq!(cur.next_block(), None);
 
-            assert_eq!(cur.prev_ebb(), Some(e1));
+            assert_eq!(cur.prev_block(), Some(e1));
             assert_eq!(cur.prev_inst(), Some(i0));
             assert_eq!(cur.prev_inst(), None);
-            assert_eq!(cur.prev_ebb(), Some(e2));
+            assert_eq!(cur.prev_block(), Some(e2));
             assert_eq!(cur.prev_inst(), Some(i3));
             assert_eq!(cur.prev_inst(), Some(i2));
             assert_eq!(cur.prev_inst(), None);
-            assert_eq!(cur.prev_ebb(), Some(e0));
+            assert_eq!(cur.prev_block(), Some(e0));
             assert_eq!(cur.prev_inst(), Some(i1));
             assert_eq!(cur.prev_inst(), None);
-            assert_eq!(cur.prev_ebb(), None);
+            assert_eq!(cur.prev_block(), None);
         }
 
         // Check `ProgramOrder`.
         assert_eq!(layout.cmp(e2, e2), Ordering::Equal);
         assert_eq!(layout.cmp(e2, i2), Ordering::Less);
         assert_eq!(layout.cmp(i3, i2), Ordering::Greater);
 
-        assert_eq!(layout.is_ebb_gap(i1, e2), true);
-        assert_eq!(layout.is_ebb_gap(i3, e1), true);
-        assert_eq!(layout.is_ebb_gap(i1, e1), false);
-        assert_eq!(layout.is_ebb_gap(i2, e1), false);
+        assert_eq!(layout.is_block_gap(i1, e2), true);
+        assert_eq!(layout.is_block_gap(i3, e1), true);
+        assert_eq!(layout.is_block_gap(i1, e1), false);
+        assert_eq!(layout.is_block_gap(i2, e1), false);
     }
 }
--- a/third_party/rust/cranelift-codegen/src/ir/libcall.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/libcall.rs
@@ -101,17 +101,17 @@ impl LibCall {
         })
     }
 }
 
 /// Get a function reference for `libcall` in `func`, following the signature
 /// for `inst`.
 ///
 /// If there is an existing reference, use it, otherwise make a new one.
-pub fn get_libcall_funcref(
+pub(crate) fn get_libcall_funcref(
     libcall: LibCall,
     call_conv: CallConv,
     func: &mut Function,
     inst: Inst,
     isa: &dyn TargetIsa,
 ) -> FuncRef {
     find_funcref(libcall, func)
         .unwrap_or_else(|| make_funcref_for_inst(libcall, call_conv, func, inst, isa))
--- a/third_party/rust/cranelift-codegen/src/ir/mod.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/mod.rs
@@ -9,17 +9,17 @@ mod extname;
 mod framelayout;
 pub mod function;
 mod globalvalue;
 mod heap;
 pub mod immediates;
 pub mod instructions;
 pub mod jumptable;
 pub mod layout;
-mod libcall;
+pub(crate) mod libcall;
 mod memflags;
 mod progpoint;
 mod sourceloc;
 pub mod stackslot;
 mod table;
 mod trapcode;
 pub mod types;
 mod valueloc;
@@ -28,33 +28,33 @@ mod valueloc;
 use serde::{Deserialize, Serialize};
 
 pub use crate::ir::builder::{
     InsertBuilder, InstBuilder, InstBuilderBase, InstInserterBase, ReplaceBuilder,
 };
 pub use crate::ir::constant::{ConstantData, ConstantOffset, ConstantPool};
 pub use crate::ir::dfg::{DataFlowGraph, ValueDef};
 pub use crate::ir::entities::{
-    Constant, Ebb, FuncRef, GlobalValue, Heap, Immediate, Inst, JumpTable, SigRef, StackSlot,
+    Block, Constant, FuncRef, GlobalValue, Heap, Immediate, Inst, JumpTable, SigRef, StackSlot,
     Table, Value,
 };
 pub use crate::ir::extfunc::{
     AbiParam, ArgumentExtension, ArgumentPurpose, ExtFuncData, Signature,
 };
 pub use crate::ir::extname::ExternalName;
 pub use crate::ir::framelayout::{FrameLayout, FrameLayoutChange, FrameLayoutChanges};
 pub use crate::ir::function::{DisplayFunctionAnnotations, Function};
 pub use crate::ir::globalvalue::GlobalValueData;
 pub use crate::ir::heap::{HeapData, HeapStyle};
 pub use crate::ir::instructions::{
     InstructionData, Opcode, ValueList, ValueListPool, VariableArgs,
 };
 pub use crate::ir::jumptable::JumpTableData;
 pub use crate::ir::layout::Layout;
-pub use crate::ir::libcall::{get_libcall_funcref, get_probestack_funcref, LibCall};
+pub use crate::ir::libcall::{get_probestack_funcref, LibCall};
 pub use crate::ir::memflags::MemFlags;
 pub use crate::ir::progpoint::{ExpandedProgramPoint, ProgramOrder, ProgramPoint};
 pub use crate::ir::sourceloc::SourceLoc;
 pub use crate::ir::stackslot::{StackLayoutInfo, StackSlotData, StackSlotKind, StackSlots};
 pub use crate::ir::table::TableData;
 pub use crate::ir::trapcode::TrapCode;
 pub use crate::ir::types::Type;
 pub use crate::ir::valueloc::{ArgumentLoc, ValueLoc};
@@ -68,18 +68,18 @@ use crate::isa;
 pub type ValueLocations = SecondaryMap<Value, ValueLoc>;
 
 /// Map of jump tables.
 pub type JumpTables = PrimaryMap<JumpTable, JumpTableData>;
 
 /// Map of instruction encodings.
 pub type InstEncodings = SecondaryMap<Inst, isa::Encoding>;
 
-/// Code offsets for EBBs.
-pub type EbbOffsets = SecondaryMap<Ebb, binemit::CodeOffset>;
+/// Code offsets for blocks.
+pub type BlockOffsets = SecondaryMap<Block, binemit::CodeOffset>;
 
 /// Code offsets for Jump Tables.
 pub type JumpTableOffsets = SecondaryMap<JumpTable, binemit::CodeOffset>;
 
 /// Source locations for instructions.
 pub type SourceLocs = SecondaryMap<Inst, SourceLoc>;
 
 /// Marked with a label value.
--- a/third_party/rust/cranelift-codegen/src/ir/progpoint.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/progpoint.rs
@@ -1,107 +1,107 @@
 //! Program points.
 
 use crate::entity::EntityRef;
-use crate::ir::{Ebb, Inst, ValueDef};
+use crate::ir::{Block, Inst, ValueDef};
 use core::cmp;
 use core::fmt;
 use core::u32;
 
 /// A `ProgramPoint` represents a position in a function where the live range of an SSA value can
 /// begin or end. It can be either:
 ///
 /// 1. An instruction or
-/// 2. An EBB header.
+/// 2. An block header.
 ///
 /// This corresponds more or less to the lines in the textual form of Cranelift IR.
 #[derive(PartialEq, Eq, Clone, Copy)]
 pub struct ProgramPoint(u32);
 
 impl From<Inst> for ProgramPoint {
     fn from(inst: Inst) -> Self {
         let idx = inst.index();
         debug_assert!(idx < (u32::MAX / 2) as usize);
         Self((idx * 2) as u32)
     }
 }
 
-impl From<Ebb> for ProgramPoint {
-    fn from(ebb: Ebb) -> Self {
-        let idx = ebb.index();
+impl From<Block> for ProgramPoint {
+    fn from(block: Block) -> Self {
+        let idx = block.index();
         debug_assert!(idx < (u32::MAX / 2) as usize);
         Self((idx * 2 + 1) as u32)
     }
 }
 
 impl From<ValueDef> for ProgramPoint {
     fn from(def: ValueDef) -> Self {
         match def {
             ValueDef::Result(inst, _) => inst.into(),
-            ValueDef::Param(ebb, _) => ebb.into(),
+            ValueDef::Param(block, _) => block.into(),
         }
     }
 }
 
 /// An expanded program point directly exposes the variants, but takes twice the space to
 /// represent.
 #[derive(PartialEq, Eq, Clone, Copy)]
 pub enum ExpandedProgramPoint {
     /// An instruction in the function.
     Inst(Inst),
-    /// An EBB header.
-    Ebb(Ebb),
+    /// An block header.
+    Block(Block),
 }
 
 impl ExpandedProgramPoint {
     /// Get the instruction we know is inside.
     pub fn unwrap_inst(self) -> Inst {
         match self {
             Self::Inst(x) => x,
-            Self::Ebb(x) => panic!("expected inst: {}", x),
+            Self::Block(x) => panic!("expected inst: {}", x),
         }
     }
 }
 
 impl From<Inst> for ExpandedProgramPoint {
     fn from(inst: Inst) -> Self {
         Self::Inst(inst)
     }
 }
 
-impl From<Ebb> for ExpandedProgramPoint {
-    fn from(ebb: Ebb) -> Self {
-        Self::Ebb(ebb)
+impl From<Block> for ExpandedProgramPoint {
+    fn from(block: Block) -> Self {
+        Self::Block(block)
     }
 }
 
 impl From<ValueDef> for ExpandedProgramPoint {
     fn from(def: ValueDef) -> Self {
         match def {
             ValueDef::Result(inst, _) => inst.into(),
-            ValueDef::Param(ebb, _) => ebb.into(),
+            ValueDef::Param(block, _) => block.into(),
         }
     }
 }
 
 impl From<ProgramPoint> for ExpandedProgramPoint {
     fn from(pp: ProgramPoint) -> Self {
         if pp.0 & 1 == 0 {
             Self::Inst(Inst::from_u32(pp.0 / 2))
         } else {
-            Self::Ebb(Ebb::from_u32(pp.0 / 2))
+            Self::Block(Block::from_u32(pp.0 / 2))
         }
     }
 }
 
 impl fmt::Display for ExpandedProgramPoint {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Self::Inst(x) => write!(f, "{}", x),
-            Self::Ebb(x) => write!(f, "{}", x),
+            Self::Block(x) => write!(f, "{}", x),
         }
     }
 }
 
 impl fmt::Display for ProgramPoint {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let epp: ExpandedProgramPoint = (*self).into();
         epp.fmt(f)
@@ -124,41 +124,41 @@ impl fmt::Debug for ProgramPoint {
 ///
 /// `ProgramPoint` objects don't carry enough information to be ordered independently, they need a
 /// context providing the program order.
 pub trait ProgramOrder {
     /// Compare the program points `a` and `b` relative to this program order.
     ///
     /// Return `Less` if `a` appears in the program before `b`.
     ///
-    /// This is declared as a generic such that it can be called with `Inst` and `Ebb` arguments
+    /// This is declared as a generic such that it can be called with `Inst` and `Block` arguments
     /// directly. Depending on the implementation, there is a good chance performance will be
     /// improved for those cases where the type of either argument is known statically.
     fn cmp<A, B>(&self, a: A, b: B) -> cmp::Ordering
     where
         A: Into<ExpandedProgramPoint>,
         B: Into<ExpandedProgramPoint>;
 
-    /// Is the range from `inst` to `ebb` just the gap between consecutive EBBs?
+    /// Is the range from `inst` to `block` just the gap between consecutive blocks?
     ///
-    /// This returns true if `inst` is the terminator in the EBB immediately before `ebb`.
-    fn is_ebb_gap(&self, inst: Inst, ebb: Ebb) -> bool;
+    /// This returns true if `inst` is the terminator in the block immediately before `block`.
+    fn is_block_gap(&self, inst: Inst, block: Block) -> bool;
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::entity::EntityRef;
-    use crate::ir::{Ebb, Inst};
+    use crate::ir::{Block, Inst};
     use alloc::string::ToString;
 
     #[test]
     fn convert() {
         let i5 = Inst::new(5);
-        let b3 = Ebb::new(3);
+        let b3 = Block::new(3);
 
         let pp1: ProgramPoint = i5.into();
         let pp2: ProgramPoint = b3.into();
 
         assert_eq!(pp1.to_string(), "inst5");
-        assert_eq!(pp2.to_string(), "ebb3");
+        assert_eq!(pp2.to_string(), "block3");
     }
 }
--- a/third_party/rust/cranelift-codegen/src/isa/constraints.rs
+++ b/third_party/rust/cranelift-codegen/src/isa/constraints.rs
@@ -90,17 +90,17 @@ pub enum ConstraintKind {
 /// Value operand constraints for an encoding recipe.
 #[derive(PartialEq, Clone)]
 pub struct RecipeConstraints {
     /// Constraints for the instruction's fixed value operands.
     ///
     /// If the instruction takes a variable number of operands, the register constraints for those
     /// operands must be computed dynamically.
     ///
-    /// - For branches and jumps, EBB arguments must match the expectations of the destination EBB.
+    /// - For branches and jumps, block arguments must match the expectations of the destination block.
     /// - For calls and returns, the calling convention ABI specifies constraints.
     pub ins: &'static [OperandConstraint],
 
     /// Constraints for the instruction's fixed results.
     ///
     /// If the instruction produces a variable number of results, it's probably a call and the
     /// constraints must be derived from the calling convention ABI.
     pub outs: &'static [OperandConstraint],
@@ -168,17 +168,17 @@ pub struct BranchRange {
     /// Number of bits in the signed byte displacement encoded in the instruction. This does not
     /// account for branches that can only target aligned addresses.
     pub bits: u8,
 }
 
 impl BranchRange {
     /// Determine if this branch range can represent the range from `branch` to `dest`, where
     /// `branch` is the code offset of the branch instruction itself and `dest` is the code offset
-    /// of the destination EBB header.
+    /// of the destination block header.
     ///
     /// This method does not detect if the range is larger than 2 GB.
     pub fn contains(self, branch: CodeOffset, dest: CodeOffset) -> bool {
         let d = dest.wrapping_sub(branch + CodeOffset::from(self.origin)) as i32;
         let s = 32 - self.bits;
         d == d << s >> s
     }
 }
--- a/third_party/rust/cranelift-codegen/src/isa/riscv/mod.rs
+++ b/third_party/rust/cranelift-codegen/src/isa/riscv/mod.rs
@@ -153,19 +153,19 @@ mod tests {
     fn test_64bitenc() {
         let shared_builder = settings::builder();
         let shared_flags = settings::Flags::new(shared_builder);
         let isa = isa::lookup(triple!("riscv64"))
             .unwrap()
             .finish(shared_flags);
 
         let mut func = Function::new();
-        let ebb = func.dfg.make_ebb();
-        let arg64 = func.dfg.append_ebb_param(ebb, types::I64);
-        let arg32 = func.dfg.append_ebb_param(ebb, types::I32);
+        let block = func.dfg.make_block();
+        let arg64 = func.dfg.append_block_param(block, types::I64);
+        let arg32 = func.dfg.append_block_param(block, types::I32);
 
         // Try to encode iadd_imm.i64 v1, -10.
         let inst64 = InstructionData::BinaryImm {
             opcode: Opcode::IaddImm,
             arg: arg64,
             imm: immediates::Imm64::new(-10),
         };
 
@@ -204,19 +204,19 @@ mod tests {
     fn test_32bitenc() {
         let shared_builder = settings::builder();
         let shared_flags = settings::Flags::new(shared_builder);
         let isa = isa::lookup(triple!("riscv32"))
             .unwrap()
             .finish(shared_flags);
 
         let mut func = Function::new();
-        let ebb = func.dfg.make_ebb();
-        let arg64 = func.dfg.append_ebb_param(ebb, types::I64);
-        let arg32 = func.dfg.append_ebb_param(ebb, types::I32);
+        let block = func.dfg.make_block();
+        let arg64 = func.dfg.append_block_param(block, types::I64);
+        let arg32 = func.dfg.append_block_param(block, types::I32);
 
         // Try to encode iadd_imm.i64 v1, -10.
         let inst64 = InstructionData::BinaryImm {
             opcode: Opcode::IaddImm,
             arg: arg64,
             imm: immediates::Imm64::new(-10),
         };
 
@@ -263,18 +263,18 @@ mod tests {
         // Set the supports_m stting which in turn enables the use_m predicate that unlocks
         // encodings for imul.
         let mut isa_builder = isa::lookup(triple!("riscv32")).unwrap();
         isa_builder.enable("supports_m").unwrap();
 
         let isa = isa_builder.finish(shared_flags);
 
         let mut func = Function::new();
-        let ebb = func.dfg.make_ebb();
-        let arg32 = func.dfg.append_ebb_param(ebb, types::I32);
+        let block = func.dfg.make_block();
+        let arg32 = func.dfg.append_block_param(block, types::I32);
 
         // Create an imul.i32 which is encodable in RV32M.
         let mul32 = InstructionData::Binary {
             opcode: Opcode::Imul,
             args: [arg32, arg32],
         };
         assert_eq!(
             encstr(&*isa, isa.encode(&func, &mul32, types::I32)),
--- a/third_party/rust/cranelift-codegen/src/isa/x86/abi.rs
+++ b/third_party/rust/cranelift-codegen/src/isa/x86/abi.rs
@@ -414,18 +414,18 @@ fn callee_saved_gprs_used(isa: &dyn Targ
     }
 
     // regmove and regfill instructions may temporarily divert values into other registers,
     // and these are not reflected in `func.locations`. Scan the function for such instructions
     // and note which callee-saved registers they use.
     //
     // TODO: Consider re-evaluating how regmove/regfill/regspill work and whether it's possible
     // to avoid this step.
-    for ebb in &func.layout {
-        for inst in func.layout.ebb_insts(ebb) {
+    for block in &func.layout {
+        for inst in func.layout.block_insts(block) {
             match func.dfg[inst] {
                 ir::instructions::InstructionData::RegMove { dst, .. }
                 | ir::instructions::InstructionData::RegFill { dst, .. } => {
                     if !used.is_avail(GPR, dst) {
                         used.free(GPR, dst);
                     }
                 }
                 _ => (),
@@ -546,18 +546,18 @@ fn fastcall_prologue_epilogue(func: &mut
 
     for csr in csrs.iter(GPR) {
         let csr_arg = ir::AbiParam::special_reg(reg_type, ir::ArgumentPurpose::CalleeSaved, csr);
         func.signature.params.push(csr_arg);
         func.signature.returns.push(csr_arg);
     }
 
     // Set up the cursor and insert the prologue
-    let entry_ebb = func.layout.entry_block().expect("missing entry block");
-    let mut pos = EncCursor::new(func, isa).at_first_insertion_point(entry_ebb);
+    let entry_block = func.layout.entry_block().expect("missing entry block");
+    let mut pos = EncCursor::new(func, isa).at_first_insertion_point(entry_block);
     let prologue_cfa_state =
         insert_common_prologue(&mut pos, local_stack_size, reg_type, &csrs, isa);
 
     // Reset the cursor and insert the epilogue
     let mut pos = pos.at_position(CursorPosition::Nowhere);
     insert_common_epilogues(
         &mut pos,
         local_stack_size,
@@ -607,18 +607,18 @@ fn system_v_prologue_epilogue(func: &mut
 
     for csr in csrs.iter(GPR) {
         let csr_arg = ir::AbiParam::special_reg(reg_type, ir::ArgumentPurpose::CalleeSaved, csr);
         func.signature.params.push(csr_arg);
         func.signature.returns.push(csr_arg);
     }
 
     // Set up the cursor and insert the prologue
-    let entry_ebb = func.layout.entry_block().expect("missing entry block");
-    let mut pos = EncCursor::new(func, isa).at_first_insertion_point(entry_ebb);
+    let entry_block = func.layout.entry_block().expect("missing entry block");
+    let mut pos = EncCursor::new(func, isa).at_first_insertion_point(entry_block);
     let prologue_cfa_state =
         insert_common_prologue(&mut pos, local_stack_size, reg_type, &csrs, isa);
 
     // Reset the cursor and insert the epilogue
     let mut pos = pos.at_position(CursorPosition::Nowhere);
     insert_common_epilogues(
         &mut pos,
         local_stack_size,
@@ -673,19 +673,19 @@ fn insert_common_prologue(
         ]
         .into_boxed_slice();
 
         Some(cfa_state)
     } else {
         None
     };
 
-    // Append param to entry EBB
-    let ebb = pos.current_ebb().expect("missing ebb under cursor");
-    let fp = pos.func.dfg.append_ebb_param(ebb, reg_type);
+    // Append param to entry block
+    let block = pos.current_block().expect("missing block under cursor");
+    let fp = pos.func.dfg.append_block_param(block, reg_type);
     pos.func.locations[fp] = ir::ValueLoc::Reg(RU::rbp as RegUnit);
 
     let push_fp_inst = pos.ins().x86_push(fp);
 
     if let Some(ref mut frame_layout) = pos.func.frame_layout {
         let cfa_state = cfa_state
             .as_mut()
             .expect("cfa state exists when recording frame layout");
@@ -722,18 +722,18 @@ fn insert_common_prologue(
                 reg: cfa_state.cf_ptr_reg,
                 offset: cfa_state.cf_ptr_offset,
             }]
             .into_boxed_slice(),
         );
     }
 
     for reg in csrs.iter(GPR) {
-        // Append param to entry EBB
-        let csr_arg = pos.func.dfg.append_ebb_param(ebb, reg_type);
+        // Append param to entry block
+        let csr_arg = pos.func.dfg.append_block_param(block, reg_type);
 
         // Assign it a location
         pos.func.locations[csr_arg] = ir::ValueLoc::Reg(reg);
 
         // Remember it so we can push it momentarily
         let reg_push_inst = pos.ins().x86_push(csr_arg);
 
         if let Some(ref mut frame_layout) = pos.func.frame_layout {
@@ -826,62 +826,46 @@ fn insert_stack_check(pos: &mut EncCurso
 fn insert_common_epilogues(
     pos: &mut EncCursor,
     stack_size: i64,
     reg_type: ir::types::Type,
     csrs: &RegisterSet,
     isa: &dyn TargetIsa,
     cfa_state: Option<CFAState>,
 ) {
-    while let Some(ebb) = pos.next_ebb() {
-        pos.goto_last_inst(ebb);
+    while let Some(block) = pos.next_block() {
+        pos.goto_last_inst(block);
         if let Some(inst) = pos.current_inst() {
             if pos.func.dfg[inst].opcode().is_return() {
-                if let (Some(ref mut frame_layout), ref func_layout) =
-                    (pos.func.frame_layout.as_mut(), &pos.func.layout)
-                {
-                    // Figure out if we need to insert end-of-function-aware frame layout information.
-                    let following_inst = func_layout
-                        .next_ebb(ebb)
-                        .and_then(|next_ebb| func_layout.first_inst(next_ebb));
-
-                    if let Some(following_inst) = following_inst {
-                        frame_layout
-                            .instructions
-                            .insert(inst, vec![FrameLayoutChange::Preserve].into_boxed_slice());
-                        frame_layout.instructions.insert(
-                            following_inst,
-                            vec![FrameLayoutChange::Restore].into_boxed_slice(),
-                        );
-                    }
-                }
-
+                let is_last = pos.func.layout.last_block() == Some(block);
                 insert_common_epilogue(
                     inst,
                     stack_size,
                     pos,
                     reg_type,
                     csrs,
                     isa,
+                    is_last,
                     cfa_state.clone(),
                 );
             }
         }
     }
 }
 
 /// Insert an epilogue given a specific `return` instruction.
 /// This is used by common calling conventions such as System V.
 fn insert_common_epilogue(
     inst: ir::Inst,
     stack_size: i64,
     pos: &mut EncCursor,
     reg_type: ir::types::Type,
     csrs: &RegisterSet,
     isa: &dyn TargetIsa,
+    is_last: bool,
     mut cfa_state: Option<CFAState>,
 ) {
     let word_size = isa.pointer_bytes() as isize;
     if stack_size > 0 {
         pos.ins().adjust_sp_up_imm(Imm64::new(stack_size));
     }
 
     // Pop all the callee-saved registers, stepping backward each time to
@@ -926,32 +910,45 @@ fn insert_common_epilogue(
         // Validity checks - if we accounted correctly, CFA state at a return will match CFA state
         // at the entry of a function.
         //
         // Current_depth starts assuming a return address is pushed, and cf_ptr_offset is one
         // pointer below current_depth.
         assert_eq!(cfa_state.current_depth, -word_size);
         assert_eq!(cfa_state.cf_ptr_offset, word_size);
 
+        // Inserting preserve CFA state operation after FP pop instructions.
         let new_cfa = FrameLayoutChange::CallFrameAddressAt {
             reg: cfa_state.cf_ptr_reg,
             offset: cfa_state.cf_ptr_offset,
         };
+        let new_cfa = if is_last {
+            vec![new_cfa]
+        } else {
+            vec![FrameLayoutChange::Preserve, new_cfa]
+        };
 
         frame_layout
             .instructions
             .entry(fp_pop_inst)
             .and_modify(|insts| {
                 *insts = insts
                     .iter()
                     .cloned()
-                    .chain(std::iter::once(new_cfa))
+                    .chain(new_cfa.clone().into_iter())
                     .collect::<Box<[_]>>();
             })
-            .or_insert_with(|| Box::new([new_cfa]));
+            .or_insert_with(|| new_cfa.into_boxed_slice());
+
+        if !is_last {
+            // Inserting restore CFA state operation after each return.
+            frame_layout
+                .instructions
+                .insert(inst, vec![FrameLayoutChange::Restore].into_boxed_slice());
+        }
     }
 }
 
 #[cfg(feature = "unwind")]
 pub fn emit_unwind_info(
     func: &ir::Function,
     isa: &dyn TargetIsa,
     kind: FrameUnwindKind,
--- a/third_party/rust/cranelift-codegen/src/isa/x86/binemit.rs
+++ b/third_party/rust/cranelift-codegen/src/isa/x86/binemit.rs
@@ -1,15 +1,15 @@
 //! Emitting binary x86 machine code.
 
 use super::enc_tables::{needs_offset, needs_sib_byte};
 use super::registers::RU;
 use crate::binemit::{bad_encoding, CodeSink, Reloc};
 use crate::ir::condcodes::{CondCode, FloatCC, IntCC};
-use crate::ir::{Constant, Ebb, Function, Inst, InstructionData, JumpTable, Opcode, TrapCode};
+use crate::ir::{Block, Constant, Function, Inst, InstructionData, JumpTable, Opcode, TrapCode};
 use crate::isa::{RegUnit, StackBase, StackBaseMask, StackRef, TargetIsa};
 use crate::regalloc::RegDiversions;
 
 use cranelift_codegen_shared::isa::x86::EncodingBits;
 
 include!(concat!(env!("OUT_DIR"), "/binemit-x86.rs"));
 
 // Convert a stack base to the corresponding register.
@@ -364,23 +364,23 @@ fn fcc2opc(cond: FloatCC) -> u16 {
         LessThanOrEqual |                  // LT|EQ
         UnorderedOrGreaterThan |           // UN|GT
         UnorderedOrGreaterThanOrEqual      // UN|GT|EQ
         => panic!("{} not supported", cond),
     }
 }
 
 /// Emit a single-byte branch displacement to `destination`.
-fn disp1<CS: CodeSink + ?Sized>(destination: Ebb, func: &Function, sink: &mut CS) {
+fn disp1<CS: CodeSink + ?Sized>(destination: Block, func: &Function, sink: &mut CS) {
     let delta = func.offsets[destination].wrapping_sub(sink.offset() + 1);
     sink.put1(delta as u8);
 }
 
 /// Emit a four-byte branch displacement to `destination`.
-fn disp4<CS: CodeSink + ?Sized>(destination: Ebb, func: &Function, sink: &mut CS) {
+fn disp4<CS: CodeSink + ?Sized>(destination: Block, func: &Function, sink: &mut CS) {
     let delta = func.offsets[destination].wrapping_sub(sink.offset() + 4);
     sink.put4(delta);
 }
 
 /// Emit a four-byte displacement to jump table `jt`.
 fn jt_disp4<CS: CodeSink + ?Sized>(jt: JumpTable, func: &Function, sink: &mut CS) {
     let delta = func.jt_offsets[jt].wrapping_sub(sink.offset() + 4);
     sink.put4(delta);
--- a/third_party/rust/cranelift-codegen/src/isa/x86/enc_tables.rs
+++ b/third_party/rust/cranelift-codegen/src/isa/x86/enc_tables.rs
@@ -248,17 +248,17 @@ fn expand_sdivrem(
         } => (args[0], args[1], false),
         ir::InstructionData::Binary {
             opcode: ir::Opcode::Srem,
             args,
         } => (args[0], args[1], true),
         _ => panic!("Need sdiv/srem: {}", func.dfg.display_inst(inst, None)),
     };
 
-    let old_ebb = func.layout.pp_ebb(inst);
+    let old_block = func.layout.pp_block(inst);
     let result = func.dfg.first_result(inst);
     let ty = func.dfg.value_type(result);
 
     let mut pos = FuncCursor::new(func).at_inst(inst);
     pos.use_srcloc(inst);
     pos.func.dfg.clear_results(inst);
 
     let avoid_div_traps = isa.flags().avoid_div_traps();
@@ -292,43 +292,43 @@ fn expand_sdivrem(
         } else {
             [Some(result), None]
         };
         pos.ins().with_results(reuse).x86_sdivmodx(x, xhi, y);
         pos.remove_inst();
         return;
     }
 
-    // EBB handling the nominal case.
-    let nominal = pos.func.dfg.make_ebb();
+    // block handling the nominal case.
+    let nominal = pos.func.dfg.make_block();
 
-    // EBB handling the -1 divisor case.
-    let minus_one = pos.func.dfg.make_ebb();
+    // block handling the -1 divisor case.
+    let minus_one = pos.func.dfg.make_block();
 
-    // Final EBB with one argument representing the final result value.
-    let done = pos.func.dfg.make_ebb();
+    // Final block with one argument representing the final result value.
+    let done = pos.func.dfg.make_block();
 
-    // Move the `inst` result value onto the `done` EBB.
-    pos.func.dfg.attach_ebb_param(done, result);
+    // Move the `inst` result value onto the `done` block.
+    pos.func.dfg.attach_block_param(done, result);
 
     // Start by checking for a -1 divisor which needs to be handled specially.
     let is_m1 = pos.ins().ifcmp_imm(y, -1);
     pos.ins().brif(IntCC::Equal, is_m1, minus_one, &[]);
     pos.ins().jump(nominal, &[]);
 
     // Now it is safe to execute the `x86_sdivmodx` instruction which will still trap on division
     // by zero.
-    pos.insert_ebb(nominal);
+    pos.insert_block(nominal);
     let xhi = pos.ins().sshr_imm(x, i64::from(ty.lane_bits()) - 1);
     let (quot, rem) = pos.ins().x86_sdivmodx(x, xhi, y);
     let divres = if is_srem { rem } else { quot };
     pos.ins().jump(done, &[divres]);
 
     // Now deal with the -1 divisor case.
-    pos.insert_ebb(minus_one);
+    pos.insert_block(minus_one);
     let m1_result = if is_srem {
         // x % -1 = 0.
         pos.ins().iconst(ty, 0)
     } else {
         // Explicitly check for overflow: Trap when x == INT_MIN.
         debug_assert!(avoid_div_traps, "Native trapping divide handled above");
         let f = pos.ins().ifcmp_imm(x, -1 << (ty.lane_bits() - 1));
         pos.ins()
@@ -337,22 +337,22 @@ fn expand_sdivrem(
         pos.ins().irsub_imm(x, 0)
     };
 
     // Recycle the original instruction as a jump.
     pos.func.dfg.replace(inst).jump(done, &[m1_result]);
 
     // Finally insert a label for the completion.
     pos.next_inst();
-    pos.insert_ebb(done);
+    pos.insert_block(done);
 
-    cfg.recompute_ebb(pos.func, old_ebb);
-    cfg.recompute_ebb(pos.func, nominal);
-    cfg.recompute_ebb(pos.func, minus_one);
-    cfg.recompute_ebb(pos.func, done);
+    cfg.recompute_block(pos.func, old_block);
+    cfg.recompute_block(pos.func, nominal);
+    cfg.recompute_block(pos.func, minus_one);
+    cfg.recompute_block(pos.func, done);
 }
 
 /// Expand the `udiv` and `urem` instructions using `x86_udivmodx`.
 fn expand_udivrem(
     inst: ir::Inst,
     func: &mut ir::Function,
     _cfg: &mut ControlFlowGraph,
     isa: &dyn TargetIsa,
@@ -416,99 +416,99 @@ fn expand_minmax(
             args,
         } => (args[0], args[1], ir::Opcode::X86Fmin, ir::Opcode::Bor),
         ir::InstructionData::Binary {
             opcode: ir::Opcode::Fmax,
             args,
         } => (args[0], args[1], ir::Opcode::X86Fmax, ir::Opcode::Band),
         _ => panic!("Expected fmin/fmax: {}", func.dfg.display_inst(inst, None)),
     };
-    let old_ebb = func.layout.pp_ebb(inst);
+    let old_block = func.layout.pp_block(inst);
 
     // We need to handle the following conditions, depending on how x and y compare:
     //
     // 1. LT or GT: The native `x86_opc` min/max instruction does what we need.
     // 2. EQ: We need to use `bitwise_opc` to make sure that
     //    fmin(0.0, -0.0) -> -0.0 and fmax(0.0, -0.0) -> 0.0.
     // 3. UN: We need to produce a quiet NaN that is canonical if the inputs are canonical.
 
-    // EBB handling case 1) where operands are ordered but not equal.
-    let one_ebb = func.dfg.make_ebb();
+    // block handling case 1) where operands are ordered but not equal.
+    let one_block = func.dfg.make_block();
 
-    // EBB handling case 3) where one operand is NaN.
-    let uno_ebb = func.dfg.make_ebb();
+    // block handling case 3) where one operand is NaN.
+    let uno_block = func.dfg.make_block();
 
-    // EBB that handles the unordered or equal cases 2) and 3).
-    let ueq_ebb = func.dfg.make_ebb();
+    // block that handles the unordered or equal cases 2) and 3).
+    let ueq_block = func.dfg.make_block();
 
-    // EBB handling case 2) where operands are ordered and equal.
-    let eq_ebb = func.dfg.make_ebb();
+    // block handling case 2) where operands are ordered and equal.
+    let eq_block = func.dfg.make_block();
 
-    // Final EBB with one argument representing the final result value.
-    let done = func.dfg.make_ebb();
+    // Final block with one argument representing the final result value.
+    let done = func.dfg.make_block();
 
     // The basic blocks are laid out to minimize branching for the common cases:
     //
     // 1) One branch not taken, one jump.
     // 2) One branch taken.
     // 3) Two branches taken, one jump.
 
-    // Move the `inst` result value onto the `done` EBB.
+    // Move the `inst` result value onto the `done` block.
     let result = func.dfg.first_result(inst);
     let ty = func.dfg.value_type(result);
     func.dfg.clear_results(inst);
-    func.dfg.attach_ebb_param(done, result);
+    func.dfg.attach_block_param(done, result);
 
     // Test for case 1) ordered and not equal.
     let mut pos = FuncCursor::new(func).at_inst(inst);
     pos.use_srcloc(inst);
     let cmp_ueq = pos.ins().fcmp(FloatCC::UnorderedOrEqual, x, y);
-    pos.ins().brnz(cmp_ueq, ueq_ebb, &[]);
-    pos.ins().jump(one_ebb, &[]);
+    pos.ins().brnz(cmp_ueq, ueq_block, &[]);
+    pos.ins().jump(one_block, &[]);
 
     // Handle the common ordered, not equal (LT|GT) case.
-    pos.insert_ebb(one_ebb);
+    pos.insert_block(one_block);
     let one_inst = pos.ins().Binary(x86_opc, ty, x, y).0;
     let one_result = pos.func.dfg.first_result(one_inst);
     pos.ins().jump(done, &[one_result]);
 
     // Case 3) Unordered.
     // We know that at least one operand is a NaN that needs to be propagated. We simply use an
     // `fadd` instruction which has the same NaN propagation semantics.
-    pos.insert_ebb(uno_ebb);
+    pos.insert_block(uno_block);
     let uno_result = pos.ins().fadd(x, y);
     pos.ins().jump(done, &[uno_result]);
 
     // Case 2) or 3).
-    pos.insert_ebb(ueq_ebb);
+    pos.insert_block(ueq_block);
     // Test for case 3) (UN) one value is NaN.
     // TODO: When we get support for flag values, we can reuse the above comparison.
     let cmp_uno = pos.ins().fcmp(FloatCC::Unordered, x, y);
-    pos.ins().brnz(cmp_uno, uno_ebb, &[]);
-    pos.ins().jump(eq_ebb, &[]);
+    pos.ins().brnz(cmp_uno, uno_block, &[]);
+    pos.ins().jump(eq_block, &[]);
 
     // We are now in case 2) where x and y compare EQ.
     // We need a bitwise operation to get the sign right.
-    pos.insert_ebb(eq_ebb);
+    pos.insert_block(eq_block);
     let bw_inst = pos.ins().Binary(bitwise_opc, ty, x, y).0;
     let bw_result = pos.func.dfg.first_result(bw_inst);
     // This should become a fall-through for this second most common case.
     // Recycle the original instruction as a jump.
     pos.func.dfg.replace(inst).jump(done, &[bw_result]);
 
     // Finally insert a label for the completion.
     pos.next_inst();
-    pos.insert_ebb(done);
+    pos.insert_block(done);
 
-    cfg.recompute_ebb(pos.func, old_ebb);
-    cfg.recompute_ebb(pos.func, one_ebb);
-    cfg.recompute_ebb(pos.func, uno_ebb);
-    cfg.recompute_ebb(pos.func, ueq_ebb);
-    cfg.recompute_ebb(pos.func, eq_ebb);
-    cfg.recompute_ebb(pos.func, done);
+    cfg.recompute_block(pos.func, old_block);
+    cfg.recompute_block(pos.func, one_block);
+    cfg.recompute_block(pos.func, uno_block);
+    cfg.recompute_block(pos.func, ueq_block);
+    cfg.recompute_block(pos.func, eq_block);
+    cfg.recompute_block(pos.func, done);
 }
 
 /// x86 has no unsigned-to-float conversions. We handle the easy case of zero-extending i32 to
 /// i64 with a pattern, the rest needs more code.
 fn expand_fcvt_from_uint(
     inst: ir::Inst,
     func: &mut ir::Function,
     cfg: &mut ControlFlowGraph,
@@ -535,63 +535,63 @@ fn expand_fcvt_from_uint(
             let wide = pos.ins().uextend(ir::types::I64, x);
             pos.func.dfg.replace(inst).fcvt_from_sint(ty, wide);
             return;
         }
         ir::types::I64 => {}
         _ => unimplemented!(),
     }
 
-    let old_ebb = pos.func.layout.pp_ebb(inst);
+    let old_block = pos.func.layout.pp_block(inst);
 
-    // EBB handling the case where x >= 0.
-    let poszero_ebb = pos.func.dfg.make_ebb();
+    // block handling the case where x >= 0.
+    let poszero_block = pos.func.dfg.make_block();
 
-    // EBB handling the case where x < 0.
-    let neg_ebb = pos.func.dfg.make_ebb();
+    // block handling the case where x < 0.
+    let neg_block = pos.func.dfg.make_block();
 
-    // Final EBB with one argument representing the final result value.
-    let done = pos.func.dfg.make_ebb();
+    // Final block with one argument representing the final result value.
+    let done = pos.func.dfg.make_block();
 
-    // Move the `inst` result value onto the `done` EBB.
+    // Move the `inst` result value onto the `done` block.
     pos.func.dfg.clear_results(inst);
-    pos.func.dfg.attach_ebb_param(done, result);
+    pos.func.dfg.attach_block_param(done, result);
 
     // If x as a signed int is not negative, we can use the existing `fcvt_from_sint` instruction.
     let is_neg = pos.ins().icmp_imm(IntCC::SignedLessThan, x, 0);
-    pos.ins().brnz(is_neg, neg_ebb, &[]);
-    pos.ins().jump(poszero_ebb, &[]);
+    pos.ins().brnz(is_neg, neg_block, &[]);
+    pos.ins().jump(poszero_block, &[]);
 
     // Easy case: just use a signed conversion.
-    pos.insert_ebb(poszero_ebb);
+    pos.insert_block(poszero_block);
     let posres = pos.ins().fcvt_from_sint(ty, x);
     pos.ins().jump(done, &[posres]);
 
     // Now handle the negative case.
-    pos.insert_ebb(neg_ebb);
+    pos.insert_block(neg_block);
 
     // Divide x by two to get it in range for the signed conversion, keep the LSB, and scale it
     // back up on the FP side.
     let ihalf = pos.ins().ushr_imm(x, 1);
     let lsb = pos.ins().band_imm(x, 1);
     let ifinal = pos.ins().bor(ihalf, lsb);
     let fhalf = pos.ins().fcvt_from_sint(ty, ifinal);
     let negres = pos.ins().fadd(fhalf, fhalf);
 
     // Recycle the original instruction as a jump.
     pos.func.dfg.replace(inst).jump(done, &[negres]);
 
     // Finally insert a label for the completion.
     pos.next_inst();
-    pos.insert_ebb(done);
+    pos.insert_block(done);
 
-    cfg.recompute_ebb(pos.func, old_ebb);
-    cfg.recompute_ebb(pos.func, poszero_ebb);
-    cfg.recompute_ebb(pos.func, neg_ebb);
-    cfg.recompute_ebb(pos.func, done);
+    cfg.recompute_block(pos.func, old_block);
+    cfg.recompute_block(pos.func, poszero_block);
+    cfg.recompute_block(pos.func, neg_block);
+    cfg.recompute_block(pos.func, done);
 }
 
 fn expand_fcvt_to_sint(
     inst: ir::Inst,
     func: &mut ir::Function,
     cfg: &mut ControlFlowGraph,
     _isa: &dyn TargetIsa,
 ) {
@@ -599,47 +599,47 @@ fn expand_fcvt_to_sint(
 
     let x = match func.dfg[inst] {
         ir::InstructionData::Unary {
             opcode: ir::Opcode::FcvtToSint,
             arg,
         } => arg,
         _ => panic!("Need fcvt_to_sint: {}", func.dfg.display_inst(inst, None)),
     };
-    let old_ebb = func.layout.pp_ebb(inst);
+    let old_block = func.layout.pp_block(inst);
     let xty = func.dfg.value_type(x);
     let result = func.dfg.first_result(inst);
     let ty = func.dfg.value_type(result);
 
-    // Final EBB after the bad value checks.
-    let done = func.dfg.make_ebb();
+    // Final block after the bad value checks.
+    let done = func.dfg.make_block();
 
-    // EBB for checking failure cases.
-    let maybe_trap_ebb = func.dfg.make_ebb();
+    // block for checking failure cases.
+    let maybe_trap_block = func.dfg.make_block();
 
     // The `x86_cvtt2si` performs the desired conversion, but it doesn't trap on NaN or overflow.
     // It produces an INT_MIN result instead.
     func.dfg.replace(inst).x86_cvtt2si(ty, x);
 
     let mut pos = FuncCursor::new(func).after_inst(inst);
     pos.use_srcloc(inst);
 
     let is_done = pos
         .ins()
         .icmp_imm(IntCC::NotEqual, result, 1 << (ty.lane_bits() - 1));
     pos.ins().brnz(is_done, done, &[]);
-    pos.ins().jump(maybe_trap_ebb, &[]);
+    pos.ins().jump(maybe_trap_block, &[]);
 
     // We now have the following possibilities:
     //
     // 1. INT_MIN was actually the correct conversion result.
     // 2. The input was NaN -> trap bad_toint
     // 3. The input was out of range -> trap int_ovf
     //
-    pos.insert_ebb(maybe_trap_ebb);
+    pos.insert_block(maybe_trap_block);
 
     // Check for NaN.
     let is_nan = pos.ins().fcmp(FloatCC::Unordered, x, x);
     pos.ins()
         .trapnz(is_nan, ir::TrapCode::BadConversionToInteger);
 
     // Check for case 1: INT_MIN is the correct result.
     // Determine the smallest floating point number that would convert to INT_MIN.
@@ -678,21 +678,21 @@ fn expand_fcvt_to_sint(
         ir::types::F32 => pos.ins().f32const(Ieee32::with_bits(0)),
         ir::types::F64 => pos.ins().f64const(Ieee64::with_bits(0)),
         _ => panic!("Can't convert {}", xty),
     };
     let overflow = pos.ins().fcmp(FloatCC::GreaterThanOrEqual, x, fzero);
     pos.ins().trapnz(overflow, ir::TrapCode::IntegerOverflow);
 
     pos.ins().jump(done, &[]);
-    pos.insert_ebb(done);
+    pos.insert_block(done);
 
-    cfg.recompute_ebb(pos.func, old_ebb);
-    cfg.recompute_ebb(pos.func, maybe_trap_ebb);
-    cfg.recompute_ebb(pos.func, done);
+    cfg.recompute_block(pos.func, old_block);
+    cfg.recompute_block(pos.func, maybe_trap_block);
+    cfg.recompute_block(pos.func, done);
 }
 
 fn expand_fcvt_to_sint_sat(
     inst: ir::Inst,
     func: &mut ir::Function,
     cfg: &mut ControlFlowGraph,
     _isa: &dyn TargetIsa,
 ) {
@@ -704,58 +704,58 @@ fn expand_fcvt_to_sint_sat(
             arg,
         } => arg,
         _ => panic!(
             "Need fcvt_to_sint_sat: {}",
             func.dfg.display_inst(inst, None)
         ),
     };
 
-    let old_ebb = func.layout.pp_ebb(inst);
+    let old_block = func.layout.pp_block(inst);
     let xty = func.dfg.value_type(x);
     let result = func.dfg.first_result(inst);
     let ty = func.dfg.value_type(result);
 
-    // Final EBB after the bad value checks.
-    let done_ebb = func.dfg.make_ebb();
-    let intmin_ebb = func.dfg.make_ebb();
-    let minsat_ebb = func.dfg.make_ebb();
-    let maxsat_ebb = func.dfg.make_ebb();
+    // Final block after the bad value checks.
+    let done_block = func.dfg.make_block();
+    let intmin_block = func.dfg.make_block();
+    let minsat_block = func.dfg.make_block();
+    let maxsat_block = func.dfg.make_block();
     func.dfg.clear_results(inst);
-    func.dfg.attach_ebb_param(done_ebb, result);
+    func.dfg.attach_block_param(done_block, result);
 
     let mut pos = FuncCursor::new(func).at_inst(inst);
     pos.use_srcloc(inst);
 
     // The `x86_cvtt2si` performs the desired conversion, but it doesn't trap on NaN or
     // overflow. It produces an INT_MIN result instead.
     let cvtt2si = pos.ins().x86_cvtt2si(ty, x);
 
     let is_done = pos
         .ins()
         .icmp_imm(IntCC::NotEqual, cvtt2si, 1 << (ty.lane_bits() - 1));
-    pos.ins().brnz(is_done, done_ebb, &[cvtt2si]);
-    pos.ins().jump(intmin_ebb, &[]);
+    pos.ins().brnz(is_done, done_block, &[cvtt2si]);
+    pos.ins().jump(intmin_block, &[]);
 
     // We now have the following possibilities:
     //
     // 1. INT_MIN was actually the correct conversion result.
     // 2. The input was NaN -> replace the result value with 0.
     // 3. The input was out of range -> saturate the result to the min/max value.
-    pos.insert_ebb(intmin_ebb);
+    pos.insert_block(intmin_block);
 
     // Check for NaN, which is truncated to 0.
     let zero = pos.ins().iconst(ty, 0);
     let is_nan = pos.ins().fcmp(FloatCC::Unordered, x, x);
-    pos.ins().brnz(is_nan, done_ebb, &[zero]);
-    pos.ins().jump(minsat_ebb, &[]);
+    pos.ins().brnz(is_nan, done_block, &[zero]);
+    pos.ins().jump(minsat_block, &[]);
 
     // Check for case 1: INT_MIN is the correct result.
     // Determine the smallest floating point number that would convert to INT_MIN.
-    pos.insert_ebb(minsat_ebb);
+    pos.insert_block(minsat_block);
     let mut overflow_cc = FloatCC::LessThan;
     let output_bits = ty.lane_bits();
     let flimit = match xty {
         ir::types::F32 =>
         // An f32 can represent `i16::min_value() - 1` exactly with precision to spare, so
         // there are values less than -2^(N-1) that convert correctly to INT_MIN.
         {
             pos.ins().f32const(if output_bits < 32 {
@@ -781,49 +781,49 @@ fn expand_fcvt_to_sint_sat(
 
     let overflow = pos.ins().fcmp(overflow_cc, x, flimit);
     let min_imm = match ty {
         ir::types::I32 => i32::min_value() as i64,
         ir::types::I64 => i64::min_value(),
         _ => panic!("Don't know the min value for {}", ty),
     };
     let min_value = pos.ins().iconst(ty, min_imm);
-    pos.ins().brnz(overflow, done_ebb, &[min_value]);
-    pos.ins().jump(maxsat_ebb, &[]);
+    pos.ins().brnz(overflow, done_block, &[min_value]);
+    pos.ins().jump(maxsat_block, &[]);
 
     // Finally, we could have a positive value that is too large.
-    pos.insert_ebb(maxsat_ebb);
+    pos.insert_block(maxsat_block);
     let fzero = match xty {
         ir::types::F32 => pos.ins().f32const(Ieee32::with_bits(0)),
         ir::types::F64 => pos.ins().f64const(Ieee64::with_bits(0)),
         _ => panic!("Can't convert {}", xty),
     };
 
     let max_imm = match ty {
         ir::types::I32 => i32::max_value() as i64,
         ir::types::I64 => i64::max_value(),
         _ => panic!("Don't know the max value for {}", ty),
     };
     let max_value = pos.ins().iconst(ty, max_imm);
 
     let overflow = pos.ins().fcmp(FloatCC::GreaterThanOrEqual, x, fzero);
-    pos.ins().brnz(overflow, done_ebb, &[max_value]);
+    pos.ins().brnz(overflow, done_block, &[max_value]);
 
     // Recycle the original instruction.
-    pos.func.dfg.replace(inst).jump(done_ebb, &[cvtt2si]);
+    pos.func.dfg.replace(inst).jump(done_block, &[cvtt2si]);
 
     // Finally insert a label for the completion.
     pos.next_inst();
-    pos.insert_ebb(done_ebb);
+    pos.insert_block(done_block);
 
-    cfg.recompute_ebb(pos.func, old_ebb);
-    cfg.recompute_ebb(pos.func, intmin_ebb);
-    cfg.recompute_ebb(pos.func, minsat_ebb);
-    cfg.recompute_ebb(pos.func, maxsat_ebb);
-    cfg.recompute_ebb(pos.func, done_ebb);
+    cfg.recompute_block(pos.func, old_block);
+    cfg.recompute_block(pos.func, intmin_block);
+    cfg.recompute_block(pos.func, minsat_block);
+    cfg.recompute_block(pos.func, maxsat_block);
+    cfg.recompute_block(pos.func, done_block);
 }
 
 fn expand_fcvt_to_uint(
     inst: ir::Inst,
     func: &mut ir::Function,
     cfg: &mut ControlFlowGraph,
     _isa: &dyn TargetIsa,
 ) {
@@ -832,92 +832,92 @@ fn expand_fcvt_to_uint(
     let x = match func.dfg[inst] {
         ir::InstructionData::Unary {
             opcode: ir::Opcode::FcvtToUint,
             arg,
         } => arg,
         _ => panic!("Need fcvt_to_uint: {}", func.dfg.display_inst(inst, None)),
     };
 
-    let old_ebb = func.layout.pp_ebb(inst);
+    let old_block = func.layout.pp_block(inst);
     let xty = func.dfg.value_type(x);
     let result = func.dfg.first_result(inst);
     let ty = func.dfg.value_type(result);
 
-    // EBB handle numbers < 2^(N-1).
-    let below_uint_max_ebb = func.dfg.make_ebb();
+    // block handle numbers < 2^(N-1).
+    let below_uint_max_block = func.dfg.make_block();
 
-    // EBB handle numbers < 0.
-    let below_zero_ebb = func.dfg.make_ebb();
+    // block handle numbers < 0.
+    let below_zero_block = func.dfg.make_block();
 
-    // EBB handling numbers >= 2^(N-1).
-    let large = func.dfg.make_ebb();
+    // block handling numbers >= 2^(N-1).
+    let large = func.dfg.make_block();
 
-    // Final EBB after the bad value checks.
-    let done = func.dfg.make_ebb();
+    // Final block after the bad value checks.
+    let done = func.dfg.make_block();
 
-    // Move the `inst` result value onto the `done` EBB.
+    // Move the `inst` result value onto the `done` block.
     func.dfg.clear_results(inst);
-    func.dfg.attach_ebb_param(done, result);
+    func.dfg.attach_block_param(done, result);
 
     let mut pos = FuncCursor::new(func).at_inst(inst);
     pos.use_srcloc(inst);
 
     // Start by materializing the floating point constant 2^(N-1) where N is the number of bits in
     // the destination integer type.
     let pow2nm1 = match xty {
         ir::types::F32 => pos.ins().f32const(Ieee32::pow2(ty.lane_bits() - 1)),
         ir::types::F64 => pos.ins().f64const(Ieee64::pow2(ty.lane_bits() - 1)),
         _ => panic!("Can't convert {}", xty),
     };
     let is_large = pos.ins().ffcmp(x, pow2nm1);
     pos.ins()
         .brff(FloatCC::GreaterThanOrEqual, is_large, large, &[]);
-    pos.ins().jump(below_uint_max_ebb, &[]);
+    pos.ins().jump(below_uint_max_block, &[]);
 
     // We need to generate a specific trap code when `x` is NaN, so reuse the flags from the
     // previous comparison.
-    pos.insert_ebb(below_uint_max_ebb);
+    pos.insert_block(below_uint_max_block);
     pos.ins().trapff(
         FloatCC::Unordered,
         is_large,
         ir::TrapCode::BadConversionToInteger,
     );
 
     // Now we know that x < 2^(N-1) and not NaN.
     let sres = pos.ins().x86_cvtt2si(ty, x);
     let is_neg = pos.ins().ifcmp_imm(sres, 0);
     pos.ins()
         .brif(IntCC::SignedGreaterThanOrEqual, is_neg, done, &[sres]);
-    pos.ins().jump(below_zero_ebb, &[]);
+    pos.ins().jump(below_zero_block, &[]);
 
-    pos.insert_ebb(below_zero_ebb);
+    pos.insert_block(below_zero_block);
     pos.ins().trap(ir::TrapCode::IntegerOverflow);
 
     // Handle the case where x >= 2^(N-1) and not NaN.
-    pos.insert_ebb(large);
+    pos.insert_block(large);
     let adjx = pos.ins().fsub(x, pow2nm1);
     let lres = pos.ins().x86_cvtt2si(ty, adjx);
     let is_neg = pos.ins().ifcmp_imm(lres, 0);
     pos.ins()
         .trapif(IntCC::SignedLessThan, is_neg, ir::TrapCode::IntegerOverflow);
     let lfinal = pos.ins().iadd_imm(lres, 1 << (ty.lane_bits() - 1));
 
     // Recycle the original instruction as a jump.
     pos.func.dfg.replace(inst).jump(done, &[lfinal]);
 
     // Finally insert a label for the completion.
     pos.next_inst();
-    pos.insert_ebb(done);
+    pos.insert_block(done);
 
-    cfg.recompute_ebb(pos.func, old_ebb);
-    cfg.recompute_ebb(pos.func, below_uint_max_ebb);
-    cfg.recompute_ebb(pos.func, below_zero_ebb);
-    cfg.recompute_ebb(pos.func, large);
-    cfg.recompute_ebb(pos.func, done);
+    cfg.recompute_block(pos.func, old_block);
+    cfg.recompute_block(pos.func, below_uint_max_block);
+    cfg.recompute_block(pos.func, below_zero_block);
+    cfg.recompute_block(pos.func, large);
+    cfg.recompute_block(pos.func, done);
 }
 
 fn expand_fcvt_to_uint_sat(
     inst: ir::Inst,
     func: &mut ir::Function,
     cfg: &mut ControlFlowGraph,
     _isa: &dyn TargetIsa,
 ) {
@@ -929,101 +929,101 @@ fn expand_fcvt_to_uint_sat(
             arg,
         } => arg,
         _ => panic!(
             "Need fcvt_to_uint_sat: {}",
             func.dfg.display_inst(inst, None)
         ),
     };
 
-    let old_ebb = func.layout.pp_ebb(inst);
+    let old_block = func.layout.pp_block(inst);
     let xty = func.dfg.value_type(x);
     let result = func.dfg.first_result(inst);
     let ty = func.dfg.value_type(result);
 
-    // EBB handle numbers < 2^(N-1).
-    let below_pow2nm1_or_nan_ebb = func.dfg.make_ebb();
-    let below_pow2nm1_ebb = func.dfg.make_ebb();
+    // block handle numbers < 2^(N-1).
+    let below_pow2nm1_or_nan_block = func.dfg.make_block();
+    let below_pow2nm1_block = func.dfg.make_block();
 
-    // EBB handling numbers >= 2^(N-1).
-    let large = func.dfg.make_ebb();
+    // block handling numbers >= 2^(N-1).
+    let large = func.dfg.make_block();
 
-    // EBB handling numbers < 2^N.
-    let uint_large_ebb = func.dfg.make_ebb();
+    // block handling numbers < 2^N.
+    let uint_large_block = func.dfg.make_block();
 
-    // Final EBB after the bad value checks.
-    let done = func.dfg.make_ebb();
+    // Final block after the bad value checks.
+    let done = func.dfg.make_block();
 
-    // Move the `inst` result value onto the `done` EBB.
+    // Move the `inst` result value onto the `done` block.
     func.dfg.clear_results(inst);
-    func.dfg.attach_ebb_param(done, result);
+    func.dfg.attach_block_param(done, result);
 
     let mut pos = FuncCursor::new(func).at_inst(inst);
     pos.use_srcloc(inst);
 
     // Start by materializing the floating point constant 2^(N-1) where N is the number of bits in
     // the destination integer type.
     let pow2nm1 = match xty {
         ir::types::F32 => pos.ins().f32const(Ieee32::pow2(ty.lane_bits() - 1)),
         ir::types::F64 => pos.ins().f64const(Ieee64::pow2(ty.lane_bits() - 1)),
         _ => panic!("Can't convert {}", xty),
     };
     let zero = pos.ins().iconst(ty, 0);
     let is_large = pos.ins().ffcmp(x, pow2nm1);
     pos.ins()
         .brff(FloatCC::GreaterThanOrEqual, is_large, large, &[]);
-    pos.ins().jump(below_pow2nm1_or_nan_ebb, &[]);
+    pos.ins().jump(below_pow2nm1_or_nan_block, &[]);
 
     // We need to generate zero when `x` is NaN, so reuse the flags from the previous comparison.
-    pos.insert_ebb(below_pow2nm1_or_nan_ebb);
+    pos.insert_block(below_pow2nm1_or_nan_block);
     pos.ins().brff(FloatCC::Unordered, is_large, done, &[zero]);
-    pos.ins().jump(below_pow2nm1_ebb, &[]);
+    pos.ins().jump(below_pow2nm1_block, &[]);
 
     // Now we know that x < 2^(N-1) and not NaN. If the result of the cvtt2si is positive, we're
     // done; otherwise saturate to the minimum unsigned value, that is 0.
-    pos.insert_ebb(below_pow2nm1_ebb);
+    pos.insert_block(below_pow2nm1_block);
     let sres = pos.ins().x86_cvtt2si(ty, x);
     let is_neg = pos.ins().ifcmp_imm(sres, 0);
     pos.ins()
         .brif(IntCC::SignedGreaterThanOrEqual, is_neg, done, &[sres]);
     pos.ins().jump(done, &[zero]);
 
     // Handle the case where x >= 2^(N-1) and not NaN.
-    pos.insert_ebb(large);
+    pos.insert_block(large);
     let adjx = pos.ins().fsub(x, pow2nm1);
     let lres = pos.ins().x86_cvtt2si(ty, adjx);
     let max_value = pos.ins().iconst(
         ty,
         match ty {
             ir::types::I32 => u32::max_value() as i64,
             ir::types::I64 => u64::max_value() as i64,
             _ => panic!("Can't convert {}", ty),
         },
     );
     let is_neg = pos.ins().ifcmp_imm(lres, 0);
     pos.ins()
         .brif(IntCC::SignedLessThan, is_neg, done, &[max_value]);
-    pos.ins().jump(uint_large_ebb, &[]);
+    pos.ins().jump(uint_large_block, &[]);
 
-    pos.insert_ebb(uint_large_ebb);
+    pos.insert_block(uint_large_block);
     let lfinal = pos.ins().iadd_imm(lres, 1 << (ty.lane_bits() - 1));
 
     // Recycle the original instruction as a jump.
     pos.func.dfg.replace(inst).jump(done, &[lfinal]);
 
     // Finally insert a label for the completion.
     pos.next_inst();
-    pos.insert_ebb(done);
+    pos.insert_block(done);
 
-    cfg.recompute_ebb(pos.func, old_ebb);
-    cfg.recompute_ebb(pos.func, below_pow2nm1_or_nan_ebb);
-    cfg.recompute_ebb(pos.func, below_pow2nm1_ebb);
-    cfg.recompute_ebb(pos.func, large);
-    cfg.recompute_ebb(pos.func, uint_large_ebb);
-    cfg.recompute_ebb(pos.func, done);
+    cfg.recompute_block(pos.func, old_block);
+    cfg.recompute_block(pos.func, below_pow2nm1_or_nan_block);
+    cfg.recompute_block(pos.func, below_pow2nm1_block);
+    cfg.recompute_block(pos.func, large);
+    cfg.recompute_block(pos.func, uint_large_block);
+    cfg.recompute_block(pos.func, done);
 }
 
 /// Convert shuffle instructions.
 fn convert_shuffle(
     inst: ir::Inst,
     func: &mut ir::Function,
     _cfg: &mut ControlFlowGraph,
     _isa: &dyn TargetIsa,
--- a/third_party/rust/cranelift-codegen/src/isa/x86/fde.rs
+++ b/third_party/rust/cranelift-codegen/src/isa/x86/fde.rs
@@ -158,19 +158,18 @@ fn to_cfi(
             let mapped = map_reg(isa, *reg);
             CallFrameInstruction::Offset(mapped, cfa_offset)
         }
         FrameLayoutChange::ReturnAddressAt { cfa_offset } => {
             assert!(cfa_offset % -8 == 0);
             let cfa_offset = *cfa_offset as i32;
             CallFrameInstruction::Offset(X86_64::RA, cfa_offset)
         }
-        _ => {
-            return None;
-        }
+        FrameLayoutChange::Preserve => CallFrameInstruction::RememberState,
+        FrameLayoutChange::Restore => CallFrameInstruction::RestoreState,
     })
 }
 
 /// Creates FDE structure from FrameLayout.
 pub fn emit_fde(func: &Function, isa: &dyn TargetIsa, sink: &mut dyn FrameUnwindSink) {
     assert!(isa.name() == "x86");
 
     // Expecting function with System V prologue
@@ -178,24 +177,24 @@ pub fn emit_fde(func: &Function, isa: &d
         func.signature.call_conv == CallConv::Fast
             || func.signature.call_conv == CallConv::Cold
             || func.signature.call_conv == CallConv::SystemV
     );
 
     assert!(func.frame_layout.is_some(), "expected func.frame_layout");
     let frame_layout = func.frame_layout.as_ref().unwrap();
 
-    let mut ebbs = func.layout.ebbs().collect::<Vec<_>>();
-    ebbs.sort_by_key(|ebb| func.offsets[*ebb]); // Ensure inst offsets always increase
+    let mut blocks = func.layout.blocks().collect::<Vec<_>>();
+    blocks.sort_by_key(|block| func.offsets[*block]); // Ensure inst offsets always increase
 
     let encinfo = isa.encoding_info();
     let mut last_offset = 0;
     let mut changes = Vec::new();
-    for ebb in ebbs {
-        for (offset, inst, size) in func.inst_offsets(ebb, &encinfo) {
+    for block in blocks {
+        for (offset, inst, size) in func.inst_offsets(block, &encinfo) {
             let address_offset = (offset + size) as usize;
             assert!(last_offset <= address_offset);
             if let Some(cmds) = frame_layout.instructions.get(&inst) {
                 for cmd in cmds.iter() {
                     changes.push((address_offset, *cmd));
                 }
             }
             last_offset = address_offset;
@@ -260,17 +259,20 @@ pub fn emit_fde(func: &Function, isa: &d
     sink.bytes(&[0, 0, 0, 0]);
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::binemit::{FrameUnwindOffset, Reloc};
     use crate::cursor::{Cursor, FuncCursor};
-    use crate::ir::{ExternalName, InstBuilder, Signature, StackSlotData, StackSlotKind};
+    use crate::ir::{
+        types, AbiParam, ExternalName, InstBuilder, Signature, StackSlotData, StackSlotKind,
+        TrapCode,
+    };
     use crate::isa::{lookup, CallConv};
     use crate::settings::{builder, Flags};
     use crate::Context;
     use std::str::FromStr;
     use target_lexicon::triple;
 
     struct SimpleUnwindSink(pub Vec<u8>, pub usize, pub Vec<(Reloc, usize)>);
     impl FrameUnwindSink for SimpleUnwindSink {
@@ -336,20 +338,95 @@ mod tests {
         assert_eq!(sink.1, 24);
         assert_eq!(sink.2.len(), 1);
     }
 
     fn create_function(call_conv: CallConv, stack_slot: Option<StackSlotData>) -> Function {
         let mut func =
             Function::with_name_signature(ExternalName::user(0, 0), Signature::new(call_conv));
 
-        let ebb0 = func.dfg.make_ebb();
+        let block0 = func.dfg.make_block();
         let mut pos = FuncCursor::new(&mut func);
-        pos.insert_ebb(ebb0);
+        pos.insert_block(block0);
         pos.ins().return_(&[]);
 
         if let Some(stack_slot) = stack_slot {
             func.stack_slots.push(stack_slot);
         }
 
         func
     }
+
+    #[test]
+    fn test_multi_return_func() {
+        let isa = lookup(triple!("x86_64"))
+            .expect("expect x86 ISA")
+            .finish(Flags::new(builder()));
+
+        let mut context = Context::for_function(create_multi_return_function(CallConv::SystemV));
+        context.func.collect_frame_layout_info();
+
+        context.compile(&*isa).expect("expected compilation");
+
+        let mut sink = SimpleUnwindSink(Vec::new(), 0, Vec::new());
+        emit_fde(&context.func, &*isa, &mut sink);
+
+        assert_eq!(
+            sink.0,
+            vec![
+                20, 0, 0, 0, // CIE len
+                0, 0, 0, 0,   // CIE marker
+                1,   // version
+                0,   // augmentation string
+                1,   // code aligment = 1
+                120, // data alignment = -8
+                16,  // RA = r16
+                0x0c, 0x07, 0x08, // DW_CFA_def_cfa r7, 8
+                0x90, 0x01, //  DW_CFA_offset r16, -8 * 1
+                0, 0, 0, 0, 0, 0, // padding
+                36, 0, 0, 0, // FDE len
+                28, 0, 0, 0, // CIE offset
+                0, 0, 0, 0, 0, 0, 0, 0, // addr reloc
+                15, 0, 0, 0, 0, 0, 0, 0,    // function length
+                0x42, // DW_CFA_advance_loc 2
+                0x0e, 0x10, // DW_CFA_def_cfa_offset 16
+                0x86, 0x02, // DW_CFA_offset r6, -8 * 2
+                0x43, // DW_CFA_advance_loc 3
+                0x0d, 0x06, // DW_CFA_def_cfa_register
+                0x47, // DW_CFA_advance_loc 10
+                0x0a, // DW_CFA_preserve_state
+                0x0c, 0x07, 0x08, // DW_CFA_def_cfa r7, 8
+                0x41, // DW_CFA_advance_loc 1
+                0x0b, // DW_CFA_restore_state
+                // NOTE: no additional CFA directives -- DW_CFA_restore_state
+                // is done before trap and it is last instruction in the function.
+                0, // padding
+                0, 0, 0, 0, // End of FDEs
+            ]
+        );
+        assert_eq!(sink.1, 24);
+        assert_eq!(sink.2.len(), 1);
+    }
+
+    fn create_multi_return_function(call_conv: CallConv) -> Function {
+        let mut sig = Signature::new(call_conv);
+        sig.params.push(AbiParam::new(types::I32));
+        let mut func = Function::with_name_signature(ExternalName::user(0, 0), sig);
+
+        let block0 = func.dfg.make_block();
+        let v0 = func.dfg.append_block_param(block0, types::I32);
+        let block1 = func.dfg.make_block();
+        let block2 = func.dfg.make_block();
+
+        let mut pos = FuncCursor::new(&mut func);
+        pos.insert_block(block0);
+        pos.ins().brnz(v0, block2, &[]);
+        pos.ins().jump(block1, &[]);
+
+        pos.insert_block(block1);
+        pos.ins().return_(&[]);
+
+        pos.insert_block(block2);
+        pos.ins().trap(TrapCode::User(0));
+
+        func
+    }
 }
--- a/third_party/rust/cranelift-codegen/src/isa/x86/unwind.rs
+++ b/third_party/rust/cranelift-codegen/src/isa/x86/unwind.rs
@@ -122,17 +122,17 @@ impl UnwindInfo {
         frame_register: Option<RegUnit>,
     ) -> Option<Self> {
         // Only Windows fastcall is supported for unwind information
         if func.signature.call_conv != CallConv::WindowsFastcall || func.prologue_end.is_none() {
             return None;
         }
 
         let prologue_end = func.prologue_end.unwrap();
-        let entry_block = func.layout.ebbs().nth(0).expect("missing entry block");
+        let entry_block = func.layout.blocks().nth(0).expect("missing entry block");
 
         // Stores the stack size when SP is not adjusted via an immediate value
         let mut stack_size = None;
         let mut prologue_size = 0;
         let mut unwind_codes = Vec::new();
         let mut found_end = false;
 
         for (offset, inst, size) in func.inst_offsets(entry_block, &isa.encoding_info()) {
@@ -514,19 +514,19 @@ mod tests {
             ]
         );
     }
 
     fn create_function(call_conv: CallConv, stack_slot: Option<StackSlotData>) -> Function {
         let mut func =
             Function::with_name_signature(ExternalName::user(0, 0), Signature::new(call_conv));
 
-        let ebb0 = func.dfg.make_ebb();
+        let block0 = func.dfg.make_block();
         let mut pos = FuncCursor::new(&mut func);
-        pos.insert_ebb(ebb0);
+        pos.insert_block(block0);
         pos.ins().return_(&[]);
 
         if let Some(stack_slot) = stack_slot {
             func.stack_slots.push(stack_slot);
         }
 
         func
     }
--- a/third_party/rust/cranelift-codegen/src/legalizer/boundary.rs
+++ b/third_party/rust/cranelift-codegen/src/legalizer/boundary.rs
@@ -17,17 +17,17 @@
 //! Between the two phases, preamble signatures and call/return arguments don't match. This
 //! intermediate state doesn't type check.
 
 use crate::abi::{legalize_abi_value, ValueConversion};
 use crate::cursor::{Cursor, FuncCursor};
 use crate::flowgraph::ControlFlowGraph;
 use crate::ir::instructions::CallInfo;
 use crate::ir::{
-    AbiParam, ArgumentLoc, ArgumentPurpose, DataFlowGraph, Ebb, Function, Inst, InstBuilder,
+    AbiParam, ArgumentLoc, ArgumentPurpose, Block, DataFlowGraph, Function, Inst, InstBuilder,
     MemFlags, SigRef, Signature, StackSlotData, StackSlotKind, Type, Value, ValueLoc,
 };
 use crate::isa::TargetIsa;
 use crate::legalizer::split::{isplit, vsplit};
 use alloc::borrow::Cow;
 use alloc::vec::Vec;
 use core::mem;
 use cranelift_entity::EntityList;
@@ -79,49 +79,49 @@ fn legalize_signature(
         Cow::Borrowed(_) => None,
         Cow::Owned(s) => Some(s),
     }
 }
 
 /// Legalize the entry block parameters after `func`'s signature has been legalized.
 ///
 /// The legalized signature may contain more parameters than the original signature, and the
-/// parameter types have been changed. This function goes through the parameters of the entry EBB
+/// parameter types have been changed. This function goes through the parameters of the entry block
 /// and replaces them with parameters of the right type for the ABI.
 ///
-/// The original entry EBB parameters are computed from the new ABI parameters by code inserted at
+/// The original entry block parameters are computed from the new ABI parameters by code inserted at
 /// the top of the entry block.
-fn legalize_entry_params(func: &mut Function, entry: Ebb) {
+fn legalize_entry_params(func: &mut Function, entry: Block) {
     let mut has_sret = false;
     let mut has_link = false;
     let mut has_vmctx = false;
     let mut has_sigid = false;
     let mut has_stack_limit = false;
 
     // Insert position for argument conversion code.
     // We want to insert instructions before the first instruction in the entry block.
     // If the entry block is empty, append instructions to it instead.
     let mut pos = FuncCursor::new(func).at_first_inst(entry);
 
     // Keep track of the argument types in the ABI-legalized signature.
     let mut abi_arg = 0;
 
-    // Process the EBB parameters one at a time, possibly replacing one argument with multiple new
-    // ones. We do this by detaching the entry EBB parameters first.
-    let ebb_params = pos.func.dfg.detach_ebb_params(entry);
+    // Process the block parameters one at a time, possibly replacing one argument with multiple new
+    // ones. We do this by detaching the entry block parameters first.
+    let block_params = pos.func.dfg.detach_block_params(entry);
     let mut old_arg = 0;
-    while let Some(arg) = ebb_params.get(old_arg, &pos.func.dfg.value_lists) {
+    while let Some(arg) = block_params.get(old_arg, &pos.func.dfg.value_lists) {
         old_arg += 1;
 
         let abi_type = pos.func.signature.params[abi_arg];
         let arg_type = pos.func.dfg.value_type(arg);
         if arg_type == abi_type.value_type {
             // No value translation is necessary, this argument matches the ABI type.
-            // Just use the original EBB argument value. This is the most common case.
-            pos.func.dfg.attach_ebb_param(entry, arg);
+            // Just use the original block argument value. This is the most common case.
+            pos.func.dfg.attach_block_param(entry, arg);
             match abi_type.purpose {
                 ArgumentPurpose::Normal => {}
                 ArgumentPurpose::FramePointer => {}
                 ArgumentPurpose::CalleeSaved => {}
                 ArgumentPurpose::StructReturn => {
                     debug_assert!(!has_sret, "Multiple sret arguments found");
                     has_sret = true;
                 }
@@ -146,23 +146,23 @@ fn legalize_entry_params(func: &mut Func
                 let abi_type = func.signature.params[abi_arg];
                 debug_assert_eq!(
                     abi_type.purpose,
                     ArgumentPurpose::Normal,
                     "Can't legalize special-purpose argument"
                 );
                 if ty == abi_type.value_type {
                     abi_arg += 1;
-                    Ok(func.dfg.append_ebb_param(entry, ty))
+                    Ok(func.dfg.append_block_param(entry, ty))
                 } else {
                     Err(abi_type)
                 }
             };
             let converted = convert_from_abi(&mut pos, arg_type, Some(arg), &mut get_arg);
-            // The old `arg` is no longer an attached EBB argument, but there are probably still
+            // The old `arg` is no longer an attached block argument, but there are probably still
             // uses of the value.
             debug_assert_eq!(pos.func.dfg.resolve_aliases(arg), converted);
         }
     }
 
     // The legalized signature may contain additional parameters representing special-purpose
     // registers.
     for &arg in &pos.func.signature.params[abi_arg..] {
@@ -196,17 +196,17 @@ fn legalize_entry_params(func: &mut Func
             ArgumentPurpose::StackLimit => {
                 debug_assert!(!has_stack_limit, "Multiple stack_limit parameters found");
                 has_stack_limit = true;
             }
         }
 
         // Just create entry block values to match here. We will use them in `handle_return_abi()`
         // below.
-        pos.func.dfg.append_ebb_param(entry, arg.value_type);
+        pos.func.dfg.append_block_param(entry, arg.value_type);
     }
 }
 
 /// Legalize the results returned from a call instruction to match the ABI signature.
 ///
 /// The cursor `pos` points to a call instruction with at least one return value. The cursor will
 /// be left pointing after the instructions inserted to convert the return values.
 ///
@@ -846,17 +846,17 @@ pub fn handle_return_abi(inst: Inst, fun
                 .iter()
                 .rposition(|t| t.purpose == arg.purpose)
                 .expect("No matching special purpose argument.");
             // Get the corresponding entry block value and add it to the return instruction's
             // arguments.
             let val = pos
                 .func
                 .dfg
-                .ebb_params(pos.func.layout.entry_block().unwrap())[idx];
+                .block_params(pos.func.layout.entry_block().unwrap())[idx];
             debug_assert_eq!(pos.func.dfg.value_type(val), arg.value_type);
             vlist.push(val, &mut pos.func.dfg.value_lists);
 
             if let ArgumentPurpose::StructReturn = arg.purpose {
                 sret = Some(val);
             }
         }
 
@@ -953,18 +953,23 @@ fn round_up_to_multiple_of_pow2(n: u32, 
 
     (n + to - 1) & !(to - 1)
 }
 
 /// Assign stack slots to incoming function parameters on the stack.
 ///
 /// Values that are passed into the function on the stack must be assigned to an `IncomingArg`
 /// stack slot already during legalization.
-fn spill_entry_params(func: &mut Function, entry: Ebb) {
-    for (abi, &arg) in func.signature.params.iter().zip(func.dfg.ebb_params(entry)) {
+fn spill_entry_params(func: &mut Function, entry: Block) {
+    for (abi, &arg) in func
+        .signature
+        .params
+        .iter()
+        .zip(func.dfg.block_params(entry))
+    {
         if let ArgumentLoc::Stack(offset) = abi.location {
             let ss = func.stack_slots.make_incoming_arg(abi.value_type, offset);
             func.locations[arg] = ValueLoc::Stack(ss);
         }
     }
 }
 
 /// Assign stack slots to outgoing function arguments on the stack.
--- a/third_party/rust/cranelift-codegen/src/legalizer/heap.rs
+++ b/third_party/rust/cranelift-codegen/src/legalizer/heap.rs
@@ -115,22 +115,22 @@ fn static_addr(
     pos.use_srcloc(inst);
 
     // Start with the bounds check. Trap if `offset + access_size > bound`.
     if access_size > bound {
         // This will simply always trap since `offset >= 0`.
         pos.ins().trap(ir::TrapCode::HeapOutOfBounds);
         pos.func.dfg.replace(inst).iconst(addr_ty, 0);
 
-        // Split Ebb, as the trap is a terminator instruction.
-        let curr_ebb = pos.current_ebb().expect("Cursor is not in an ebb");
-        let new_ebb = pos.func.dfg.make_ebb();
-        pos.insert_ebb(new_ebb);
-        cfg.recompute_ebb(pos.func, curr_ebb);
-        cfg.recompute_ebb(pos.func, new_ebb);
+        // Split Block, as the trap is a terminator instruction.
+        let curr_block = pos.current_block().expect("Cursor is not in an block");
+        let new_block = pos.func.dfg.make_block();
+        pos.insert_block(new_block);
+        cfg.recompute_block(pos.func, curr_block);
+        cfg.recompute_block(pos.func, new_block);
         return;
     }
 
     // Check `offset > limit` which is now known non-negative.
     let limit = bound - access_size;
 
     // We may be able to omit the check entirely for 32-bit offsets if the heap bound is 4 GB or
     // more.
--- a/third_party/rust/cranelift-codegen/src/legalizer/libcall.rs
+++ b/third_party/rust/cranelift-codegen/src/legalizer/libcall.rs
@@ -1,12 +1,12 @@
 //! Expanding instructions as runtime library calls.
 
 use crate::ir;
-use crate::ir::{get_libcall_funcref, InstBuilder};
+use crate::ir::{libcall::get_libcall_funcref, InstBuilder};
 use crate::isa::{CallConv, TargetIsa};
 use crate::legalizer::boundary::legalize_libcall_signature;
 use alloc::vec::Vec;
 
 /// Try to expand `inst` as a library call, returning true is successful.
 pub fn expand_as_libcall(inst: ir::Inst, func: &mut ir::Function, isa: &dyn TargetIsa) -> bool {
     // Does the opcode/ctrl_type combo even have a well-known runtime library name.
     let libcall = match ir::LibCall::for_inst(func.dfg[inst].opcode(), func.dfg.ctrl_typevar(inst))
--- a/third_party/rust/cranelift-codegen/src/legalizer/mod.rs
+++ b/third_party/rust/cranelift-codegen/src/legalizer/mod.rs
@@ -82,17 +82,17 @@ fn legalize_inst(
                     // `arg` was created by an `iconcat` instruction.
                 } else {
                     // `arg` was not created by an `iconcat` instruction. Don't try to resolve it,
                     // as otherwise `split::isplit` will re-insert the original `isplit`, causing
                     // an endless loop.
                     return LegalizeInstResult::SplitLegalizePending;
                 }
             }
-            ir::ValueDef::Param(_ebb, _num) => {}
+            ir::ValueDef::Param(_block, _num) => {}
         }
 
         let res = pos.func.dfg.inst_results(inst).to_vec();
         assert_eq!(res.len(), 2);
         let (resl, resh) = (res[0], res[1]); // Prevent borrowck error
 
         // Remove old isplit
         pos.func.dfg.clear_results(inst);
@@ -143,30 +143,30 @@ pub fn legalize_function(func: &mut ir::
 
     boundary::legalize_signatures(func, isa);
 
     func.encodings.resize(func.dfg.num_insts());
 
     let mut pos = FuncCursor::new(func);
     let func_begin = pos.position();
 
-    // Split ebb params before trying to legalize instructions, so that the newly introduced
+    // Split block params before trying to legalize instructions, so that the newly introduced
     // isplit instructions get legalized.
-    while let Some(ebb) = pos.next_ebb() {
-        split::split_ebb_params(pos.func, cfg, ebb);
+    while let Some(block) = pos.next_block() {
+        split::split_block_params(pos.func, cfg, block);
     }
 
     pos.set_position(func_begin);
 
     // This must be a set to prevent trying to legalize `isplit` and `vsplit` twice in certain cases.
     let mut pending_splits = BTreeSet::new();
 
-    // Process EBBs in layout order. Some legalization actions may split the current EBB or append
-    // new ones to the end. We need to make sure we visit those new EBBs too.
-    while let Some(_ebb) = pos.next_ebb() {
+    // Process blocks in layout order. Some legalization actions may split the current block or append
+    // new ones to the end. We need to make sure we visit those new blocks too.
+    while let Some(_block) = pos.next_block() {
         // Keep track of the cursor position before the instruction being processed, so we can
         // double back when replacing instructions.
         let mut prev_pos = pos.position();
 
         while let Some(inst) = pos.next_inst() {
             match legalize_inst(inst, &mut pos, cfg, isa) {
                 // Remember this position in case we need to double back.
                 LegalizeInstResult::Done => prev_pos = pos.position(),
@@ -220,58 +220,58 @@ fn expand_cond_trap(
                 ir::Opcode::Trapnz => false,
                 _ => panic!("Expected cond trap: {}", func.dfg.display_inst(inst, None)),
             };
             (arg, code)
         }
         _ => panic!("Expected cond trap: {}", func.dfg.display_inst(inst, None)),
     };
 
-    // Split the EBB after `inst`:
+    // Split the block after `inst`:
     //
     //     trapnz arg
     //     ..
     //
     // Becomes:
     //
-    //     brz arg, new_ebb_resume
-    //     jump new_ebb_trap
+    //     brz arg, new_block_resume
+    //     jump new_block_trap
     //
-    //   new_ebb_trap:
+    //   new_block_trap:
     //     trap
     //
-    //   new_ebb_resume:
+    //   new_block_resume:
     //     ..
-    let old_ebb = func.layout.pp_ebb(inst);
-    let new_ebb_trap = func.dfg.make_ebb();
-    let new_ebb_resume = func.dfg.make_ebb();
+    let old_block = func.layout.pp_block(inst);
+    let new_block_trap = func.dfg.make_block();
+    let new_block_resume = func.dfg.make_block();
 
     // Replace trap instruction by the inverted condition.
     if trapz {
-        func.dfg.replace(inst).brnz(arg, new_ebb_resume, &[]);
+        func.dfg.replace(inst).brnz(arg, new_block_resume, &[]);
     } else {
-        func.dfg.replace(inst).brz(arg, new_ebb_resume, &[]);
+        func.dfg.replace(inst).brz(arg, new_block_resume, &[]);
     }
 
     // Add jump instruction after the inverted branch.
     let mut pos = FuncCursor::new(func).after_inst(inst);
     pos.use_srcloc(inst);
-    pos.ins().jump(new_ebb_trap, &[]);
+    pos.ins().jump(new_block_trap, &[]);
 
     // Insert the new label and the unconditional trap terminator.
-    pos.insert_ebb(new_ebb_trap);
+    pos.insert_block(new_block_trap);
     pos.ins().trap(code);
 
     // Insert the new label and resume the execution when the trap fails.
-    pos.insert_ebb(new_ebb_resume);
+    pos.insert_block(new_block_resume);
 
     // Finally update the CFG.
-    cfg.recompute_ebb(pos.func, old_ebb);
-    cfg.recompute_ebb(pos.func, new_ebb_resume);
-    cfg.recompute_ebb(pos.func, new_ebb_trap);
+    cfg.recompute_block(pos.func, old_block);
+    cfg.recompute_block(pos.func, new_block_resume);
+    cfg.recompute_block(pos.func, new_block_trap);
 }
 
 /// Jump tables.
 fn expand_br_table(
     inst: ir::Inst,
     func: &mut ir::Function,
     cfg: &mut ControlFlowGraph,
     isa: &dyn TargetIsa,
@@ -287,57 +287,57 @@ fn expand_br_table(
 fn expand_br_table_jt(
     inst: ir::Inst,
     func: &mut ir::Function,
     cfg: &mut ControlFlowGraph,
     isa: &dyn TargetIsa,
 ) {
     use crate::ir::condcodes::IntCC;
 
-    let (arg, default_ebb, table) = match func.dfg[inst] {
+    let (arg, default_block, table) = match func.dfg[inst] {
         ir::InstructionData::BranchTable {
             opcode: ir::Opcode::BrTable,
             arg,
             destination,
             table,
         } => (arg, destination, table),
         _ => panic!("Expected br_table: {}", func.dfg.display_inst(inst, None)),
     };
 
     // Rewrite:
     //
-    //     br_table $idx, default_ebb, $jt
+    //     br_table $idx, default_block, $jt
     //
     // To:
     //
     //     $oob = ifcmp_imm $idx, len($jt)
-    //     brif uge $oob, default_ebb
-    //     jump fallthrough_ebb
+    //     brif uge $oob, default_block
+    //     jump fallthrough_block
     //
-    //   fallthrough_ebb:
+    //   fallthrough_block:
     //     $base = jump_table_base.i64 $jt
     //     $rel_addr = jump_table_entry.i64 $idx, $base, 4, $jt
     //     $addr = iadd $base, $rel_addr
     //     indirect_jump_table_br $addr, $jt
 
-    let ebb = func.layout.pp_ebb(inst);
-    let jump_table_ebb = func.dfg.make_ebb();
+    let block = func.layout.pp_block(inst);
+    let jump_table_block = func.dfg.make_block();
 
     let mut pos = FuncCursor::new(func).at_inst(inst);
     pos.use_srcloc(inst);
 
     // Bounds check.
     let table_size = pos.func.jump_tables[table].len() as i64;
     let oob = pos
         .ins()
         .icmp_imm(IntCC::UnsignedGreaterThanOrEqual, arg, table_size);
 
-    pos.ins().brnz(oob, default_ebb, &[]);
-    pos.ins().jump(jump_table_ebb, &[]);
-    pos.insert_ebb(jump_table_ebb);
+    pos.ins().brnz(oob, default_block, &[]);
+    pos.ins().jump(jump_table_block, &[]);
+    pos.insert_block(jump_table_block);
 
     let addr_ty = isa.pointer_type();
 
     let arg = if pos.func.dfg.value_type(arg) == addr_ty {
         arg
     } else {
         pos.ins().uextend(addr_ty, arg)
     };
@@ -346,75 +346,75 @@ fn expand_br_table_jt(
     let entry = pos
         .ins()
         .jump_table_entry(arg, base_addr, I32.bytes() as u8, table);
 
     let addr = pos.ins().iadd(base_addr, entry);
     pos.ins().indirect_jump_table_br(addr, table);
 
     pos.remove_inst();
-    cfg.recompute_ebb(pos.func, ebb);
-    cfg.recompute_ebb(pos.func, jump_table_ebb);
+    cfg.recompute_block(pos.func, block);
+    cfg.recompute_block(pos.func, jump_table_block);
 }
 
 /// Expand br_table to series of conditionals.
 fn expand_br_table_conds(
     inst: ir::Inst,
     func: &mut ir::Function,
     cfg: &mut ControlFlowGraph,
     _isa: &dyn TargetIsa,
 ) {
     use crate::ir::condcodes::IntCC;
 
-    let (arg, default_ebb, table) = match func.dfg[inst] {
+    let (arg, default_block, table) = match func.dfg[inst] {
         ir::InstructionData::BranchTable {
             opcode: ir::Opcode::BrTable,
             arg,
             destination,
             table,
         } => (arg, destination, table),
         _ => panic!("Expected br_table: {}", func.dfg.display_inst(inst, None)),
     };
 
-    let ebb = func.layout.pp_ebb(inst);
+    let block = func.layout.pp_block(inst);
 
     // This is a poor man's jump table using just a sequence of conditional branches.
     let table_size = func.jump_tables[table].len();
-    let mut cond_failed_ebb = vec![];
+    let mut cond_failed_block = vec![];
     if table_size >= 1 {
-        cond_failed_ebb = alloc::vec::Vec::with_capacity(table_size - 1);
+        cond_failed_block = alloc::vec::Vec::with_capacity(table_size - 1);
         for _ in 0..table_size - 1 {
-            cond_failed_ebb.push(func.dfg.make_ebb());
+            cond_failed_block.push(func.dfg.make_block());
         }
     }
 
     let mut pos = FuncCursor::new(func).at_inst(inst);
     pos.use_srcloc(inst);
 
     // Ignore the lint for this loop as the range needs to be 0 to table_size
     #[allow(clippy::needless_range_loop)]
     for i in 0..table_size {
         let dest = pos.func.jump_tables[table].as_slice()[i];
         let t = pos.ins().icmp_imm(IntCC::Equal, arg, i as i64);
         pos.ins().brnz(t, dest, &[]);
         // Jump to the next case.
         if i < table_size - 1 {
-            let ebb = cond_failed_ebb[i];
-            pos.ins().jump(ebb, &[]);
-            pos.insert_ebb(ebb);
+            let block = cond_failed_block[i];
+            pos.ins().jump(block, &[]);
+            pos.insert_block(block);
         }
     }
 
     // `br_table` jumps to the default destination if nothing matches
-    pos.ins().jump(default_ebb, &[]);
+    pos.ins().jump(default_block, &[]);
 
     pos.remove_inst();
-    cfg.recompute_ebb(pos.func, ebb);
-    for failed_ebb in cond_failed_ebb.into_iter() {
-        cfg.recompute_ebb(pos.func, failed_ebb);
+    cfg.recompute_block(pos.func, block);
+    for failed_block in cond_failed_block.into_iter() {
+        cfg.recompute_block(pos.func, failed_block);
     }
 }
 
 /// Expand the select instruction.
 ///
 /// Conditional moves are available in some ISAs for some register classes. The remaining selects
 /// are handled by a branch.
 fn expand_select(
@@ -428,67 +428,67 @@ fn expand_select(
             opcode: ir::Opcode::Select,
             args,
         } => (args[0], args[1], args[2]),
         _ => panic!("Expected select: {}", func.dfg.display_inst(inst, None)),
     };
 
     // Replace `result = select ctrl, tval, fval` with:
     //
-    //   brnz ctrl, new_ebb(tval)
-    //   jump new_ebb(fval)
-    // new_ebb(result):
-    let old_ebb = func.layout.pp_ebb(inst);
+    //   brnz ctrl, new_block(tval)
+    //   jump new_block(fval)
+    // new_block(result):
+    let old_block = func.layout.pp_block(inst);
     let result = func.dfg.first_result(inst);
     func.dfg.clear_results(inst);
-    let new_ebb = func.dfg.make_ebb();
-    func.dfg.attach_ebb_param(new_ebb, result);
+    let new_block = func.dfg.make_block();
+    func.dfg.attach_block_param(new_block, result);
 
-    func.dfg.replace(inst).brnz(ctrl, new_ebb, &[tval]);
+    func.dfg.replace(inst).brnz(ctrl, new_block, &[tval]);
     let mut pos = FuncCursor::new(func).after_inst(inst);
     pos.use_srcloc(inst);
-    pos.ins().jump(new_ebb, &[fval]);
-    pos.insert_ebb(new_ebb);
+    pos.ins().jump(new_block, &[fval]);
+    pos.insert_block(new_block);
 
-    cfg.recompute_ebb(pos.func, new_ebb);
-    cfg.recompute_ebb(pos.func, old_ebb);
+    cfg.recompute_block(pos.func, new_block);
+    cfg.recompute_block(pos.func, old_block);
 }
 
 fn expand_br_icmp(
     inst: ir::Inst,
     func: &mut ir::Function,
     cfg: &mut ControlFlowGraph,
     _isa: &dyn TargetIsa,
 ) {
-    let (cond, a, b, destination, ebb_args) = match func.dfg[inst] {
+    let (cond, a, b, destination, block_args) = match func.dfg[inst] {
         ir::InstructionData::BranchIcmp {
             cond,
             destination,
             ref args,
             ..
         } => (
             cond,
             args.get(0, &func.dfg.value_lists).unwrap(),
             args.get(1, &func.dfg.value_lists).unwrap(),
             destination,
             args.as_slice(&func.dfg.value_lists)[2..].to_vec(),
         ),
         _ => panic!("Expected br_icmp {}", func.dfg.display_inst(inst, None)),
     };
 
-    let old_ebb = func.layout.pp_ebb(inst);
+    let old_block = func.layout.pp_block(inst);
     func.dfg.clear_results(inst);
 
     let icmp_res = func.dfg.replace(inst).icmp(cond, a, b);
     let mut pos = FuncCursor::new(func).after_inst(inst);
     pos.use_srcloc(inst);
-    pos.ins().brnz(icmp_res, destination, &ebb_args);
+    pos.ins().brnz(icmp_res, destination, &block_args);
 
-    cfg.recompute_ebb(pos.func, destination);
-    cfg.recompute_ebb(pos.func, old_ebb);
+    cfg.recompute_block(pos.func, destination);
+    cfg.recompute_block(pos.func, old_block);
 }
 
 /// Expand illegal `f32const` and `f64const` instructions.
 fn expand_fconst(
     inst: ir::Inst,
     func: &mut ir::Function,
     _cfg: &mut ControlFlowGraph,
     _isa: &dyn TargetIsa,
--- a/third_party/rust/cranelift-codegen/src/legalizer/split.rs
+++ b/third_party/rust/cranelift-codegen/src/legalizer/split.rs
@@ -49,29 +49,29 @@
 //!     v6 = bint.i32
 //!     v41 = iadd.i32 v11, v6
 //!     v4 = iconcat v40, v41
 //! ```
 //!
 //! This means that the `iconcat` instructions defining `v1` and `v4` end up with no uses, so they
 //! can be trivially deleted by a dead code elimination pass.
 //!
-//! # EBB arguments
+//! # block arguments
 //!
 //! If all instructions that produce an `i64` value are legalized as above, we will eventually end
-//! up with no `i64` values anywhere, except for EBB arguments. We can work around this by
-//! iteratively splitting EBB arguments too. That should leave us with no illegal value types
+//! up with no `i64` values anywhere, except for block arguments. We can work around this by
+//! iteratively splitting block arguments too. That should leave us with no illegal value types
 //! anywhere.
 //!
-//! It is possible to have circular dependencies of EBB arguments that are never used by any real
+//! It is possible to have circular dependencies of block arguments that are never used by any real
 //! instructions. These loops will remain in the program.
 
 use crate::cursor::{Cursor, CursorPosition, FuncCursor};
-use crate::flowgraph::{BasicBlock, ControlFlowGraph};
-use crate::ir::{self, Ebb, Inst, InstBuilder, InstructionData, Opcode, Type, Value, ValueDef};
+use crate::flowgraph::{BlockPredecessor, ControlFlowGraph};
+use crate::ir::{self, Block, Inst, InstBuilder, InstructionData, Opcode, Type, Value, ValueDef};
 use alloc::vec::Vec;
 use core::iter;
 use smallvec::SmallVec;
 
 /// Split `value` into two values using the `isplit` semantics. Do this by reusing existing values