Implement bit operations for Cranelift interpreter

Implemented for the Cranelift interpreter:
- `Bitrev` to reverse the order of the bits in an integer.
- `Cls` to count the leading bits which are the same as the sign bit in
an integer, yielding one less than the size of the integer for 0 and -1.
- `Clz` to count the number of leading zeros in the bitwise representation of the
integer.
- `Ctz` to count the number of trailing zeros in the bitwise representation of the
integer.
- `Popcnt` to count the number of ones in the bitwise representation of the
integer.

Copyright (c) 2021, Arm Limited

cranelift/interpreter/src/step.rs

@@ -668,11 +668,40 @@ where
         Opcode::IshlImm => binary(Value::shl, arg(0)?, imm_as_ctrl_ty()?)?,
         Opcode::UshrImm => binary(Value::ushr, arg(0)?, imm_as_ctrl_ty()?)?,
         Opcode::SshrImm => binary(Value::ishr, arg(0)?, imm_as_ctrl_ty()?)?,
-        Opcode::Bitrev => unimplemented!("Bitrev"),
-        Opcode::Clz => unimplemented!("Clz"),
-        Opcode::Cls => unimplemented!("Cls"),
-        Opcode::Ctz => unimplemented!("Ctz"),
-        Opcode::Popcnt => unimplemented!("Popcnt"),
+        Opcode::Bitrev => assign(Value::reverse_bits(arg(0)?)?),
+        // For `Clz`, `Cls`, `Ctz`, and `Popcnt`, the underlying Rust function
+        // always returns `u32` (and therefore a `Value` of type `U32`), so this
+        // is switched back to the correct type by recreating the `Value`.
+        Opcode::Clz => assign(Value::int(
+            Value::leading_zeros(arg(0)?)?.into_int()?,
+            ctrl_ty,
+        )?),
+        Opcode::Cls => {
+            let count = if Value::lt(&arg(0)?, &Value::int(0, ctrl_ty)?)? {
+                Value::int(Value::leading_ones(arg(0)?)?.into_int()?, ctrl_ty)?
+            } else {
+                Value::int(Value::leading_zeros(arg(0)?)?.into_int()?, ctrl_ty)?
+            };
+            assign(Value::sub(count, Value::int(1, ctrl_ty)?)?)
+        }
+        Opcode::Ctz => assign(Value::int(
+            Value::trailing_zeros(arg(0)?)?.into_int()?,
+            ctrl_ty,
+        )?),
+        Opcode::Popcnt => {
+            let count = if arg(0)?.ty().is_int() {
+                Value::int(Value::count_ones(arg(0)?)?.into_int()?, ctrl_ty)?
+            } else {
+                let lanes = extractlanes(&arg(0)?, ctrl_ty.lane_type())?;
+                let mut new_vec = SimdVec::new();
+                for i in lanes {
+                    let c: V = Value::count_ones(i)?;
+                    new_vec.push(c);
+                }
+                vectorizelanes(&new_vec, ctrl_ty)?
+            };
+            assign(count)
+        }
         Opcode::Fcmp => assign(Value::bool(
             fcmp(inst.fp_cond_code().unwrap(), &arg(0)?, &arg(1)?)?,
             ctrl_ty.as_bool(),

cranelift/interpreter/src/value.rs

@@ -62,6 +62,13 @@ pub trait Value: Clone + From<DataValue> {
     fn or(self, other: Self) -> ValueResult<Self>;
     fn xor(self, other: Self) -> ValueResult<Self>;
     fn not(self) -> ValueResult<Self>;
+
+    // Bit counting.
+    fn count_ones(self) -> ValueResult<Self>;
+    fn leading_ones(self) -> ValueResult<Self>;
+    fn leading_zeros(self) -> ValueResult<Self>;
+    fn trailing_zeros(self) -> ValueResult<Self>;
+    fn reverse_bits(self) -> ValueResult<Self>;
 }
 
 #[derive(Error, Debug, PartialEq)]
@@ -132,6 +139,20 @@ pub enum ValueConversionKind {
 
 /// Helper for creating match expressions over [DataValue].
 macro_rules! unary_match {
+    ( $op:ident($arg1:expr); [ $( $data_value_ty:ident ),* ]; $return_value_ty:ident ) => {
+        match $arg1 {
+            $( DataValue::$data_value_ty(a) => {
+                Ok(DataValue::$return_value_ty(a.$op()))
+            } )*
+            _ => unimplemented!()
+        }
+    };
+    ( $op:ident($arg1:expr); [ $( $data_value_ty:ident ),* ] ) => {
+        match $arg1 {
+            $( DataValue::$data_value_ty(a) => { Ok(DataValue::$data_value_ty(a.$op())) } )*
+            _ => unimplemented!()
+        }
+    };
     ( $op:tt($arg1:expr); [ $( $data_value_ty:ident ),* ] ) => {
         match $arg1 {
             $( DataValue::$data_value_ty(a) => { Ok(DataValue::$data_value_ty($op a)) } )*
@@ -438,4 +459,24 @@ impl Value for DataValue {
     fn not(self) -> ValueResult<Self> {
         unary_match!(!(&self); [I8, I16, I32, I64])
     }
+
+    fn count_ones(self) -> ValueResult<Self> {
+        unary_match!(count_ones(&self); [I8, I16, I32, I64, I128, U8, U16, U32, U64, U128]; U32)
+    }
+
+    fn leading_ones(self) -> ValueResult<Self> {
+        unary_match!(leading_ones(&self); [I8, I16, I32, I64, I128, U8, U16, U32, U64, U128]; U32)
+    }
+
+    fn leading_zeros(self) -> ValueResult<Self> {
+        unary_match!(leading_zeros(&self); [I8, I16, I32, I64, I128, U8, U16, U32, U64, U128]; U32)
+    }
+
+    fn trailing_zeros(self) -> ValueResult<Self> {
+        unary_match!(trailing_zeros(&self); [I8, I16, I32, I64, I128, U8, U16, U32, U64, U128]; U32)
+    }
+
+    fn reverse_bits(self) -> ValueResult<Self> {
+        unary_match!(reverse_bits(&self); [I8, I16, I32, I64, I128, U8, U16, U32, U64, U128])
+    }
 }