Port some compiletests from rust-gpu

tests/compiletests/ui/atomic/atomic_operations.rs

@@ -0,0 +1,38 @@
+// Test CUDA atomic operations compile correctly
+// build-pass
+
+use core::sync::atomic::Ordering;
+use cuda_std::atomic::{
+    AtomicF32, AtomicF64, BlockAtomicF32, BlockAtomicF64, SystemAtomicF32, SystemAtomicF64,
+};
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_cuda_atomic_floats() {
+    // Device-scoped atomic float
+    let atomic_f32 = AtomicF32::new(3.14);
+    let _old = atomic_f32.fetch_add(1.0, Ordering::Relaxed);
+    let _val = atomic_f32.load(Ordering::Relaxed);
+    atomic_f32.store(2.718, Ordering::Relaxed);
+
+    // Block-scoped atomic float
+    let block_atomic = BlockAtomicF32::new(1.5);
+    let _old = block_atomic.fetch_add(0.5, Ordering::Relaxed);
+
+    // System-scoped atomic float
+    let system_atomic = SystemAtomicF32::new(0.0);
+    let _old = system_atomic.fetch_add(1.0, Ordering::Relaxed);
+
+    // Test f64 as well
+    let atomic_f64 = AtomicF64::new(3.14159);
+    let _old = atomic_f64.fetch_add(1.0, Ordering::Relaxed);
+
+    // Test block-scoped f64
+    let block_f64 = BlockAtomicF64::new(2.718);
+    let _old = block_f64.fetch_sub(0.5, Ordering::Relaxed);
+
+    // Test bitwise operations on floats
+    let _old = atomic_f32.fetch_and(3.14, Ordering::Relaxed);
+    let _old = atomic_f32.fetch_or(1.0, Ordering::Relaxed);
+    let _old = atomic_f32.fetch_xor(2.0, Ordering::Relaxed);
+}

tests/compiletests/ui/float/float_extensions.rs

@@ -0,0 +1,42 @@
+// Test CUDA float extension functions compile correctly
+// build-pass
+
+use cuda_std::kernel;
+use cuda_std::FloatExt;
+
+#[kernel]
+pub unsafe fn test_float_extensions() {
+    let x = 3.14f32;
+
+    // Test various float extension methods
+    let _cospi = x.cospi();
+    let _erf = x.error_function();
+    let _erfc = x.complementary_error_function();
+    let _erfcx = x.scaled_complementary_error_function();
+
+    // Test frexp
+    let (_frac, _exp) = x.frexp();
+    let _exp = x.unbiased_exp();
+
+    // Test bessel functions
+    let _j0 = x.j0();
+    let _j1 = x.j1();
+    let _jn = x.jn(2);
+
+    // Test other functions
+    let _ldexp = x.ldexp(3);
+    let _lgamma = x.log_gamma();
+    let _log1p = x.log1p();
+
+    // Test normcdf functions
+    let _normcdf = x.norm_cdf();
+    let _normcdfinv = (0.5f32).inv_norm_cdf();
+
+    // Test sinpi
+    let _sinpi = x.sinpi();
+
+    // Test f64 as well
+    let y = 2.718f64;
+    let _cospi_f64 = y.cospi();
+    let _erf_f64 = y.error_function();
+}

tests/compiletests/ui/glam/mat3_vec3_multiply.rs

@@ -0,0 +1,11 @@
+// Tests multiplying a `Mat3` by a `Vec3`.
+// build-pass
+
+use cuda_std::glam;
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn mat3_vec3_multiply(input: glam::Mat3, output: *mut glam::Vec3) {
+    let vector = input * glam::Vec3::new(1.0, 2.0, 3.0);
+    *output = vector;
+}

tests/compiletests/ui/lang/consts/shallow-ref.rs

@@ -0,0 +1,26 @@
+// Test `&'static T` constants where the `T` values don't themselves contain
+// references, and where the `T` values aren't immediately loaded from.
+
+// build-pass
+
+use cuda_std::glam::{Mat2, Vec2};
+use cuda_std::kernel;
+
+#[inline(never)]
+fn scalar_load(r: &'static u32) -> u32 {
+    *r
+}
+
+const ROT90: Mat2 = Mat2::from_cols_array_2d(&[[0.0, 1.0], [-1.0, 0.0]]);
+
+#[kernel]
+pub unsafe fn test_shallow_ref(
+    scalar_out: *mut u32,
+    vec_in: Vec2,
+    bool_out: *mut u32,
+    vec_out: *mut Vec2,
+) {
+    *scalar_out = scalar_load(&123);
+    *bool_out = (vec_in == Vec2::ZERO) as u32;
+    *vec_out = ROT90.transpose() * vec_in;
+}

tests/compiletests/ui/lang/control_flow/for_range.rs

@@ -0,0 +1,8 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_for_range(i: u32) {
+    for _ in 0..i {}
+}

tests/compiletests/ui/lang/control_flow/for_range_signed.rs

@@ -0,0 +1,8 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_for_range_signed(i: i32) {
+    for _ in 0..i {}
+}

tests/compiletests/ui/lang/control_flow/for_with_custom_range_iter.rs

