add NullOp::FieldOffset & use it to lower unaligned_field_offset

BennoLossin · BennoLossin · commit 86a47ee5a958 · 2025-09-09T12:46:03.000+02:00
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1633,7 +1633,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             | Rvalue::ThreadLocalRef(..)
             | Rvalue::Len(..)
             | Rvalue::Discriminant(..)
-            | Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => {}
+            | Rvalue::NullaryOp(NullOp::OffsetOf(..) | NullOp::FieldOffset, _) => {}
         }
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -626,6 +626,17 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             .bytes();
                         bx.cx().const_usize(val)
                     }
+                    mir::NullOp::FieldOffset => {
+                        let &ty::Field(container, field_path) = ty.kind() else {
+                            bug!("expected `ty::Field`, but found {ty:?}")
+                        };
+                        let layout = bx.cx().layout_of(container);
+                        let val = bx
+                            .tcx()
+                            .offset_of_subfield(bx.typing_env(), layout, field_path.iter())
+                            .bytes();
+                        bx.cx().const_usize(val)
+                    }
                     mir::NullOp::UbChecks => {
                         let val = bx.tcx().sess.ub_checks();
                         bx.cx().const_bool(val)
diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -650,6 +650,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                 NullOp::SizeOf
                 | NullOp::AlignOf
                 | NullOp::OffsetOf(_)
+                | NullOp::FieldOffset
                 | NullOp::UbChecks
                 | NullOp::ContractChecks,
                 _,
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -7,10 +7,10 @@ use std::assert_matches::assert_matches;
 use rustc_abi::{FieldIdx, HasDataLayout, Size};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, read_target_uint, write_target_uint};
-use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic, NullOp};
+use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{Ty, TyCtxt};
-use rustc_middle::{bug, err_inval, span_bug, ty};
+use rustc_middle::{bug, ty};
 use rustc_span::{Symbol, sym};
 use tracing::trace;
 
@@ -638,8 +638,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 rustc_apfloat::Round::NearestTiesToEven,
             )?,
 
-            sym::unaligned_field_offset => self.unaligned_field_offset(instance, dest)?,
-
             // Unsupported intrinsic: skip the return_to_block below.
             _ => return interp_ok(false),
         }
@@ -649,25 +647,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(true)
     }
 
-    fn unaligned_field_offset(
-        &mut self,
-        instance: ty::Instance<'tcx>,
-        dest: &PlaceTy<'tcx, M::Provenance>,
-    ) -> InterpResult<'tcx, ()> {
-        assert_eq!(instance.args.len(), 1);
-        let ty = instance.args.type_at(0);
-        match ty.kind() {
-            &ty::Field(container, field_path) => {
-                let offset = self.nullary_op(NullOp::OffsetOf(field_path), container)?;
-                self.write_immediate(*offset, dest)
-            }
-            ty::Alias(..) | ty::Param(..) | ty::Placeholder(..) | ty::Infer(..) => {
-                Err(err_inval!(TooGeneric)).into()
-            }
-            _ => span_bug!(self.cur_span(), "expected field representing type, found {ty}"),
-        }
-    }
-
     pub(super) fn eval_nondiverging_intrinsic(
         &mut self,
         intrinsic: &NonDivergingIntrinsic<'tcx>,
diff --git a/compiler/rustc_const_eval/src/interpret/operator.rs b/compiler/rustc_const_eval/src/interpret/operator.rs
@@ -536,6 +536,12 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                     self.tcx.offset_of_subfield(self.typing_env, layout, fields.iter()).bytes();
                 ImmTy::from_uint(val, usize_layout())
             }
+            FieldOffset => {
+                let &ty::Field(container, field_path) = arg_ty.kind() else {
+                    span_bug!(self.cur_span(), "expected `ty::Field`, found {arg_ty:?}")
+                };
+                self.nullary_op(OffsetOf(field_path), container)?
+            }
             UbChecks => ImmTy::from_bool(M::ub_checks(self)?, *self.tcx),
             ContractChecks => ImmTy::from_bool(M::contract_checks(self)?, *self.tcx),
         })
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1073,6 +1073,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                     NullOp::SizeOf => write!(fmt, "SizeOf({t})"),
                     NullOp::AlignOf => write!(fmt, "AlignOf({t})"),
                     NullOp::OffsetOf(fields) => write!(fmt, "OffsetOf({t}, {fields:?})"),
