[WIP] cmov: fix aarch64 ASM bug; add regression test

The implementation was using the wrong register type when invoking
`csel` for `u64` (`:w` which is 32-bit, should use `:x` for 64-bit)

This captures the bug in a regression test and fixes it.

Author: tarcieri

cmov/src/aarch64.rs

@@ -1,7 +1,7 @@
 use crate::{Cmov, CmovEq, Condition};
 use core::arch::asm;
 
-macro_rules! csel {
+macro_rules! csel_32 {
     ($csel:expr, $dst:expr, $src:expr, $condition:expr) => {
         unsafe {
             asm! {
@@ -17,7 +17,23 @@ macro_rules! csel {
     };
 }
 
-macro_rules! csel_eq {
+macro_rules! csel_64 {
+    ($csel:expr, $dst:expr, $src:expr, $condition:expr) => {
+        unsafe {
+            asm! {
+                "cmp {0:x}, 0",
+                $csel,
+                in(reg) $condition,
+                inlateout(reg) *$dst,
+                in(reg) *$src,
+                in(reg) *$dst,
+                options(pure, nomem, nostack),
+            };
+        }
+    };
+}
+
+macro_rules! csel_eq_32 {
     ($instruction:expr, $lhs:expr, $rhs:expr, $condition:expr, $dst:expr) => {
         let mut tmp = *$dst as u16;
         unsafe {
@@ -39,74 +55,96 @@ macro_rules! csel_eq {
     };
 }
 
+macro_rules! csel_eq_64 {
+    ($instruction:expr, $lhs:expr, $rhs:expr, $condition:expr, $dst:expr) => {
+        let mut tmp = *$dst as u16;
+        unsafe {
+            asm! {
+                "eor {0:x}, {1:x}, {2:x}",
+                "cmp {0:x}, 0",
+                $instruction,
+                out(reg) _,
+                in(reg) *$lhs,
+                in(reg) *$rhs,
+                inlateout(reg) tmp,
+                in(reg) $condition as u16,
+                in(reg) tmp,
+                options(pure, nomem, nostack),
+            };
+        };
+
+        *$dst = tmp as u8;
+    };
+}
+
 impl Cmov for u16 {
     #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
-        csel!("csel {1:w}, {2:w}, {3:w}, NE", self, value, condition);
+        csel_32!("csel {1:w}, {2:w}, {3:w}, NE", self, value, condition);
     }
 
     #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
-        csel!("csel {1:w}, {2:w}, {3:w}, EQ", self, value, condition);
+        csel_32!("csel {1:w}, {2:w}, {3:w}, EQ", self, value, condition);
     }
 }
 
 impl CmovEq for u16 {
     #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
-        csel_eq!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);
+        csel_eq_32!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);
     }
 
     #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
-        csel_eq!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);
+        csel_eq_32!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);
     }
 }
 
 impl Cmov for u32 {
     #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
-        csel!("csel {1:w}, {2:w}, {3:w}, NE", self, value, condition);
+        csel_32!("csel {1:w}, {2:w}, {3:w}, NE", self, value, condition);
     }
 
     #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
-        csel!("csel {1:w}, {2:w}, {3:w}, EQ", self, value, condition);
+        csel_32!("csel {1:w}, {2:w}, {3:w}, EQ", self, value, condition);
     }
 }
 
 impl CmovEq for u32 {
     #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
-        csel_eq!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);
+        csel_eq_32!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);
     }
 
     #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
-        csel_eq!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);
+        csel_eq_32!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);
     }
 }
 
 impl Cmov for u64 {
     #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
-        csel!("csel {1:x}, {2:x}, {3:x}, NE", self, value, condition);
+        csel_64!("csel {1:x}, {2:x}, {3:x}, NE", self, value, condition);
     }
 
     #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
-        csel!("csel {1:x}, {2:x}, {3:x}, EQ", self, value, condition);
+        csel_64!("csel {1:x}, {2:x}, {3:x}, EQ", self, value, condition);
     }
 }
 
 impl CmovEq for u64 {
     #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
-        csel_eq!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);
+        csel_eq_64!("csel {3:x}, {4:x}, {5:x}, NE", self, rhs, input, output);
     }
 
     #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
-        csel_eq!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);
+        csel_eq_64!("csel {3:x}, {4:x}, {5:x}, EQ", self, rhs, input, output);
     }
 }

cmov/tests/regression.rs

@@ -0,0 +1,13 @@
+//! Tests for previous bugs in the implementation.
+
+use cmov::CmovEq;
+
+#[test]
+fn u64_cmoveq() {
+    let n = 0x8200_0000_0000_0000u64;
+    let mut cond = 0u8;
+    n.cmoveq(&0, 1u8, &mut cond);
+
+    // 0x8200_0000_0000_0000 is not equal to 0
+    assert_eq!(cond, 0);
+}