cranelift: Remove booleans (#5031)

Remove the boolean types from cranelift, and the associated instructions breduce, bextend, bconst, and bint. Standardize on using 1/0 for the return value from instructions that produce scalar boolean results, and -1/0 for boolean vector elements.

Fixes #3205

Co-authored-by: Afonso Bordado <afonso360@users.noreply.github.com>
Co-authored-by: Ulrich Weigand <ulrich.weigand@de.ibm.com>
Co-authored-by: Chris Fallin <chris@cfallin.org>

cranelift/codegen/meta/src/cdsl/types.rs

@@ -145,7 +145,6 @@ impl From<DynamicVectorType> for ValueType {
 /// A concrete scalar type that can appear as a vector lane too.
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub(crate) enum LaneType {
-    Bool(shared_types::Bool),
     Float(shared_types::Float),
     Int(shared_types::Int),
 }
@@ -154,7 +153,6 @@ impl LaneType {
     /// Return a string containing the documentation comment for this lane type.
     pub fn doc(self) -> String {
         match self {
-            LaneType::Bool(_) => format!("A boolean type with {} bits.", self.lane_bits()),
             LaneType::Float(shared_types::Float::F32) => String::from(
                 "A 32-bit floating point type represented in the IEEE 754-2008
                 *binary32* interchange format. This corresponds to the :c:type:`float`
@@ -178,7 +176,6 @@ impl LaneType {
     /// Return the number of bits in a lane.
     pub fn lane_bits(self) -> u64 {
         match self {
-            LaneType::Bool(ref b) => *b as u64,
             LaneType::Float(ref f) => *f as u64,
             LaneType::Int(ref i) => *i as u64,
         }
@@ -188,12 +185,6 @@ impl LaneType {
     pub fn number(self) -> u16 {
         constants::LANE_BASE
             + match self {
-                LaneType::Bool(shared_types::Bool::B1) => 0,
-                LaneType::Bool(shared_types::Bool::B8) => 1,
-                LaneType::Bool(shared_types::Bool::B16) => 2,
-                LaneType::Bool(shared_types::Bool::B32) => 3,
-                LaneType::Bool(shared_types::Bool::B64) => 4,
-                LaneType::Bool(shared_types::Bool::B128) => 5,
                 LaneType::Int(shared_types::Int::I8) => 6,
                 LaneType::Int(shared_types::Int::I16) => 7,
                 LaneType::Int(shared_types::Int::I32) => 8,
@@ -204,18 +195,6 @@ impl LaneType {
             }
     }
 
-    pub fn bool_from_bits(num_bits: u16) -> LaneType {
-        LaneType::Bool(match num_bits {
-            1 => shared_types::Bool::B1,
-            8 => shared_types::Bool::B8,
-            16 => shared_types::Bool::B16,
-            32 => shared_types::Bool::B32,
-            64 => shared_types::Bool::B64,
-            128 => shared_types::Bool::B128,
-            _ => unreachable!("unxpected num bits for bool"),
-        })
-    }
-
     pub fn int_from_bits(num_bits: u16) -> LaneType {
         LaneType::Int(match num_bits {
             8 => shared_types::Int::I8,
@@ -251,7 +230,6 @@ impl LaneType {
 impl fmt::Display for LaneType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            LaneType::Bool(_) => write!(f, "b{}", self.lane_bits()),
             LaneType::Float(_) => write!(f, "f{}", self.lane_bits()),
             LaneType::Int(_) => write!(f, "i{}", self.lane_bits()),
         }
@@ -265,21 +243,13 @@ impl fmt::Debug for LaneType {
             f,
             "{}",
             match *self {
-                LaneType::Bool(_) => format!("BoolType({})", inner_msg),
                 LaneType::Float(_) => format!("FloatType({})", inner_msg),
                 LaneType::Int(_) => format!("IntType({})", inner_msg),
             }
         )
     }
 }
 
-/// Create a LaneType from a given bool variant.
-impl From<shared_types::Bool> for LaneType {
-    fn from(b: shared_types::Bool) -> Self {
-        LaneType::Bool(b)
-    }
-}
-
 /// Create a LaneType from a given float variant.
 impl From<shared_types::Float> for LaneType {
     fn from(f: shared_types::Float) -> Self {
@@ -296,7 +266,6 @@ impl From<shared_types::Int> for LaneType {
 
 /// An iterator for different lane types.
 pub(crate) struct LaneTypeIterator {
-    bool_iter: shared_types::BoolIterator,
     int_iter: shared_types::IntIterator,
     float_iter: shared_types::FloatIterator,
 }
@@ -305,7 +274,6 @@ impl LaneTypeIterator {
     /// Create a new lane type iterator.
     fn new() -> Self {
         Self {
-            bool_iter: shared_types::BoolIterator::new(),
             int_iter: shared_types::IntIterator::new(),
             float_iter: shared_types::FloatIterator::new(),
         }
@@ -315,9 +283,7 @@ impl LaneTypeIterator {
 impl Iterator for LaneTypeIterator {
     type Item = LaneType;
     fn next(&mut self) -> Option<Self::Item> {
-        if let Some(b) = self.bool_iter.next() {
-            Some(LaneType::from(b))
-        } else if let Some(i) = self.int_iter.next() {
+        if let Some(i) = self.int_iter.next() {
             Some(LaneType::from(i))
         } else if let Some(f) = self.float_iter.next() {
             Some(LaneType::from(f))