miri: for ABI mismatch errors, say which argument is the problem

Author: RalfJung

compiler/rustc_const_eval/messages.ftl

@@ -128,15 +128,19 @@ const_eval_frame_note_inner = inside {$where_ ->
 
 const_eval_frame_note_last = the failure occurred here
 
+const_eval_incompatible_arg_types =
+    calling a function whose {$arg_idx ->
+        [1] 1st
+        [2] 2nd
+        *[other] {$arg_idx}th
+    } parameter has type {$callee_ty} passing argument of type {$caller_ty}
+
 const_eval_incompatible_calling_conventions =
     calling a function with calling convention "{$callee_conv}" using calling convention "{$caller_conv}"
 
 const_eval_incompatible_return_types =
     calling a function with return type {$callee_ty} passing return place of type {$caller_ty}
 
-const_eval_incompatible_types =
-    calling a function with argument of type {$callee_ty} passing data of type {$caller_ty}
-
 const_eval_interior_mutable_borrow_escaping =
     interior mutable shared borrows of temporaries that have their lifetime extended until the end of the program are not allowed
     .label = this borrow of an interior mutable value refers to such a temporary

compiler/rustc_const_eval/src/errors.rs

@@ -500,7 +500,7 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
             InvalidNichedEnumVariantWritten { .. } => {
                 const_eval_invalid_niched_enum_variant_written
             }
-            AbiMismatchArgument { .. } => const_eval_incompatible_types,
+            AbiMismatchArgument { .. } => const_eval_incompatible_arg_types,
             AbiMismatchReturn { .. } => const_eval_incompatible_return_types,
         }
     }
@@ -625,12 +625,16 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
                 diag.arg("data_size", info.data_size);
             }
             InvalidNichedEnumVariantWritten { enum_ty } => {
-                diag.arg("ty", enum_ty.to_string());
+                diag.arg("ty", enum_ty);
             }
-            AbiMismatchArgument { caller_ty, callee_ty }
-            | AbiMismatchReturn { caller_ty, callee_ty } => {
-                diag.arg("caller_ty", caller_ty.to_string());
-                diag.arg("callee_ty", callee_ty.to_string());
+            AbiMismatchArgument { arg_idx, caller_ty, callee_ty } => {
+                diag.arg("arg_idx", arg_idx + 1); // adjust for 1-indexed lists in output
+                diag.arg("caller_ty", caller_ty);
+                diag.arg("callee_ty", callee_ty);
+            }
+            AbiMismatchReturn { caller_ty, callee_ty } => {
+                diag.arg("caller_ty", caller_ty);
+                diag.arg("callee_ty", callee_ty);
             }
         }
     }

compiler/rustc_const_eval/src/interpret/call.rs

