impove integer check

folkertdev · folkertdev · commit 11aa613ae415 · 2026-04-28T23:11:28.000+02:00
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -6,6 +6,7 @@ mod simd;
 
 use std::assert_matches;
 
+use either::{Either, Left, Right};
 use rustc_abi::{FieldIdx, HasDataLayout, Size, VariantIdx};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_ast::{IntTy, UintTy};
@@ -60,8 +61,7 @@ pub(crate) enum MinMax {
 enum VarArgCompatible {
     Identical,
     Incompatible,
-    CastSignedToUnsigned(IntTy),
-    CastUnsignedToSigned(UintTy),
+    CastIntTo(Either<IntTy, UintTy>),
     ValidPtrCast,
 }
 
@@ -781,8 +781,11 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         arg_mplace: &MPlaceTy<'tcx, M::Provenance>,
         callee_type: TyAndLayout<'tcx>,
     ) -> InterpResult<'tcx> {
+        let callee_ty = callee_type.ty;
+        let caller_ty = arg_mplace.layout.ty;
+
         // Identical types are clearly compatible.
-        if arg_mplace.layout.ty == callee_type.ty {
+        if caller_ty == callee_ty {
             return interp_ok(());
         }
 
@@ -795,20 +798,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             )
         }
 
-        fn validate_cast<'tcx, T, U>(x: T, target_ty: Ty<'tcx>) -> InterpResult<'tcx>
-        where
-            T: std::fmt::Display + Copy,
-            U: std::fmt::Display + TryFrom<T>,
-        {
-            if U::try_from(x).is_ok() {
-                return interp_ok(());
-            }
-
-            throw_ub_format!(
-                "va_arg value mismatch: value `{x}` cannot be represented by type {target_ty}",
-            )
-        }
-
         match self.validate_c_variadic_compatible_ty(arg_mplace.layout.ty, callee_type.ty) {
             VarArgCompatible::Identical => interp_ok(()),
             VarArgCompatible::ValidPtrCast => interp_ok(()),
@@ -817,43 +806,24 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 callee_type.ty,
                 arg_mplace.layout.ty,
             ),