+                    NullOp::FieldOffset => write!(fmt, "FieldOffset({t})"),
                     NullOp::UbChecks => write!(fmt, "UbChecks()"),
                     NullOp::ContractChecks => write!(fmt, "ContractChecks()"),
                 }
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
@@ -751,9 +751,10 @@ impl<'tcx> Rvalue<'tcx> {
                 op.ty(tcx, arg_ty)
             }
             Rvalue::Discriminant(ref place) => place.ty(local_decls, tcx).ty.discriminant_ty(tcx),
-            Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {
-                tcx.types.usize
-            }
+            Rvalue::NullaryOp(
+                NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..) | NullOp::FieldOffset,
+                _,
+            ) => tcx.types.usize,
             Rvalue::NullaryOp(NullOp::ContractChecks, _)
             | Rvalue::NullaryOp(NullOp::UbChecks, _) => tcx.types.bool,
             Rvalue::Aggregate(ref ak, ref ops) => match **ak {
@@ -822,7 +823,9 @@ impl BorrowKind {
 impl<'tcx> NullOp<'tcx> {
     pub fn ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
         match self {
-            NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(_) => tcx.types.usize,
+            NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(_) | NullOp::FieldOffset => {
+                tcx.types.usize
+            }
             NullOp::UbChecks | NullOp::ContractChecks => tcx.types.bool,
         }
     }
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
@@ -1575,6 +1575,8 @@ pub enum NullOp<'tcx> {
     AlignOf,
     /// Returns the offset of a field
     OffsetOf(FieldPath<'tcx>),
+    /// Returns the offset of the field represented by the type
+    FieldOffset,
     /// Returns whether we should perform some UB-checking at runtime.
     /// See the `ub_checks` intrinsic docs for details.
     UbChecks,
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -420,6 +420,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                 NullOp::SizeOf
                 | NullOp::AlignOf
                 | NullOp::OffsetOf(..)
+                | NullOp::FieldOffset
                 | NullOp::UbChecks
                 | NullOp::ContractChecks,
                 _,
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
@@ -497,6 +497,16 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                         .tcx
                         .offset_of_subfield(self.typing_env(), arg_layout, fields.iter())
                         .bytes(),
+                    NullOp::FieldOffset => {
+                        let &ty::Field(container, field_path) = arg_ty.kind() else {
+                            bug!("expected `ty::Field`, found {arg_ty:?}")
+                        };
+                        let layout = self.ecx.layout_of(container).ok()?;
+                        self.ecx
+                            .tcx
+                            .offset_of_subfield(self.typing_env(), layout, field_path.iter())
+                            .bytes()
+                    }
                     NullOp::UbChecks => return None,
                     NullOp::ContractChecks => return None,
                 };
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -629,6 +629,15 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                         .tcx
                         .offset_of_subfield(self.typing_env, op_layout, fields.iter())
                         .bytes(),
+                    NullOp::FieldOffset => {
+                        let &ty::Field(container, field_path) = ty.kind() else {
+                            bug!("expected `ty::Field`, found {ty:?}")
+                        };
+                        let layout = self.ecx.layout_of(container).ok()?;
+                        self.tcx
+                            .offset_of_subfield(self.typing_env, layout, field_path.iter())
+                            .bytes()
+                    }
                     NullOp::UbChecks => return None,
                     NullOp::ContractChecks => return None,
                 };
diff --git a/compiler/rustc_mir_transform/src/lower_intrinsics.rs b/compiler/rustc_mir_transform/src/lower_intrinsics.rs
@@ -374,6 +374,18 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                         ));
                         terminator.kind = TerminatorKind::Goto { target };
                     }
