Added tests for 64bit trailing_zeros

Author: voxelbee

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

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

tests/difftests/tests/Cargo.lock

@@ -46,6 +46,8 @@ members = [
     "lang/core/ops/vector_swizzle/vector_swizzle-wgsl",
     "lang/core/intrinsics/black_box_noop/with-black-box",
     "lang/core/intrinsics/black_box_noop/without-black-box",
+    "lang/core/intrinsics/trailing_zeros_64/trailing_zeros_64-rust",
+    "lang/core/intrinsics/trailing_zeros_64/trailing_zeros_64-cpu",
 ]
 
 [workspace.package]
@@ -55,7 +57,7 @@ publish = false
 
 [workspace.lints.rust]
 unexpected_cfgs = { level = "allow", check-cfg = [
-    'cfg(target_arch, values("spirv"))'
+    'cfg(target_arch, values("spirv"))',
 ] }
 
 [workspace.dependencies]

tests/difftests/tests/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "trailing_zeros_64-cpu"
+edition.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+difftest.workspace = true
+trailing_zeros_64-rust = { path = "../trailing_zeros_64-rust" }

tests/difftests/tests/lang/core/intrinsics/trailing_zeros_64/trailing_zeros_64-cpu/Cargo.toml

@@ -0,0 +1,13 @@
+use difftest::config::{Config, TestMetadata};
+use trailing_zeros_64_rust::TEST_DATA;
+
+fn main() {
+    let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap();
+
+    let output: Vec<u32> = TEST_DATA.iter().map(|v| v.trailing_zeros()).collect();
+
+    config.write_result(&output).unwrap();
+    config
+        .write_metadata(&TestMetadata::u32())
+        .expect("Failed to write metadata");
+}

tests/difftests/tests/lang/core/intrinsics/trailing_zeros_64/trailing_zeros_64-cpu/src/main.rs

@@ -0,0 +1,15 @@
+[package]
+name = "trailing_zeros_64-rust"
+edition.workspace = true
+
+[lints]
+workspace = true
+
+# GPU deps
+[dependencies]
+spirv-std.workspace = true
+
+# CPU deps (for the test harness)
+[target.'cfg(not(target_arch = "spirv"))'.dependencies]
+difftest.workspace = true
+bytemuck.workspace = true

tests/difftests/tests/lang/core/intrinsics/trailing_zeros_64/trailing_zeros_64-rust/Cargo.toml

@@ -0,0 +1,38 @@
+#![no_std]
+#![cfg_attr(target_arch = "spirv", feature(asm_experimental_arch))]
+
+use spirv_std::spirv;
+
+/// Test cases for 64-bit trailing_zeros - shared between GPU and CPU tests
+#[cfg(not(target_arch = "spirv"))]
+pub const TEST_DATA: [u64; 16] = [
+    0x0000000000000000,
+    0x0000000000000001,
+    0x8000000000000000,
+    0xFFFFFFFFFFFFFFFE,
+    0x1234000000000000,
+    0x0000000100000000,
+    0x0000000000001000,
+    0x0000000080000000,
+    0x0000000000000010,
+    0x0000000000000100,
+    0x0000000000010000,
+    0x0001000000000000,
+    0x0100000000000000,
+    0xFFFFFFFFFFFFFFFF,
+    0x8000000000000001,
+    0x4000000000000000,
+];
+
+#[spirv(compute(threads(1)))]
+pub fn main_cs(
+    #[spirv(storage_buffer, descriptor_set = 0, binding = 0)] input: &[u64],
+    #[spirv(storage_buffer, descriptor_set = 0, binding = 1)] output: &mut [u32],
+    #[spirv(global_invocation_id)] global_id: spirv_std::glam::UVec3,
+) {
+    let tid = global_id.x as usize;
+
+    if tid < input.len() && tid < output.len() {
+        output[tid] = input[tid].trailing_zeros();
+    }
+}

tests/difftests/tests/lang/core/intrinsics/trailing_zeros_64/trailing_zeros_64-rust/src/lib.rs

@@ -0,0 +1,55 @@
+#[cfg(not(target_arch = "spirv"))]
+fn main() {
+    use difftest::config::{Config, TestMetadata};
+    use difftest::scaffold::compute::{
+        AshBackend, BufferConfig, BufferUsage, ComputeShaderTest, RustComputeShader,
+    };
+    use difftest::spirv_builder::Capability;
+    use trailing_zeros_64_rust::TEST_DATA;
+
+    let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap();
+
+    // Skip on macOS due to Vulkan/MoltenVK configuration issues
+    #[cfg(target_os = "macos")]
+    {
+        use difftest::scaffold::Skip;
+
+        let skip = Skip::new("Ash tests are skipped on macOS due to MoltenVK configuration issues");
+        skip.run_test(&config).unwrap();
+        return;
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    {
+        let input_bytes: Vec<u8> = bytemuck::cast_slice(&TEST_DATA).to_vec();
+        let output_size = (TEST_DATA.len() * std::mem::size_of::<u32>()) as u64;
+
+        let buffers = vec![
+            BufferConfig {
+                size: input_bytes.len() as u64,
+                usage: BufferUsage::StorageReadOnly,
+                initial_data: Some(input_bytes),
+            },
+            BufferConfig {
+                size: output_size,
+                usage: BufferUsage::Storage,
+                initial_data: None,
+            },
+        ];
+
+        // Use Ash backend since wgpu/naga doesn't support Int64
+        let shader = RustComputeShader::default().with_capability(Capability::Int64);
+        let num_workgroups = TEST_DATA.len() as u32;
+        let test = ComputeShaderTest::<AshBackend, _>::new(shader, [num_workgroups, 1, 1], buffers)
+            .unwrap();
+
+        config
+            .write_metadata(&TestMetadata::u32())
+            .expect("Failed to write metadata");
+
+        test.run_test(&config).unwrap();
+    }
+}
+
+#[cfg(target_arch = "spirv")]
+fn main() {}