WIP: builder: castless noop in ptr_offset_strided.

Author: eddyb

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -759,8 +759,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         if const_offset == Some(Size::ZERO) {
             trace!("ptr_offset_strided: strategy 1 picked: offset 0 => pointer cast");
 
-            // FIXME(eddyb) could this just `return ptr;`? what even breaks?
-            return self.pointercast(ptr, self.type_ptr_to(stride_elem_ty));
+            // FIXME(eddyb) replace docs to remove mentions of pointer casting.
+            return ptr;
         }
 
         // Strategy 2: try recovering an `OpAccessChain` from a constant offset.
@@ -3261,6 +3261,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                     Bitcast(ID, ID),
                     CompositeExtract(ID, ID, u32),
                     InBoundsAccessChain(ID, ID, u32),
+                    InBoundsAccessChain2(ID, ID, u32, u32),
                     Store(ID, ID),
                     Load(ID, ID),
                     CopyMemory(ID, ID),
@@ -3317,6 +3318,13 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                                         Inst::Unsupported(inst.class.opcode)
                                     }
                                 }
+                                (Op::InBoundsAccessChain, Some(r), &[p, i, j]) => {
+                                    if let [Some(i), Some(j)] = [i, j].map(const_as_u32) {
+                                        Inst::InBoundsAccessChain2(r, p, i, j)
+                                    } else {
+                                        Inst::Unsupported(inst.class.opcode)
+                                    }
+                                }
                                 (Op::Store, None, &[p, v]) => Inst::Store(p, v),
                                 (Op::Load, Some(r), &[p]) => Inst::Load(r, p),
                                 (Op::CopyMemory, None, &[a, b]) => Inst::CopyMemory(a, b),
@@ -3508,20 +3516,45 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
 
                     let rev_copies_to_rt_args_array_src_ptrs: SmallVec<[_; 4]> =
                     (0..rt_args_count).rev().map(|rt_arg_idx| {
-                        let copy_to_rt_args_array_insts = try_rev_take(4).ok_or_else(|| {
+                        let mut copy_to_rt_args_array_insts = try_rev_take(3).ok_or_else(|| {
                             FormatArgsNotRecognized(
                                 "[fmt::rt::Argument; N] copy: ran out of instructions".into(),
                             )
                         })?;
+
+                        // HACK(eddyb) account for both the split and combined
+                        // access chain cases that `inbounds_gep` can now cause.
+                        if let Inst::InBoundsAccessChain(dst_field_ptr, dst_base_ptr, 0) =
+                            copy_to_rt_args_array_insts[0]
+                        {
+                            if let Some(mut prev_insts) = try_rev_take(1) {
+                                assert_eq!(prev_insts.len(), 1);
+                                let prev_inst = prev_insts.pop().unwrap();
+
+                                match prev_inst {
+                                    Inst::InBoundsAccessChain(
+                                        array_elem_ptr,
+                                        array_ptr,
+                                        idx,
+                                    ) if dst_base_ptr == array_elem_ptr => {
+                                        copy_to_rt_args_array_insts[0] =
+                                            Inst::InBoundsAccessChain2(dst_field_ptr, array_ptr, idx, 0);
+                                    }
+                                    _ => {
+                                        // HACK(eddyb) don't lose the taken `prev_inst`.
+                                        copy_to_rt_args_array_insts.insert(0, prev_inst);
+                                    }
+                                }
+                            }
+                        }
+
                         match copy_to_rt_args_array_insts[..] {
                             [
-                                Inst::InBoundsAccessChain(array_slot, array_base, array_idx),
-                                Inst::InBoundsAccessChain(dst_field_ptr, dst_base_ptr, 0),
+                                Inst::InBoundsAccessChain2(dst_field_ptr, dst_array_base_ptr, array_idx, 0),
                                 Inst::InBoundsAccessChain(src_field_ptr, src_base_ptr, 0),
                                 Inst::CopyMemory(copy_dst, copy_src),
-                            ] if array_base == rt_args_array_ptr_id
+                            ] if dst_array_base_ptr == rt_args_array_ptr_id
                                 && array_idx as usize == rt_arg_idx
-                                && dst_base_ptr == array_slot
                                 && (copy_dst, copy_src) == (dst_field_ptr, src_field_ptr) =>
                             {
                                 Ok(src_base_ptr)