Port some compiletests from rust-gpu

We needed more compiletests, rust-gpu had some. So I ported them with AI and confirmed they passed.

Author: LegNeato

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 {
+ }
+}