Emit clear error for index into zero-sized Arrays

crates/rustc_codegen_spirv/src/abi.rs

@@ -745,9 +745,6 @@ fn trans_aggregate<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>
                     element: element_type,
                 }
                 .def(span, cx)
-            } else if count == 0 {
-                // spir-v doesn't support zero-sized arrays
-                create_zst(cx, span, ty)
             } else {
                 let count_const = cx.constant_u32(span, count as u32);
                 let element_spv = cx.lookup_type(element_type);

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -409,7 +409,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let ptr = ptr.strip_ptrcasts();
         let mut leaf_ty = match self.lookup_type(ptr.ty) {
             SpirvType::Pointer { pointee } => pointee,
-            other => self.fatal(format!("non-pointer type: {other:?}")),
+            SpirvType::Adt { .. } => return None,
+            other => self.fatal(format!("adjust_pointer for non-pointer type: {other:?}")),
         };
 
         // FIXME(eddyb) this isn't efficient, `recover_access_chain_from_offset`
@@ -531,8 +532,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     let stride = ty_kind.sizeof(self)?;
                     ty_size = MaybeSized::Sized(stride);
 
-                    indices.push((offset.bytes() / stride.bytes()).try_into().ok()?);
-                    offset = Size::from_bytes(offset.bytes() % stride.bytes());
+                    if stride.bytes() == 0 {
+                        indices.push(0);
+                        offset = Size::from_bytes(0);
+                    } else {
+                        indices.push((offset.bytes() / stride.bytes()).try_into().ok()?);
+                        offset = Size::from_bytes(offset.bytes() % stride.bytes());
+                    }
                 }
                 _ => return None,
             }
