builder: backport rust-lang/rust#134117 ([0, i] -> [i] for array GEPs).

Author: eddyb

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -655,6 +655,68 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // https://github.com/gpuweb/gpuweb/issues/33
         let (&ptr_base_index, indices) = combined_indices.split_first().unwrap();
 
+        // HACK(eddyb) this effectively removes any real support for GEPs with
+        // any `indices` (beyond `ptr_base_index`), which should now be the case
+        // across `rustc_codegen_ssa` (see also comment inside `inbounds_gep`).
+        // FIXME(eddyb) are the warning + fallback path even work keeping?
+        if !indices.is_empty() {
+            // HACK(eddyb) Cargo silences warnings in dependencies.
+            let force_warn = |span, msg| -> rustc_errors::Diag<'_, ()> {
+                rustc_errors::Diag::new(
+                    self.tcx.dcx(),
+                    rustc_errors::Level::ForceWarning(None),
+                    msg,
+                )
+                .with_span(span)
+            };
+            force_warn(
+                self.span(),
+                format!(
+                    "[RUST-GPU BUG] `inbounds_gep` or `gep` called with \
+                     {} combined indices (expected only 1)",
+                    combined_indices.len(),
+                ),
+            )
+            .emit();
+
+            let indexed_base_ptr = self.maybe_inbounds_gep(ty, ptr, &[ptr_base_index], is_inbounds);
+            let indexed_base_ptr_id = indexed_base_ptr.def(self);
+            assert_ty_eq!(self, indexed_base_ptr.ty, self.type_ptr_to(ty));
+
+            let mut final_pointee = ty;
+            for &index in indices {
+                final_pointee = match self.lookup_type(final_pointee) {
+                    SpirvType::Adt { field_types, .. } => {
+                        field_types[self
+                            .builder
+                            .lookup_const_scalar(index)
+                            .expect("non-const struct index for GEP")
+                            as usize]
+                    }
+                    SpirvType::Array { element, .. }
+                    | SpirvType::RuntimeArray { element }
+                    | SpirvType::Vector { element, .. }
+                    | SpirvType::Matrix { element, .. } => element,
+
+                    _ => self.fatal(format!(
+                        "GEP not implemented for indexing into type {}",
+                        self.debug_type(final_pointee)
+                    )),
+                };
+            }
+            let final_spirv_ptr_type = self.type_ptr_to(final_pointee);
+
+            let indices_ids: Vec<_> = indices.iter().map(|index| index.def(self)).collect();
+
+            return self.emit_access_chain(
+                final_spirv_ptr_type,
+                indexed_base_ptr_id,
+                None,
+                indices_ids,
+                is_inbounds,
+            );
+        }
+
         // Determine if this GEP operation is effectively byte-level addressing.
         // This check is based on the *provided* input type `ty`. If `ty` is i8 or u8,
         // it suggests the caller intends to perform byte-offset calculations,
@@ -1972,6 +2034,21 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         ptr: Self::Value,
         indices: &[Self::Value],
     ) -> Self::Value {
+        // HACK(eddyb) effectively a backport of this `gep [0, i]` -> `gep [i]`
+        // PR: https://github.com/rust-lang/rust/pull/134117 to even earlier
+        // nightlies - and that PR happens to remove the last GEP that can be
+        // emitted with any "structured" (struct/array) indices, beyond the
+        // "first index" (which acts as `<*T>::offset` aka "pointer arithmetic").
+        if let &[ptr_base_index, structured_index] = indices {
+            if self.builder.lookup_const_scalar(ptr_base_index) == Some(0) {
+                if let SpirvType::Array { element, .. } | SpirvType::RuntimeArray { element, .. } =
+                    self.lookup_type(ty)
+                {
+                    return self.maybe_inbounds_gep(element, ptr, &[structured_index], true);
+                }
+            }
+        }
+
         self.maybe_inbounds_gep(ty, ptr, indices, true)
     }
 

tests/compiletests/ui/lang/issue-46.stderr

@@ -0,0 +1,8 @@
+error: error:0:0 - Result type (OpTypeArray) does not match the type that results from indexing into the composite (OpTypeArray).
+         %67 = OpCompositeExtract %_arr_uint_uint_2 %49 0 0
+  |
+  = note: spirv-val failed
+  = note: module `$TEST_BUILD_DIR/lang/issue-46.spv1.3`
+
+error: aborting due to 1 previous error
+

tests/compiletests/ui/storage_class/typed-buffer-simple.stderr

@@ -0,0 +1,8 @@
+error: error:0:0 - OpInBoundsAccessChain result type (OpTypeInt) does not match the type that results from indexing into the base <id> (OpTypeArray).
+         %33 = OpInBoundsAccessChain %_ptr_StorageBuffer_uint %28 %uint_0
+  |
+  = note: spirv-val failed
+  = note: module `$TEST_BUILD_DIR/storage_class/typed-buffer-simple.spv1.3`
+
+error: aborting due to 1 previous error
+