+                    sym::unaligned_field_offset => {
+                        let target = target.unwrap();
+                        let ty = generic_args.type_at(0);
+                        block.statements.push(Statement::new(
+                            terminator.source_info,
+                            StatementKind::Assign(Box::new((
+                                *destination,
+                                Rvalue::NullaryOp(NullOp::FieldOffset, ty),
+                            ))),
+                        ));
+                        terminator.kind = TerminatorKind::Goto { target };
+                    }
                     _ => {}
                 }
             }
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -456,6 +456,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                 NullOp::SizeOf => {}
                 NullOp::AlignOf => {}
                 NullOp::OffsetOf(_) => {}
+                NullOp::FieldOffset => {}
                 NullOp::UbChecks => {}
                 NullOp::ContractChecks => {}
             },
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
@@ -1384,6 +1384,15 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                     }
                 }
             }
+            Rvalue::NullaryOp(NullOp::FieldOffset, ty) => {
+                let &ty::Field(container, field_path) = ty.kind() else {
+                    bug!("expected `ty::Field`, found {ty:?}")
+                };
+                self.visit_rvalue(
+                    &Rvalue::NullaryOp(NullOp::OffsetOf(field_path), container),
+                    location,
+                )
+            }
             Rvalue::Repeat(_, _)
             | Rvalue::ThreadLocalRef(_)
             | Rvalue::RawPtr(_, _)
diff --git a/compiler/rustc_public/src/mir/body.rs b/compiler/rustc_public/src/mir/body.rs
@@ -642,9 +642,10 @@ impl Rvalue {
                     .discriminant_ty()
                     .ok_or_else(|| error!("Expected a `RigidTy` but found: {place_ty:?}"))
             }
-            Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {
-                Ok(Ty::usize_ty())
-            }
+            Rvalue::NullaryOp(
+                NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..) | NullOp::FieldOffset,
+                _,
+            ) => Ok(Ty::usize_ty()),
             Rvalue::NullaryOp(NullOp::ContractChecks, _)
             | Rvalue::NullaryOp(NullOp::UbChecks, _) => Ok(Ty::bool_ty()),
             Rvalue::Aggregate(ak, ops) => match *ak {
@@ -1055,6 +1056,8 @@ pub enum NullOp {
     AlignOf,
     /// Returns the offset of a field.
     OffsetOf(Vec<(VariantIdx, FieldIdx)>),
+    /// Returns the offset of the field represented by the type.
+    FieldOffset,
     /// cfg!(ub_checks), but at codegen time
     UbChecks,
     /// cfg!(contract_checks), but at codegen time
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -332,6 +332,7 @@ impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> {
             OffsetOf(indices) => crate::mir::NullOp::OffsetOf(
                 indices.iter().map(|idx| idx.stable(tables, cx)).collect(),
             ),
+            FieldOffset => crate::mir::NullOp::FieldOffset,
             UbChecks => crate::mir::NullOp::UbChecks,
             ContractChecks => crate::mir::NullOp::ContractChecks,
         }

Original file line number	Diff line number	Diff line change
`@@ -1633,7 +1633,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {`
`1633`	`1633`	`\| Rvalue::ThreadLocalRef(..)`
`1634`	`1634`	`\| Rvalue::Len(..)`
`1635`	`1635`	`\| Rvalue::Discriminant(..)`
`1636`		`- \| Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => {}`
	`1636`	`+ \| Rvalue::NullaryOp(NullOp::OffsetOf(..) \| NullOp::FieldOffset, _) => {}`
`1637`	`1637`	`}`
`1638`	`1638`	`}`
`1639`	`1639`
Original file line number	Diff line number	Diff line change
`@@ -1073,6 +1073,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {`
`1073`	`1073`	`NullOp::SizeOf => write!(fmt, "SizeOf({t})"),`
`1074`	`1074`	`NullOp::AlignOf => write!(fmt, "AlignOf({t})"),`
`1075`	`1075`	`NullOp::OffsetOf(fields) => write!(fmt, "OffsetOf({t}, {fields:?})"),`
	`1076`	`+ NullOp::FieldOffset => write!(fmt, "FieldOffset({t})"),`
`1076`	`1077`	`NullOp::UbChecks => write!(fmt, "UbChecks()"),`
`1077`	`1078`	`NullOp::ContractChecks => write!(fmt, "ContractChecks()"),`
`1078`	`1079`	`}`