Fix inverted conditions in count_(leading|trailing)_zeros for 64-bit integers

Selecting between lower and upper 32-bit parts were swapped.

Author: LegNeato

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -531,18 +531,19 @@ impl Builder<'_, '_> {
                         let higher = self.emit().u_convert(u32, None, higher).unwrap();
 
                         if trailing {
-                            let use_lower = self.emit().i_equal(bool, None, higher, u32_0).unwrap();
+                            let use_lower = self.emit().i_equal(bool, None, lower, u32_0).unwrap();
                             let lower_bits = find_xsb(lower, 32);
                             let higher_bits = find_xsb(higher, 0);
                             self.emit()
-                                .select(u32, None, use_lower, lower_bits, higher_bits)
+                                .select(u32, None, use_lower, higher_bits, lower_bits)
                                 .unwrap()
                         } else {
-                            let use_higher = self.emit().i_equal(bool, None, lower, u32_0).unwrap();
+                            let use_higher =
+                                self.emit().i_equal(bool, None, higher, u32_0).unwrap();
                             let lower_bits = find_xsb(lower, 0);
                             let higher_bits = find_xsb(higher, 32);
                             self.emit()
-                                .select(u32, None, use_higher, higher_bits, lower_bits)
+                                .select(u32, None, use_higher, lower_bits, higher_bits)
                                 .unwrap()
                         }
                     }

tests/ui/lang/core/intrinsics/leading_zeros.rs

@@ -0,0 +1,47 @@
+// build-pass
+
+use spirv_std::spirv;
+
+#[spirv(fragment)]
+pub fn main() {
+    // 8-bit tests
+    assert!(0b00000000_u8.leading_zeros() == 8);
+    assert!(0b00000001_u8.leading_zeros() == 7);
+    assert!(0b00010000_u8.leading_zeros() == 3);
+    assert!(0b10000000_u8.leading_zeros() == 0);
+    assert!(0b11111111_u8.leading_zeros() == 0);
+
+    // 16-bit tests
+    assert!(0x0000_u16.leading_zeros() == 16);
+    assert!(0x0001_u16.leading_zeros() == 15);
+    assert!(0x0100_u16.leading_zeros() == 7);
+    assert!(0x8000_u16.leading_zeros() == 0);
+    assert!(0xFFFF_u16.leading_zeros() == 0);
+
+    // 32-bit tests
+    assert!(0x00000000_u32.leading_zeros() == 32);
+    assert!(0x00000001_u32.leading_zeros() == 31);
+    assert!(0x00010000_u32.leading_zeros() == 15);
+    assert!(0x80000000_u32.leading_zeros() == 0);
+    assert!(0xFFFFFFFF_u32.leading_zeros() == 0);
+
+    // 64-bit tests
+    assert!(0x0000000000000000_u64.leading_zeros() == 64);
+    assert!(0x0000000000000001_u64.leading_zeros() == 63);
+    assert!(0x8000000000000000_u64.leading_zeros() == 0);
+    assert!(0xFFFFFFFFFFFFFFFF_u64.leading_zeros() == 0);
+    assert!(0x00000000_12345678_u64.leading_zeros() == 32);
+    assert!(0x00000000_80000000_u64.leading_zeros() == 32);
+    assert!(0x00100000_00000000_u64.leading_zeros() == 11);
+    assert!(0x12345678_00000000_u64.leading_zeros() == 3);
+
+    // Signed integers (should behave the same as unsigned)
+    assert!(0i8.leading_zeros() == 8);
+    assert!((-1i8).leading_zeros() == 0);
+    assert!(0i16.leading_zeros() == 16);
+    assert!((-1i16).leading_zeros() == 0);
+    assert!(0i32.leading_zeros() == 32);
+    assert!((-1i32).leading_zeros() == 0);
+    assert!(0i64.leading_zeros() == 64);
+    assert!((-1i64).leading_zeros() == 0);
+}

tests/ui/lang/core/intrinsics/trailing_zeros.rs

@@ -0,0 +1,47 @@
+// build-pass
+
+use spirv_std::spirv;
+
+#[spirv(fragment)]
+pub fn main() {
+    // 8-bit tests
+    assert!(0b00000000_u8.trailing_zeros() == 8);
+    assert!(0b00000001_u8.trailing_zeros() == 0);
+    assert!(0b00010000_u8.trailing_zeros() == 4);
+    assert!(0b10000000_u8.trailing_zeros() == 7);
+    assert!(0b11111110_u8.trailing_zeros() == 1);
+
+    // 16-bit tests
+    assert!(0x0000_u16.trailing_zeros() == 16);
+    assert!(0x0001_u16.trailing_zeros() == 0);
+    assert!(0x0100_u16.trailing_zeros() == 8);
+    assert!(0x8000_u16.trailing_zeros() == 15);
+    assert!(0xFFFE_u16.trailing_zeros() == 1);
+
+    // 32-bit tests
+    assert!(0x00000000_u32.trailing_zeros() == 32);
+    assert!(0x00000001_u32.trailing_zeros() == 0);
+    assert!(0x00010000_u32.trailing_zeros() == 16);
+    assert!(0x80000000_u32.trailing_zeros() == 31);
+    assert!(0xFFFFFFFE_u32.trailing_zeros() == 1);
+
+    // 64-bit tests
+    assert!(0x0000000000000000_u64.trailing_zeros() == 64);
+    assert!(0x0000000000000001_u64.trailing_zeros() == 0);
+    assert!(0x8000000000000000_u64.trailing_zeros() == 63);
+    assert!(0xFFFFFFFFFFFFFFFE_u64.trailing_zeros() == 1);
+    assert!(0x12340000_00000000_u64.trailing_zeros() == 32);
+    assert!(0x00000001_00000000_u64.trailing_zeros() == 32);
+    assert!(0x00000000_00001000_u64.trailing_zeros() == 12);
+    assert!(0x00000000_80000000_u64.trailing_zeros() == 31);
+
+    // Signed integers (should behave the same as unsigned)
+    assert!(0i8.trailing_zeros() == 8);
+    assert!((-1i8).trailing_zeros() == 0);
+    assert!(0i16.trailing_zeros() == 16);
+    assert!((-1i16).trailing_zeros() == 0);
+    assert!(0i32.trailing_zeros() == 32);
+    assert!((-1i32).trailing_zeros() == 0);
+    assert!(0i64.trailing_zeros() == 64);
+    assert!((-1i64).trailing_zeros() == 0);
+}