@@ -0,0 +1,31 @@
+// NOTE(eddyb) this tests `for` loop desugaring (with its call to `Iterator::next`
+// and matching on the resulting `Option`), without relying on a `Range` iterator.
+// More precisely, `Range` used to not compile, due to it using `mem::replace`,
+// which, before https://github.com/rust-lang/rust/pull/83022, used to just call
+// `mem::swap` (which has a block-wise optimization that can't work on SPIR-V).
+
+// build-pass
+
+use core::ops::Range;
+use cuda_std::kernel;
+use cuda_std::vek::num_traits::Num;
+
+struct RangeIter<T>(Range<T>);
+
+impl<T: Num + Ord + Copy> Iterator for RangeIter<T> {
+    type Item = T;
+    fn next(&mut self) -> Option<T> {
+        let x = self.0.start;
+        if x >= self.0.end {
+            None
+        } else {
+            self.0.start = x + T::one();
+            Some(x)
+        }
+    }
+}
+
+#[kernel]
+pub unsafe fn test_custom_range_iter(i: i32) {
+    for _ in RangeIter(0..i) {}
+}

tests/compiletests/ui/lang/control_flow/if.rs

@@ -0,0 +1,8 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_if(i: i32) {
+    if i > 0 {}
+}

tests/compiletests/ui/lang/control_flow/if_else.rs

@@ -0,0 +1,10 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_if_else(i: i32) {
+    if i > 0 {
+    } else {
+    }
+}

tests/compiletests/ui/lang/control_flow/if_else_if_else.rs

@@ -0,0 +1,11 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_if_else_if_else(i: i32) {
+    if i > 0 {
+    } else if i < 0 {
+    } else {
+    }
+}

tests/compiletests/ui/lang/control_flow/if_if.rs

@@ -0,0 +1,10 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_if_if(i: i32) {
+    if i > 0 {
+        if i < 10 {}
+    }
+}

tests/compiletests/ui/lang/control_flow/if_return_else.rs

@@ -0,0 +1,11 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_if_return_else(i: i32) {
+    if i < 10 {
+        return;
+    } else {
+    }
+}

tests/compiletests/ui/lang/control_flow/if_return_else_return.rs

@@ -0,0 +1,12 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_if_return_else_return(i: i32) {
+    if i < 10 {
+        return;
+    } else {
+        return;
+    }
+}

tests/compiletests/ui/lang/control_flow/if_while.rs

@@ -0,0 +1,10 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_if_while(i: i32) {
+    if i == 0 {
+        while i < 10 {}
+    }
+}

tests/compiletests/ui/lang/control_flow/ifx2.rs

@@ -0,0 +1,9 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_ifx2(i: i32) {
+    if i > 0 {}
+    if i > 1 {}
+}

tests/compiletests/ui/lang/control_flow/issue_283.rs

@@ -0,0 +1,49 @@
+// build-pass
+
+use cuda_std::glam::*;
+use cuda_std::kernel;
+
+fn sphere_sdf(p: Vec3) -> f32 {
+    p.length() - 1.0
+}
+
+// Global scene to render
+fn scene_sdf(p: Vec3) -> f32 {
+    sphere_sdf(p)
+}
+
+fn render(eye: Vec3, dir: Vec3, start: f32, end: f32) -> f32 {
+    let max_marching_steps: i32 = 255;
+    let epsilon: f32 = 0.0001;
+
+    let mut depth = start;
+    let mut i = 0;
+
+    loop {
+        if i < max_marching_steps {
+            break;
+        }
+
+        let dist = scene_sdf(eye + depth * dir);
+
+        if dist < epsilon {
+            return depth;
+        }
+
+        depth += dist;
+
+        if depth >= end {
+            return end;
+        }
+
+        i += 1;
+    }
+
+    end
+}
+
+#[kernel]
+pub unsafe fn test_issue_283() {
+    let v = Vec3::new(1.0, 1.0, 1.0);
+    render(v, v, 1.0, 2.0);
+}

tests/compiletests/ui/lang/control_flow/loop.rs

@@ -0,0 +1,8 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_loop() {
+    loop {}
+}

tests/compiletests/ui/lang/control_flow/while.rs

@@ -0,0 +1,8 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_while(i: i32) {
+    while i < 10 {}
+}

tests/compiletests/ui/lang/control_flow/while_break.rs

@@ -0,0 +1,10 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_while_break(i: i32) {
+    while i < 10 {
+        break;
+    }
+}

tests/compiletests/ui/lang/control_flow/while_continue.rs

@@ -0,0 +1,10 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_while_continue(i: i32) {
+    while i < 10 {
+        continue;
+    }
+}

tests/compiletests/ui/lang/control_flow/while_if_break.rs

@@ -0,0 +1,12 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_while_if_break(i: i32) {
+    while i < 10 {
+        if i == 0 {
+            break;
+        }
+    }
+}

tests/compiletests/ui/lang/control_flow/while_if_break_else_break.rs

@@ -0,0 +1,14 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_while_if_break_else_break(i: i32) {
+    while i < 10 {
+        if i == 0 {
+            break;
+        } else {
+            break;
+        }
+    }
+}

tests/compiletests/ui/lang/control_flow/while_if_break_if_break.rs

@@ -0,0 +1,15 @@
+// build-pass
+
+use cuda_std::kernel;
+
+#[kernel]
+pub unsafe fn test_while_if_break_if_break(i: i32) {
+    while i < 10 {
+        if i == 0 {
+            break;
+        }
+        if i == 1 {
+            break;
+        }
+    }
+}