repr(C) enums: fix enum size mismatch on MSVC targets

RalfJung · RalfJung · commit 5f6145eb735f · 2025-09-13T14:31:03.000+02:00
diff --git a/compiler/rustc_abi/src/layout.rs b/compiler/rustc_abi/src/layout.rs
@@ -757,7 +757,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
 
         let niche_filling_layout = calculate_niche_filling_layout();
 
-        let discr_type = repr.discr_type();
+        let discr_type = repr.discr_type(dl);
         let discr_int = Integer::from_attr(dl, discr_type);
         // Because we can only represent one range of valid values, we'll look for the
         // largest range of invalid values and pick everything else as the range of valid
@@ -875,7 +875,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             return Err(LayoutCalculatorError::SizeOverflow);
         }
 
-        let typeck_ity = Integer::from_attr(dl, repr.discr_type());
+        let typeck_ity = Integer::from_attr(dl, repr.discr_type(dl));
         if typeck_ity < min_ity {
             // It is a bug if Layout decided on a greater discriminant size than typeck for
             // some reason at this point (based on values discriminant can take on). Mostly
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
@@ -183,8 +183,22 @@ impl ReprOptions {
 
     /// Returns the discriminant type, given these `repr` options.
     /// This must only be called on enums!
-    pub fn discr_type(&self) -> IntegerType {
-        self.int.unwrap_or(IntegerType::Pointer(true))
+    ///
+    /// This is the "typeck type" of the discriminant, which is effectively the maximum size:
+    /// discriminant values will be wrapped to fit (with a lint). Layout can later decide to use a
+    /// smaller type (which it will do depending on the actual discriminant values, also enforcing
+    /// `c_enum_min_size` along the way) and that will work just fine, it just induces casts when
+    /// getting/setting the discriminant.
+    pub fn discr_type(&self, cx: &impl HasDataLayout) -> IntegerType {
+        self.int.unwrap_or(
+            if self.c()
+                && let Some(max_size) = cx.data_layout().c_enum_max_size
+            {
+                IntegerType::Fixed(max_size, true)
+            } else {
+                IntegerType::Pointer(true)
+            },
+        )
     }
 
     /// Returns `true` if this `#[repr()]` should inhabit "smart enum
@@ -274,6 +288,8 @@ pub struct TargetDataLayout {
     /// Note: This isn't in LLVM's data layout string, it is `short_enum`
     /// so the only valid spec for LLVM is c_int::BITS or 8
     pub c_enum_min_size: Integer,
+    /// Maximum size of #[repr(C)] enums (defaults to pointer size).
+    pub c_enum_max_size: Option<Integer>,
 }
 
 impl Default for TargetDataLayout {
@@ -307,6 +323,7 @@ impl Default for TargetDataLayout {
             address_space_info: vec![],
             instruction_address_space: AddressSpace::ZERO,
             c_enum_min_size: Integer::I32,
+            c_enum_max_size: None,
         }
     }
 }
@@ -327,7 +344,7 @@ impl TargetDataLayout {
     /// [llvm data layout string](https://llvm.org/docs/LangRef.html#data-layout)
     ///
     /// This function doesn't fill `c_enum_min_size` and it will always be `I32` since it can not be
-    /// determined from llvm string.
+    /// determined from llvm string. Likewise, it does not fill in `c_enum_max_size`.
     pub fn parse_from_llvm_datalayout_string<'a>(
         input: &'a str,
         default_address_space: AddressSpace,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
@@ -607,7 +607,7 @@ pub(super) fn lower_variant_ctor(tcx: TyCtxt<'_>, def_id: LocalDefId) {
 
 pub(super) fn lower_enum_variant_types(tcx: TyCtxt<'_>, def_id: DefId) {
     let def = tcx.adt_def(def_id);
-    let repr_type = def.repr().discr_type();
+    let repr_type = def.repr().discr_type(&tcx);
     let initial = repr_type.initial_discriminant(tcx);
     let mut prev_discr = None::<Discr<'_>>;
 
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -46,7 +46,7 @@ fn anon_const_type_of<'tcx>(icx: &ItemCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx
         }) if anon_hir_id == hir_id => const_arg_anon_type_of(icx, arg_hir_id, span),
 
         Node::Variant(Variant { disr_expr: Some(e), .. }) if e.hir_id == hir_id => {
-            tcx.adt_def(tcx.hir_get_parent_item(hir_id)).repr().discr_type().to_ty(tcx)
+            tcx.adt_def(tcx.hir_get_parent_item(hir_id)).repr().discr_type(&tcx).to_ty(tcx)
         }
         // Sort of affects the type system, but only for the purpose of diagnostics
         // so no need for ConstArg.
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
@@ -526,7 +526,7 @@ impl<'tcx> AdtDef<'tcx> {
     ) -> Result<Discr<'tcx>, ErrorGuaranteed> {
         assert!(self.is_enum());
 
-        let repr_type = self.repr().discr_type();
+        let repr_type = self.repr().discr_type(&tcx);
         match tcx.const_eval_poly(expr_did) {
             Ok(val) => {
                 let typing_env = ty::TypingEnv::post_analysis(tcx, expr_did);
@@ -561,7 +561,7 @@ impl<'tcx> AdtDef<'tcx> {
         tcx: TyCtxt<'tcx>,
     ) -> impl Iterator<Item = (VariantIdx, Discr<'tcx>)> {
         assert!(self.is_enum());
-        let repr_type = self.repr().discr_type();
+        let repr_type = self.repr().discr_type(&tcx);
         let initial = repr_type.initial_discriminant(tcx);
         let mut prev_discr = None::<Discr<'tcx>>;
         self.variants().iter_enumerated().map(move |(i, v)| {
@@ -600,7 +600,7 @@ impl<'tcx> AdtDef<'tcx> {
         {
             val
         } else {
-            self.repr().discr_type().initial_discriminant(tcx)
+            self.repr().discr_type(&tcx).initial_discriminant(tcx)
         };
         explicit_value.checked_add(tcx, offset as u128).0
     }
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -1589,7 +1589,7 @@ impl<'tcx> Ty<'tcx> {
     /// Returns the type of the discriminant of this type.
     pub fn discriminant_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
         match self.kind() {
-            ty::Adt(adt, _) if adt.is_enum() => adt.repr().discr_type().to_ty(tcx),
+            ty::Adt(adt, _) if adt.is_enum() => adt.repr().discr_type(&tcx).to_ty(tcx),
             ty::Coroutine(_, args) => args.as_coroutine().discr_ty(tcx),
 
             ty::Param(_) | ty::Alias(..) | ty::Infer(ty::TyVar(_)) => {
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
@@ -197,7 +197,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let (source, ty) = if let ty::Adt(adt_def, ..) = source_expr.ty.kind()
                     && adt_def.is_enum()
                 {
-                    let discr_ty = adt_def.repr().discr_type().to_ty(this.tcx);
+                    let discr_ty = adt_def.repr().discr_type(&this.tcx).to_ty(this.tcx);
                     let temp = unpack!(block = this.as_temp(block, scope, source, Mutability::Not));
                     let discr = this.temp(discr_ty, source_expr.span);
                     this.cfg.push_assign(
diff --git a/compiler/rustc_mir_build/src/builder/matches/test.rs b/compiler/rustc_mir_build/src/builder/matches/test.rs
@@ -89,7 +89,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     otherwise_block,
                 );
                 debug!("num_enum_variants: {}", adt_def.variants().len());
-                let discr_ty = adt_def.repr().discr_type().to_ty(self.tcx);
+                let discr_ty = adt_def.repr().discr_type(&self.tcx).to_ty(self.tcx);
                 let discr = self.temp(discr_ty, test.span);
                 self.cfg.push_assign(
                     block,
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -292,7 +292,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
             let (discr_did, discr_offset) = adt_def.discriminant_def_for_variant(idx);
 
             use rustc_middle::ty::util::IntTypeExt;
-            let ty = adt_def.repr().discr_type();
+            let ty = adt_def.repr().discr_type(&tcx);
             let discr_ty = ty.to_ty(tcx);
 
             let size = tcx
diff --git a/compiler/rustc_mir_transform/src/elaborate_drop.rs b/compiler/rustc_mir_transform/src/elaborate_drop.rs
@@ -937,7 +937,7 @@ where
         // Additionally, we do not want to switch on the
         // discriminant after it is free-ed, because that
         // way lies only trouble.
-        let discr_ty = adt.repr().discr_type().to_ty(self.tcx());
+        let discr_ty = adt.repr().discr_type(&self.tcx()).to_ty(self.tcx());
         let discr = Place::from(self.new_temp(discr_ty));
         let discr_rv = Rvalue::Discriminant(self.place);
         let switch_block = BasicBlockData::new_stmts(
diff --git a/compiler/rustc_mir_transform/src/large_enums.rs b/compiler/rustc_mir_transform/src/large_enums.rs
@@ -85,7 +85,7 @@ impl<'tcx> crate::MirPass<'tcx> for EnumSizeOpt {
                 let const_assign = StatementKind::Assign(Box::new((place, rval)));
 
                 let discr_place =
-                    Place::from(patch.new_temp(adt_def.repr().discr_type().to_ty(tcx), span));
+                    Place::from(patch.new_temp(adt_def.repr().discr_type(&tcx).to_ty(tcx), span));
                 let store_discr =
                     StatementKind::Assign(Box::new((discr_place, Rvalue::Discriminant(*rhs))));
 
diff --git a/compiler/rustc_target/src/spec/base/msvc.rs b/compiler/rustc_target/src/spec/base/msvc.rs
@@ -18,6 +18,11 @@ pub(crate) fn opts() -> TargetOptions {
         emit_debug_gdb_scripts: false,
         archive_format: "coff".into(),
 
+        // MSVC does not seem to ever automatically increase enums beyond their default size (see
+        // <https://github.com/rust-lang/rust/issues/124403>, <https://godbolt.org/z/1Pdb3hP9E>).
+        c_enum_min_bits: Some(32),
+        c_enum_max_bits: Some(32),
+
         // Currently this is the only supported method of debuginfo on MSVC
         // where `*.pdb` files show up next to the final artifact.
         split_debuginfo: SplitDebuginfo::Packed,
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
@@ -2386,6 +2386,13 @@ impl Target {
             self.c_enum_min_bits.unwrap_or(self.c_int_width as _),
         ))
         .map_err(|err| TargetDataLayoutErrors::InvalidBitsSize { err })?;
+        dl.c_enum_max_size = match self.c_enum_max_bits {
+            None => None,
+            Some(max_bits) => Some(
+                Integer::from_size(Size::from_bits(max_bits))
+                    .map_err(|err| TargetDataLayoutErrors::InvalidBitsSize { err })?,
+            ),
+        };
 
         Ok(dl)
     }
@@ -2797,6 +2804,8 @@ pub struct TargetOptions {
 
     /// Minimum number of bits in #[repr(C)] enum. Defaults to the size of c_int
     pub c_enum_min_bits: Option<u64>,
+    /// Maximum number of bits in #[repr(C)] enum. Defaults to the pointer size.
+    pub c_enum_max_bits: Option<u64>,
 
     /// Whether or not the DWARF `.debug_aranges` section should be generated.
     pub generate_arange_section: bool,
@@ -3044,6 +3053,7 @@ impl Default for TargetOptions {
             supported_split_debuginfo: Cow::Borrowed(&[SplitDebuginfo::Off]),
             supported_sanitizers: SanitizerSet::empty(),
             c_enum_min_bits: None,
+            c_enum_max_bits: None,
             generate_arange_section: true,
             supports_stack_protector: true,
             entry_name: "main".into(),
diff --git a/src/tools/clippy/clippy_lints/src/enum_clike.rs b/src/tools/clippy/clippy_lints/src/enum_clike.rs
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for UnportableVariant {
                         if let ty::Adt(adt, _) = ty.kind()
                             && adt.is_enum()
                         {
-                            ty = adt.repr().discr_type().to_ty(cx.tcx);
+                            ty = adt.repr().discr_type(&cx.tcx).to_ty(cx.tcx);
                         }
                         match ty.kind() {
                             ty::Int(IntTy::Isize) => {
diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs
@@ -169,11 +169,29 @@ pub trait Add<Rhs = Self> {
     fn add(self, _: Rhs) -> Self::Output;
 }
 
-impl Add<isize> for isize {
+impl Add for isize {
     type Output = isize;
 
     fn add(self, other: isize) -> isize {
-        7 // avoid needing to add all of the overflow handling and panic language items
+        loop {} // Dummy impl, not actually used
+    }
+}
+
+#[lang = "eq"]
+pub trait PartialEq<Rhs = Self> {
+    fn eq(&self, other: &Rhs) -> bool;
+
+    fn ne(&self, other: &Rhs) -> bool {
+        match self.eq(other) {
+            true => false,
+            false => true,
+        }
+    }
+}
+
+impl PartialEq for usize {
+    fn eq(&self, other: &Self) -> bool {
+        loop {} // Dummy impl, not actually used
     }
 }
 
@@ -231,6 +249,19 @@ pub mod mem {
     #[rustc_nounwind]
     #[rustc_intrinsic]
     pub unsafe fn transmute<Src, Dst>(src: Src) -> Dst;
+
+    #[rustc_nounwind]
+    #[rustc_intrinsic]
+    pub const fn size_of<T>() -> usize;
+    #[rustc_nounwind]
+    #[rustc_intrinsic]
+    pub const fn align_of<T>() -> usize;
+}
+
+pub mod hint {
+    #[rustc_nounwind]
+    #[rustc_intrinsic]
+    pub const unsafe fn unreachable() -> !;
 }
 
 #[lang = "c_void"]
diff --git a/tests/ui/enum-discriminant/repr-c-size.linux32.stderr b/tests/ui/enum-discriminant/repr-c-size.linux32.stderr
@@ -0,0 +1,15 @@
+warning: literal out of range for `isize`
+  --> $DIR/repr-c-size.rs:24:9
+   |
+LL |     A = 9223372036854775807, // i64::MAX
+   |         ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the literal `9223372036854775807` does not fit into the type `isize` whose range is `-2147483648..=2147483647`
+note: the lint level is defined here
+  --> $DIR/repr-c-size.rs:22:8
+   |
+LL | #[warn(overflowing_literals)]
+   |        ^^^^^^^^^^^^^^^^^^^^
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/enum-discriminant/repr-c-size.msvc32.stderr b/tests/ui/enum-discriminant/repr-c-size.msvc32.stderr
@@ -0,0 +1,16 @@
+warning: literal out of range for `i32`
+  --> $DIR/repr-c-size.rs:24:9
+   |
+LL |     A = 9223372036854775807, // i64::MAX
+   |         ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the literal `9223372036854775807` does not fit into the type `i32` whose range is `-2147483648..=2147483647`
+   = help: consider using the type `i64` instead
+note: the lint level is defined here
+  --> $DIR/repr-c-size.rs:22:8
+   |
+LL | #[warn(overflowing_literals)]
+   |        ^^^^^^^^^^^^^^^^^^^^
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/enum-discriminant/repr-c-size.msvc64.stderr b/tests/ui/enum-discriminant/repr-c-size.msvc64.stderr
@@ -0,0 +1,16 @@
+warning: literal out of range for `i32`
+  --> $DIR/repr-c-size.rs:24:9
+   |
+LL |     A = 9223372036854775807, // i64::MAX
+   |         ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the literal `9223372036854775807` does not fit into the type `i32` whose range is `-2147483648..=2147483647`
+   = help: consider using the type `i64` instead
+note: the lint level is defined here
+  --> $DIR/repr-c-size.rs:22:8
+   |
+LL | #[warn(overflowing_literals)]
+   |        ^^^^^^^^^^^^^^^^^^^^
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/enum-discriminant/repr-c-size.rs b/tests/ui/enum-discriminant/repr-c-size.rs
@@ -0,0 +1,37 @@
+//@ check-pass
+//@ revisions: linux32 linux64 msvc32 msvc64
+//@[linux32] compile-flags: --target i686-unknown-linux-gnu
+//@[linux32] needs-llvm-components: x86
+//@[linux64] compile-flags: --target x86_64-unknown-linux-gnu
+//@[linux64] needs-llvm-components: x86
+//@[msvc32] compile-flags: --target i686-pc-windows-msvc
+//@[msvc32] needs-llvm-components: x86
+//@[msvc64] compile-flags: --target x86_64-pc-windows-msvc
+//@[msvc64] needs-llvm-components: x86
+
+//@ add-core-stubs
+#![feature(no_core)]
+#![no_core]
+extern crate minicore;
+use minicore::*;
+
+// Fits in i64 but not i32.
+// C compiler demo: <https://godbolt.org/z/6v941G3x5>
+// FIXME: This seems to be wrong for linux32?
+#[repr(C)]
+#[warn(overflowing_literals)]
+enum OverflowingEnum {
+    A = 9223372036854775807, // i64::MAX
+    //[linux32,msvc32,msvc64]~^ WARN: literal out of range
+}
+
+#[cfg(not(linux64))]
+const _: () = if mem::size_of::<OverflowingEnum>() != 4 {
+    unsafe { hint::unreachable() }
+};
+#[cfg(linux64)]
+const _: () = if mem::size_of::<OverflowingEnum>() != 8 {
+    unsafe { hint::unreachable() }
+};
+
+fn main() {}

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ fn anon_const_type_of<'tcx>(icx: &ItemCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx`
`46`	`46`	`}) if anon_hir_id == hir_id => const_arg_anon_type_of(icx, arg_hir_id, span),`
`47`	`47`
`48`	`48`	`Node::Variant(Variant { disr_expr: Some(e), .. }) if e.hir_id == hir_id => {`
`49`		`- tcx.adt_def(tcx.hir_get_parent_item(hir_id)).repr().discr_type().to_ty(tcx)`
	`49`	`+ tcx.adt_def(tcx.hir_get_parent_item(hir_id)).repr().discr_type(&tcx).to_ty(tcx)`
`50`	`50`	`}`
`51`	`51`	`// Sort of affects the type system, but only for the purpose of diagnostics`
`52`	`52`	`// so no need for ConstArg.`
Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {`
`197`	`197`	`let (source, ty) = if let ty::Adt(adt_def, ..) = source_expr.ty.kind()`
`198`	`198`	`&& adt_def.is_enum()`
`199`	`199`	`{`
`200`		`- let discr_ty = adt_def.repr().discr_type().to_ty(this.tcx);`
	`200`	`+ let discr_ty = adt_def.repr().discr_type(&this.tcx).to_ty(this.tcx);`
`201`	`201`	`let temp = unpack!(block = this.as_temp(block, scope, source, Mutability::Not));`
`202`	`202`	`let discr = this.temp(discr_ty, source_expr.span);`
`203`	`203`	`this.cfg.push_assign(`