Mass rename Ebb and relatives to Block (#1365)

* Manually rename BasicBlock to BlockPredecessor

BasicBlock is a pair of (Ebb, Inst) that is used to represent the
basic block subcomponent of an Ebb that is a predecessor to an Ebb.

Eventually we will be able to remove this struct, but for now it
makes sense to give it a non-conflicting name so that we can start
to transition Ebb to represent a basic block.

I have not updated any comments that refer to BasicBlock, as
eventually we will remove BlockPredecessor and replace with Block,
which is a basic block, so the comments will become correct.

* Manually rename SSABuilder block types to avoid conflict

SSABuilder has its own Block and BlockData types. These along with
associated identifier will cause conflicts in a later commit, so
they are renamed to be more verbose here.

* Automatically rename 'Ebb' to 'Block' in *.rs

* Automatically rename 'EBB' to 'block' in *.rs

* Automatically rename 'ebb' to 'block' in *.rs

* Automatically rename 'extended basic block' to 'basic block' in *.rs

* Automatically rename 'an basic block' to 'a basic block' in *.rs

* Manually update comment for `Block`

`Block`'s wikipedia article required an update.

* Automatically rename 'an `Block`' to 'a `Block`' in *.rs

* Automatically rename 'extended_basic_block' to 'basic_block' in *.rs

* Automatically rename 'ebb' to 'block' in *.clif

* Manually rename clif constant that contains 'ebb' as substring to avoid conflict

* Automatically rename filecheck uses of 'EBB' to 'BB'

'regex: EBB' -> 'regex: BB'
'$EBB' -> '$BB'

* Automatically rename 'EBB' 'Ebb' to 'block' in *.clif

* Automatically rename 'an block' to 'a block' in *.clif

* Fix broken testcase when function name length increases

Test function names are limited to 16 characters. This causes
the new longer name to be truncated and fail a filecheck test. An
outdated comment was also fixed.

cranelift/codegen/src/ir/progpoint.rs

@@ -1,7 +1,7 @@
 //! 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;
@@ -10,7 +10,7 @@ use core::u32;
 /// 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)]
@@ -24,9 +24,9 @@ impl From<Inst> for ProgramPoint {
     }
 }
 
-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)
     }
@@ -36,7 +36,7 @@ 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(),
         }
     }
 }
@@ -47,8 +47,8 @@ impl From<ValueDef> for ProgramPoint {
 pub enum ExpandedProgramPoint {
     /// An instruction in the function.
     Inst(Inst),
-    /// An EBB header.
-    Ebb(Ebb),
+    /// An block header.
+    Block(Block),
 }
 
 impl ExpandedProgramPoint {
@@ -56,7 +56,7 @@ impl ExpandedProgramPoint {
     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),
         }
     }
 }
@@ -67,9 +67,9 @@ impl From<Inst> for ExpandedProgramPoint {
     }
 }
 
-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)
     }
 }
 
@@ -77,7 +77,7 @@ 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(),
         }
     }
 }
@@ -87,7 +87,7 @@ impl From<ProgramPoint> for ExpandedProgramPoint {
         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))
         }
     }
 }
@@ -96,7 +96,7 @@ 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),
         }
     }
 }
@@ -129,7 +129,7 @@ pub trait ProgramOrder {
     ///
     /// 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
@@ -137,28 +137,28 @@ pub trait ProgramOrder {
         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");
     }
 }