@@ -270,6 +270,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             Item = (&'x FnArg<'tcx, M::Provenance>, &'y ArgAbi<'tcx, Ty<'tcx>>),
         >,
         callee_abi: &ArgAbi<'tcx, Ty<'tcx>>,
+        callee_arg_idx: usize,
         callee_arg: &mir::Place<'tcx>,
         callee_ty: Ty<'tcx>,
         already_live: bool,
@@ -298,6 +299,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         // Check compatibility
         if !self.check_argument_compat(caller_abi, callee_abi)? {
             throw_ub!(AbiMismatchArgument {
+                arg_idx: callee_arg_idx,
                 caller_ty: caller_abi.layout.ty,
                 callee_ty: callee_abi.layout.ty
             });
@@ -424,7 +426,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             // this is a single iterator (that handles `spread_arg`), then
             // `pass_argument` would be the loop body. It takes care to
             // not advance `caller_iter` for ignored arguments.
-            let mut callee_args_abis = callee_fn_abi.args.iter();
+            let mut callee_args_abis = callee_fn_abi.args.iter().enumerate();
             for local in body.args_iter() {
                 // Construct the destination place for this argument. At this point all
                 // locals are still dead, so we cannot construct a `PlaceTy`.
@@ -445,21 +447,23 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                             &[mir::ProjectionElem::Field(FieldIdx::from_usize(i), field_ty)],
                             *self.tcx,
                         );
-                        let callee_abi = callee_args_abis.next().unwrap();
+                        let (idx, callee_abi) = callee_args_abis.next().unwrap();
                         self.pass_argument(
                             &mut caller_args,
                             callee_abi,
+                            idx,
                             &dest,
                             field_ty,
                             /* already_live */ true,
                         )?;
                     }
                 } else {
                     // Normal argument. Cannot mark it as live yet, it might be unsized!
-                    let callee_abi = callee_args_abis.next().unwrap();
+                    let (idx, callee_abi) = callee_args_abis.next().unwrap();
                     self.pass_argument(
                         &mut caller_args,
                         callee_abi,
+                        idx,
                         &dest,
                         ty,
                         /* already_live */ false,

compiler/rustc_middle/src/mir/interpret/error.rs

@@ -426,7 +426,12 @@ pub enum UndefinedBehaviorInfo<'tcx> {
     /// Trying to set discriminant to the niched variant, but the value does not match.
     InvalidNichedEnumVariantWritten { enum_ty: Ty<'tcx> },
     /// ABI-incompatible argument types.
-    AbiMismatchArgument { caller_ty: Ty<'tcx>, callee_ty: Ty<'tcx> },
+    AbiMismatchArgument {
+        /// The index of the argument whose type is wrong.
+        arg_idx: usize,
+        caller_ty: Ty<'tcx>,
+        callee_ty: Ty<'tcx>,
+    },
     /// ABI-incompatible return types.
     AbiMismatchReturn { caller_ty: Ty<'tcx>, callee_ty: Ty<'tcx> },
 }

src/tools/miri/src/diagnostics.rs

@@ -382,7 +382,7 @@ pub fn report_error<'tcx>(
                             helps.push(note_span!(span, "{:?} was deallocated here:", alloc_id));
                         }
                     }
-                    AbiMismatchArgument { .. } | AbiMismatchReturn { .. } => {
+                    AbiMismatchArgument { .. } => {
                         helps.push(note!("this means these two types are not *guaranteed* to be ABI-compatible across all targets"));
                         helps.push(note!("if you think this code should be accepted anyway, please report an issue with Miri"));
                     }

src/tools/miri/src/helpers.rs

@@ -1079,6 +1079,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             .position(|b| !b)
         {
             throw_ub!(AbiMismatchArgument {
+                arg_idx: index,
                 caller_ty: caller_fn_abi.args[index].layout.ty,
                 callee_ty: callee_fn_abi.args[index].layout.ty
             });

src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs

@@ -17,5 +17,5 @@ fn main() {
     // These two types have the same size but are still not compatible.
     let g = unsafe { std::mem::transmute::<fn(S), fn(A)>(f) };
 
-    g(Default::default()) //~ ERROR: calling a function with argument of type S passing data of type [i32; 4]
+    g(Default::default()) //~ ERROR: type S passing argument of type [i32; 4]
 }

src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.stderr

@@ -1,4 +1,4 @@
-error: Undefined Behavior: calling a function with argument of type S passing data of type [i32; 4]
+error: Undefined Behavior: calling a function whose 1st parameter has type S passing argument of type [i32; 4]
   --> tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs:LL:CC
    |
 LL |     g(Default::default())

src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.rs

@@ -3,5 +3,5 @@ fn main() {
 
     let g = unsafe { std::mem::transmute::<fn(f32), fn(i32)>(f) };
 
-    g(42) //~ ERROR: calling a function with argument of type f32 passing data of type i32
+    g(42) //~ ERROR: type f32 passing argument of type i32
 }

src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.stderr

@@ -1,4 +1,4 @@
-error: Undefined Behavior: calling a function with argument of type f32 passing data of type i32
+error: Undefined Behavior: calling a function whose 1st parameter has type f32 passing argument of type i32
   --> tests/fail/function_pointers/abi_mismatch_int_vs_float.rs:LL:CC
    |
 LL |     g(42)