WIP: builder: more robust format_args! "decompiling".

Author: eddyb

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -3510,47 +3510,65 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                 if rt_args_count > 0 {
                     let rt_args_array_ptr_id = rt_args_slice_ptr_id.unwrap();
 
-                    // Each runtime argument has 4 instructions to call one of
+                    // Each runtime argument has A instructions to call one of
                     // the `fmt::rt::Argument::new_*` functions (and temporarily
-                    // store its result), and 4 instructions to copy it into
-                    // the appropriate slot in the array. The groups of 4 and 4
-                    // instructions, for all runtime args, are each separate.
-                    let copies_to_rt_args_array =
-                        try_rev_take(rt_args_count * 4).ok_or_else(|| {
+                    // store its result), and B instructions to copy it into
+                    // the appropriate slot in the array. The groups of A and B
+                    // instructions, for all runtime args, are each separate,
+                    // so the B×N later instructions are all processed first,
+                    // before moving (backwards) to the A×N earlier instructions.
+
+                    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(|| {
                             FormatArgsNotRecognized(
-                                "[fmt::rt::Argument; N] copies: ran out of instructions".into(),
+                                "[fmt::rt::Argument; N] copy: ran out of instructions".into(),
                             )
                         })?;
-                    let copies_to_rt_args_array = copies_to_rt_args_array.chunks(4);
-                    let rt_arg_new_calls = try_rev_take(rt_args_count * 4).ok_or_else(|| {
-                        FormatArgsNotRecognized(
-                            "fmt::rt::Argument::new calls: ran out of instructions".into(),
-                        )
-                    })?;
-                    let rt_arg_new_calls = rt_arg_new_calls.chunks(4);
+                        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::InBoundsAccessChain(src_field_ptr, src_base_ptr, 0),
+                                Inst::CopyMemory(copy_dst, copy_src),
+                            ] if array_base == 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)
+                            }
+                            _ => {
+                                Err(FormatArgsNotRecognized(format!(
+                                    "[fmt::rt::Argument; N] copy sequence ({copy_to_rt_args_array_insts:?})"
+                                )))
+                            }
+                        }
+                    }).collect::<Result<_, _>>()?;
 
-                    for (rt_arg_idx, (rt_arg_new_call_insts, copy_to_rt_args_array_insts)) in
-                        rt_arg_new_calls.zip(copies_to_rt_args_array).enumerate()
-                    {
-                        let call_ret_slot_ptr = match rt_arg_new_call_insts[..] {
+                    let rev_ref_arg_ids_with_ty_and_spec = (rev_copies_to_rt_args_array_src_ptrs
+                        .into_iter())
+                    .map(|copy_to_rt_args_array_src_ptr| {
+                        let rt_arg_new_call_insts = try_rev_take(4).ok_or_else(|| {
+                            FormatArgsNotRecognized(
+                                "fmt::rt::Argument::new call: ran out of instructions".into(),
+                            )
+                        })?;
+                        match rt_arg_new_call_insts[..] {
                             [
                                 Inst::Call(call_ret_id, callee_id, ref call_args),
                                 Inst::InBoundsAccessChain(tmp_slot_field_ptr, tmp_slot_ptr, 0),
                                 Inst::CompositeExtract(field, wrapper_newtype, 0),
                                 Inst::Store(st_dst_ptr, st_val),
                             ] if wrapper_newtype == call_ret_id
+                                && tmp_slot_ptr == copy_to_rt_args_array_src_ptr
                                 && (st_dst_ptr, st_val) == (tmp_slot_field_ptr, field) =>
                             {
                                 self.fmt_rt_arg_new_fn_ids_to_ty_and_spec
                                     .borrow()
                                     .get(&callee_id)
                                     .and_then(|&(ty, spec)| match call_args[..] {
-                                        [x] => {
-                                            decoded_format_args
-                                                .ref_arg_ids_with_ty_and_spec
-                                                .push((x, ty, spec));
-                                            Some(tmp_slot_ptr)
-                                        }
+                                        [x] => Some((x, ty, spec)),
                                         _ => None,
                                     })
                             }
@@ -3560,26 +3578,13 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                             FormatArgsNotRecognized(format!(
                                 "fmt::rt::Argument::new call sequence ({rt_arg_new_call_insts:?})"
                             ))
-                        })?;
+                        })
+                    })
+                    .collect::<Result<_, _>>()?;
 
-                        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::InBoundsAccessChain(src_field_ptr, src_base_ptr, 0),
-                                Inst::CopyMemory(copy_dst, copy_src),
-                            ] if array_base == rt_args_array_ptr_id
-                                && array_idx as usize == rt_arg_idx
-                                && dst_base_ptr == array_slot
-                                && src_base_ptr == call_ret_slot_ptr
-                                && (copy_dst, copy_src) == (dst_field_ptr, src_field_ptr) => {}
-                            _ => {
-                                return Err(FormatArgsNotRecognized(format!(
-                                    "[fmt::rt::Argument; N] copies sequence ({copy_to_rt_args_array_insts:?})"
-                                )));
-                            }
-                        }
-                    }
+                    decoded_format_args.ref_arg_ids_with_ty_and_spec =
+                        rev_ref_arg_ids_with_ty_and_spec;
+                    decoded_format_args.ref_arg_ids_with_ty_and_spec.reverse();
                 }
 
                 // If the `pieces: &[&str]` slice needs a bitcast, it'll be here.