changes after code review

Author: folkertdev

compiler/rustc_const_eval/src/interpret/call.rs

@@ -371,7 +371,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
                 (fixed_count, self.tcx.mk_type_list_from_iter(extra_tys))
             } else {
-                (caller_fn_abi.args.len(), ty::List::empty())
+                (caller_fn_abi.fixed_count.try_into().unwrap(), ty::List::empty())
             };
 
         let callee_fn_abi = self.fn_abi_of_instance(instance, callee_c_variadic_args)?;
@@ -393,7 +393,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             });
         }
 
-        if caller_fn_abi.fixed_count != callee_fn_abi.fixed_count {
+        if caller_fn_abi.c_variadic && caller_fn_abi.fixed_count != callee_fn_abi.fixed_count {
             throw_ub!(CVariadicFixedCountMismatch {
                 caller: caller_fn_abi.fixed_count,
                 callee: callee_fn_abi.fixed_count,
@@ -472,12 +472,16 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             // `pass_argument` would be the loop body. It takes care to
             // not advance `caller_iter` for ignored arguments.
             let mut callee_args_abis = if caller_fn_abi.c_variadic {
-                // Only the fixed arguments are passed normally.
+                // Only the fixed arguments are passed normally. C-variadic functions cannot be
+                // `extern "Rust"` and `#[track_caller]` can only be applied to `extern "Rust"`, to
+                // the extra caller location argument is not relevant here.
+                assert!(!instance.def.requires_caller_location(*self.tcx));
                 callee_fn_abi.args[..fixed_count].iter().enumerate()
             } else {
-                // NOTE: this handles the extra caller location argument
-                // when `#[track_caller]` is used. This attribute is only allowed on `extern "Rust"`
-                // functions, so the c-variadic case does not need to handle the extra argument.
+                // NOTE: this handles the extra caller location argument that is passed when
+                // `#[track_caller]` is used. The `fixed_count` does not account for this argument.
+                // This attribute is only allowed on `extern "Rust"` functions, so the c-variadic
+                // case does not need to handle the extra argument.
                 callee_fn_abi.args.iter().enumerate()
             };
 
@@ -501,7 +505,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                     // Consume the remaining arguments by putting them into the variable argument
                     // list.
                     let varargs = self.allocate_varargs(&mut caller_args)?;
-                    let key = self.va_list_ptr(varargs);
+                    // When the frame is dropped, these variable arguments are deallocated.
+                    self.frame_mut().va_list = varargs.clone();
+                    let key = self.va_list_ptr(varargs.into());
 
                     // Zero the VaList, so it is fully initialized.
                     self.write_bytes_ptr(

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -1287,13 +1287,12 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         let va_list_inner = self.project_field(va_list, FieldIdx::ZERO)?;
 
         // Find the first pointer field in this struct. The exact index is target-specific.
-        let ty::Adt(adt, _substs) = va_list_inner.layout().ty.kind() else {
+        let ty::Adt(adt, substs) = va_list_inner.layout().ty.kind() else {
             bug!("invalid VaListImpl layout");
         };
 
         for (i, field) in adt.non_enum_variant().fields.iter().enumerate() {
-            let field_ty = self.tcx.type_of(field.did);
-            if field_ty.skip_binder().is_raw_ptr() {
+            if field.ty(*self.tcx, substs).is_raw_ptr() {
                 return self.project_field(&va_list_inner, FieldIdx::from_usize(i));
             }
         }

compiler/rustc_const_eval/src/interpret/stack.rs

@@ -1,7 +1,6 @@
 //! Manages the low-level pushing and popping of stack frames and the (de)allocation of local variables.
 //! For handling of argument passing and return values, see the `call` module.
 use std::cell::Cell;
-use std::collections::VecDeque;
 use std::{fmt, mem};
 
 use either::{Either, Left, Right};
@@ -640,7 +639,7 @@ impl<'a, 'tcx: 'a, M: Machine<'tcx>> InterpCx<'tcx, M> {
     pub(crate) fn allocate_varargs<I>(
         &mut self,
         caller_args: &mut I,
-    ) -> InterpResult<'tcx, VecDeque<MPlaceTy<'tcx, M::Provenance>>>
+    ) -> InterpResult<'tcx, Vec<MPlaceTy<'tcx, M::Provenance>>>
     where
         I: Iterator<Item = (&'a FnArg<'tcx, M::Provenance>, &'a ArgAbi<'tcx, Ty<'tcx>>)>,
     {
@@ -655,10 +654,7 @@ impl<'a, 'tcx: 'a, M: Machine<'tcx>> InterpCx<'tcx, M> {
             varargs.push(mplace);
         }
 
-        // When the frame is dropped, these variable arguments are deallocated.
-        self.frame_mut().va_list = varargs.clone();
-
-        interp_ok(varargs.into())
+        interp_ok(varargs)
     }
 
     fn deallocate_varargs(

src/tools/miri/tests/fail/c-variadic-mismatch-count.rs

@@ -7,7 +7,7 @@ fn main() {
         let f = helper as *const ();
         let f = std::mem::transmute::<_, unsafe extern "C" fn(...)>(f);
 
-        f();
+        f(1);
         //~^ ERROR: Undefined Behavior
     }
 }

src/tools/miri/tests/fail/c-variadic-mismatch-count.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: calling a C-variadic function with 0 fixed arguments, but the function expects 1
   --> tests/fail/c-variadic-mismatch-count.rs:LL:CC
    |
-LL |         f();
-   |         ^^^ Undefined Behavior occurred here
+LL |         f(1);
+   |         ^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information