@@ -569,6 +575,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             .iter()
             .map(|index| {
                 result_pointee_type = match self.lookup_type(result_pointee_type) {
+                    SpirvType::Array { count, element }
+                        if self.builder.lookup_const_scalar(count) == Some(0) =>
+                    {
+                        self.fatal(format!(
+                            "evaluation of constant value failed: cannot index into [{}; 0]",
+                            self.debug_type(element)
+                        ))
+                    }
                     SpirvType::Array { element, .. } | SpirvType::RuntimeArray { element } => {
                         element
                     }

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -480,6 +480,11 @@ impl<'tcx> CodegenCx<'tcx> {
                 }
                 self.constant_composite(ty, values.into_iter())
             }
+            SpirvType::Array { count, .. }
+                if self.builder.lookup_const_scalar(count) == Some(0) =>
+            {
+                self.undef(ty)
+            }
             SpirvType::Array { element, count } => {
                 let count = self.builder.lookup_const_scalar(count).unwrap() as usize;
                 let values = (0..count).map(|_| {

crates/rustc_codegen_spirv/src/spirv_type.rs

@@ -373,6 +373,9 @@ impl SpirvType<'_> {
                     .bytes(),
             )
             .expect("alignof: Vectors must have power-of-2 size"),
+            Self::Array { count, .. } if cx.builder.lookup_const_scalar(count) == Some(0) => {
+                Align::from_bytes(0).unwrap()
+            }
             Self::Array { element, .. }
             | Self::RuntimeArray { element }
             | Self::Matrix { element, .. } => cx.lookup_type(element).alignof(cx),

tests/README.md

@@ -21,3 +21,5 @@ the resulting binary with spirv-val). Because of this, there might be some stran
 the point isn't to make a fully functional shader every time (that would take an annoying amount of
 effort), but rather validate that specific parts of the compiler are doing their job correctly
 (either succeeding as they should, or erroring as they should).
+
+For more docs on compiletests, check the [rustc docs](https://rustc-dev-guide.rust-lang.org/tests/compiletest.html).

tests/ui/lang/core/array/array_0.rs

@@ -0,0 +1,11 @@
+#![allow(unconditional_panic)]
+
+// build-fail
+#![cfg_attr(target_arch = "spirv", no_std)]
+use spirv_std::spirv;
+
+#[spirv(compute(threads(1, 1, 1)))]
+pub fn compute() {
+    let array = [0; 0];
+    let x = array[0];
+}

tests/ui/lang/core/array/array_0.stderr

@@ -0,0 +1,8 @@
+error: evaluation of constant value failed: cannot index into [i32; 0]
+  --> $DIR/array_0.rs:10:13
+   |
+10 |     let x = array[0];
+   |             ^^^^^^^^
+
+error: aborting due to 1 previous error
+

tests/ui/lang/core/array/array_entry_param.rs

@@ -0,0 +1,9 @@
+// build-fail
+#![allow(unconditional_panic)]
+
+#![cfg_attr(target_arch = "spirv", no_std)]
+use spirv_std::spirv;
+
+// note that &mut [usize; 0] will cause an even worse panic
+#[spirv(compute(threads(1, 1, 1)))]
+pub fn compute(m: [usize; 0]) {}

tests/ui/lang/core/array/array_entry_param.stderr

@@ -0,0 +1,8 @@
+error: entry point parameter type not yet supported (`[usize; 0]` has size `0`)
+ --> $DIR/array_entry_param.rs:9:19
+  |
+9 | pub fn compute(m: [usize; 0]) {}
+  |                   ^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

tests/ui/lang/core/array/array_zst_0.rs

@@ -0,0 +1,12 @@
+// build-pass
+#![cfg_attr(target_arch = "spirv", no_std)]
+use spirv_std::spirv;
+
+#[spirv(compute(threads(1, 1, 1)))]
+pub fn compute() {
+    let mut array = [(); 0];
+    for i in 0..array.len() {
+      array[i] = ();
+    }
+    let () = array[0];
+}

tests/ui/lang/core/array/array_zst_0.stderr

@@ -0,0 +1,10 @@
+error: this operation will panic at runtime
+  --> $DIR/array_zst_0.rs:11:14
+   |
+11 |     let () = array[0];
+   |              ^^^^^^^^ index out of bounds: the length is 0 but the index is 0
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: aborting due to 1 previous error
+

tests/ui/lang/core/array/gep0.rs

@@ -0,0 +1,16 @@
+// build-fail
+
+#![cfg_attr(target_arch = "spirv", no_std)]
+use spirv_std::spirv;
+
+fn example<const N: usize>() {
+    let mut array = [0; N];
+    for i in 0..N {
+        array[i] += i;
+    }
+}
+
+#[spirv(compute(threads(1, 1, 1)))]
+pub fn compute() {
+    example::<0>();
+}

tests/ui/lang/core/array/gep0.stderr

@@ -0,0 +1,8 @@
+error: evaluation of constant value failed: cannot index into [u32; 0]
+ --> $DIR/gep0.rs:9:9
+  |
+9 |         array[i] += i;
+  |         ^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

tests/ui/lang/core/array/oob_0_array.rs

@@ -0,0 +1,16 @@
+// build-pass
+// compile-flags: -C llvm-args=--disassemble-entry=compute
+#![allow(unconditional_panic)]
+
+#![cfg_attr(target_arch = "spirv", no_std)]
+use spirv_std::spirv;
+
+#[spirv(compute(threads(1, 1, 1)))]
+pub fn compute() {
+    let mut array = [0; 0];
+    // writes to an array compile fine although they should be a panic.
+    // (&mut array)[0] = 1; // this fails to compile, but it seems that below is
+    // optimized out, and I'm not sure where.
+    // GEP is not being hit, and neither is any load/store.
+    array[0] = 1;
+}

tests/ui/lang/core/array/oob_0_array.stderr

@@ -0,0 +1,14 @@
+%1 = OpFunction  %2  None %3
+%4 = OpLabel
+OpLine %5 15 4
+%6 = OpULessThan  %7  %8 %8
+OpNoLine
+OpSelectionMerge %9 None
+OpBranchConditional %6 %10 %11
+%10 = OpLabel
+OpBranch %9
+%11 = OpLabel
+OpReturn
+%9 = OpLabel
+OpReturn
+OpFunctionEnd

tests/ui/lang/core/array/unused_array_0.rs

@@ -0,0 +1,7 @@
+#![cfg_attr(target_arch = "spirv", no_std)]
+use spirv_std::spirv;
+
+#[spirv(compute(threads(1, 1, 1)))]
+pub fn compute() {
+    let array = [0; 0];
+}