-            VarArgCompatible::CastSignedToUnsigned(int_ty) => {
+            VarArgCompatible::CastIntTo(target_ty) => {
                 // Check that the value can be represented in the target type.
-                let callee_ty = callee_type.ty;
-                let scalar = self.read_scalar(arg_mplace)?;
-                match int_ty {
-                    IntTy::Isize => match self.data_layout().pointer_size().bits() {
-                        16 => validate_cast::<i16, u16>(scalar.to_i16()?, callee_ty)?,
-                        32 => validate_cast::<i32, u32>(scalar.to_i32()?, callee_ty)?,
-                        64 => validate_cast::<i64, u64>(scalar.to_i64()?, callee_ty)?,
-                        _ => unreachable!("unexpected pointer size"),
-                    },
-                    IntTy::I8 => validate_cast::<i8, u8>(scalar.to_i8()?, callee_ty)?,
-                    IntTy::I16 => validate_cast::<i16, u16>(scalar.to_i16()?, callee_ty)?,
-                    IntTy::I32 => validate_cast::<i32, u32>(scalar.to_i32()?, callee_ty)?,
-                    IntTy::I64 => validate_cast::<i64, u64>(scalar.to_i64()?, callee_ty)?,
-                    IntTy::I128 => validate_cast::<i128, u128>(scalar.to_i128()?, callee_ty)?,
+                let ptr_size = self.data_layout().pointer_size();
+                let size = match target_ty {
+                    Left(int_ty) => Size::from_bits(int_ty.bit_width()).unwrap_or(ptr_size),
+                    Right(uint_ty) => Size::from_bits(uint_ty.bit_width()).unwrap_or(ptr_size),
                 };
 
-                interp_ok(())
-            }
-            VarArgCompatible::CastUnsignedToSigned(uint_ty) => {
-                // Check that the value can be represented in the target type.
-                let callee_ty = callee_type.ty;
                 let scalar = self.read_scalar(arg_mplace)?;
-                match uint_ty {
-                    UintTy::Usize => match self.data_layout().pointer_size().bits() {
-                        16 => validate_cast::<u16, i16>(scalar.to_u16()?, callee_ty)?,
-                        32 => validate_cast::<u32, i32>(scalar.to_u32()?, callee_ty)?,
-                        64 => validate_cast::<u64, i64>(scalar.to_u64()?, callee_ty)?,
-                        _ => unreachable!("unexpected pointer size"),
-                    },
-                    UintTy::U8 => validate_cast::<u8, i8>(scalar.to_u8()?, callee_ty)?,
-                    UintTy::U16 => validate_cast::<u16, i16>(scalar.to_u16()?, callee_ty)?,
-                    UintTy::U32 => validate_cast::<u32, i32>(scalar.to_u32()?, callee_ty)?,
-                    UintTy::U64 => validate_cast::<u64, i64>(scalar.to_u64()?, callee_ty)?,
-                    UintTy::U128 => validate_cast::<u128, i128>(scalar.to_u128()?, callee_ty)?,
-                };
+                if scalar.to_int(size)? < 0 {
+                    throw_ub_format!(
+                        "va_arg value mismatch: value `{value}_{caller_ty}` cannot be represented by type {callee_ty}",
+                        value = match target_ty {
+                            Left(_int_ty) => scalar.to_int(size)?.to_string(),
+                            Right(_uint_ty) => scalar.to_uint(size)?.to_string(),
+                        }
+                    )
+                }
 
                 interp_ok(())
             }
@@ -869,7 +839,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// - `T` is a signed integer and `U` the corresponding unsigned integer,
     /// - `T` is an unsigned integer and `U` the corresponding signed integer,
     /// - `T` and `U` are both pointers, and their target types are compatible.
-    /// - `T` is a pointer to `c_void` and `U` is a pointer to `i8` or `u8`.
+    /// - `T` is a pointer to `c_void` and `U` is a pointer to `i8` or `u8` (i.e., any "character type").
     /// - `T` is a pointer to `i8` or `u8` and `U` is a pointer to `c_void`.
     fn validate_c_variadic_compatible_ty(
         &mut self,
@@ -880,13 +850,17 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             return VarArgCompatible::Identical;
         }
 
-        // The signedness of c_char is irrelevant here.
+        // Any character type (`char`, `unsigned char` and `signed char`) is compatible with
+        // `void*`, so the signedness of `c_char` is irrelevant here.
         let is_c_char = |ty: Ty<'_>| matches!(ty.kind(), ty::Uint(UintTy::U8) | ty::Int(IntTy::I8));
 
         match (caller_type.kind(), callee_type.kind()) {
             (ty::RawPtr(caller_target_ty, _), ty::RawPtr(callee_target_ty, _)) => {
                 // Accept the cast if one type is pointer to qualified or unqualified void,
                 // and the other is a pointer to a qualified or unqualified character type.
+                //
+                // In C types can be qualified by a combination of `const`, `volatile` and
+                // `restrict`. These properties are not relevant for the ABI.
                 if caller_target_ty.is_c_void(self.tcx.tcx) && is_c_char(*callee_target_ty) {
                     return VarArgCompatible::ValidPtrCast;
                 }
diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
@@ -406,7 +406,7 @@ impl<'f> VaList<'f> {
     /// - `T` is a pointer to [`i8]` or [`u8`] and `U` is a pointer to [`c_void`].
     ///
     /// When `T` and `U` are both integer types, the value that the caller passes must be
-    /// representable by `U`.
+    /// representable by `T` and `U`.
     ///
     /// [`c_void`]: core::ffi::c_void
     #[inline] // Avoid codegen when not used to help backends that don't support VaList.
diff --git a/tests/ui/consts/const-eval/c-variadic-fail.rs b/tests/ui/consts/const-eval/c-variadic-fail.rs
@@ -52,9 +52,17 @@ unsafe fn read_cast_numeric() {
     const { read_as::<i32>(1u32) };
 
     const { read_as::<u32>(-1i32) };
-    //~^ ERROR va_arg value mismatch: value `-1` cannot be represented by type u32
+    //~^ ERROR va_arg value mismatch: value `-1_i32` cannot be represented by type u32
+    const { read_as::<u32>(i32::MIN) };
+    //~^ ERROR va_arg value mismatch: value `-2147483648_i32` cannot be represented by type u32
     const { read_as::<i32>(u32::MAX) };
-    //~^ ERROR va_arg value mismatch: value `4294967295` cannot be represented by type i32
+    //~^ ERROR va_arg value mismatch: value `4294967295_u32` cannot be represented by type i32
+    const { read_as::<i32>(i32::MAX as u32 + 1) };
+    //~^ ERROR va_arg value mismatch: value `2147483648_u32` cannot be represented by type i32
+    const { read_as::<i64>(u64::MAX) };
+    //~^ ERROR va_arg value mismatch: value `18446744073709551615_u64` cannot be represented by type i64
+    const { read_as::<i64>(i64::MAX as u64 + 1) };
+    //~^ ERROR va_arg value mismatch: value `9223372036854775808_u64` cannot be represented by type i64
 
     const { read_as::<i32>(1u64) };
     //~^ ERROR va_arg type mismatch: requested `i32` is incompatible with next argument of type `u64`
diff --git a/tests/ui/consts/const-eval/c-variadic-fail.stderr b/tests/ui/consts/const-eval/c-variadic-fail.stderr
