add slice cast support

[39ali]

fixes casting array as a slice , or array to ptr :

*[T; N] -> *[T]

*[T; N] -> *T

fixes #465

[Firestar99]

Rebased it on main, squashed the fmt fixes and added disassembly and arrays from consts to the compiletest.

Overall, I'm super impressed how simple this has turned out to be. I haven't looked at our existing pointer emulation too deeply before, but this seems quite logical.

@LegNeato But this also shows that I've been wrong about RuntimeArray only being used via spirv_std::RuntimeArray, it is also used to represent slices. Just that those slices get removed in the post-link legalization, since they contain a pointer, so you don't actually see them in the disassembly of the compiletest.
See:

rust-gpu/crates/rustc_codegen_spirv/src/abi.rs

Lines 637 to 646 in bdf8bae

	FieldsShape::Array { stride, count } => {
	let element_type = ty.field(cx, 0).spirv_type(span, cx);
	if ty.is_unsized() {
	// There's a potential for this array to be sized, but the element to be unsized, e.g. `[[u8]; 5]`.
	// However, I think rust disallows all these cases, so assert this here.
	assert_eq!(count, 0);
	SpirvType::RuntimeArray {
	element: element_type,
	}
	.def(span, cx)

[39ali]

@Firestar99 we should probably use LogicalPtrCast in the future and resolve it in qptr, but the issue it'll get zombied since i think qptr is not on by default

[eddyb]

I'm not sure why this change even helps - is it hiding errors that don't end up mattering in the end?

One way you could check is compiling (using some Rust-GPU version without this change) with RUSTGPU_CODEGEN_ARGS=--no-early-report-zombies (which moves the "zombie" reporting much later, near the end of the SPIR-T part of the linker).

For the test, I believe this is equivalent:

// compile-flags: -C llvm-args=--no-early-report-zombies

[eddyb]

How come this is needed, won't recover_access_chain_from_offset produce the same effect?

[eddyb]

Looks like this is doing *[T; N] -> *T -> *[T], using an OpInBoundsAccessChain for the first step, and OpBitcast for the second step, but:

1. that OpBitcast is illegal, but won't be seen by the same zombie-creating logic that would be triggered by using self.pointercast(elem_ptr, dest_ty)
2. creating SpirvValueKind::LogicalPtrCast (like calling pointercast recursively would do) allows later stripping the cast, so it should be more helpful?

I can't see how this helps, other than hiding an error?

[eddyb]

The test from this PR passes on main with only this change:

--- a/tests/compiletests/ui/lang/core/array-slice-cast.rs
+++ b/tests/compiletests/ui/lang/core/array-slice-cast.rs
@@ -1,5 +1,5 @@
@@ -1,5 +1,5 @@
 // build-pass
-// compile-flags: -C llvm-args=--disassemble
+// compile-flags: -C llvm-args=--disassemble -C llvm-args=--no-early-report-zombies

I've been meaning for a while to replace the old zombie system:

• Replace "zombie" system with post-legalization SPIR-T validation. EmbarkStudios/rust-gpu#1095
  (TIL it didn't get migrated: [meta] Issue migration (from old repo) wasn't 100% successful. #581)

---

In this specific case, I am guessing inlining removes the need for a *[T]-typed pointer, but I don't recall us having a pass to actually remove OpBitcasts, so I'm not sure how this ends up working.