Revert "add NullOp::FieldOffset & use it to lower unaligned_field_offset"

BennoLossin · BennoLossin · commit 7e552c69c729 · 2025-09-09T13:45:51.000+02:00
This reverts commit 86a47ee.
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(..) | NullOp::FieldOffset, _) => {}
+            | Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => {}
         }
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -626,17 +626,6 @@ 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,7 +650,6 @@ 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};
+use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic, NullOp};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{Ty, TyCtxt};
-use rustc_middle::{bug, ty};
+use rustc_middle::{bug, err_inval, span_bug, ty};
 use rustc_span::{Symbol, sym};
 use tracing::trace;
 
@@ -638,6 +638,8 @@ 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),
         }
@@ -647,6 +649,25 @@ 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,12 +536,6 @@ 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,7 +1073,6 @@ 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,10 +751,9 @@ 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(..) | NullOp::FieldOffset,
-                _,
-            ) => tcx.types.usize,
+            Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {
+                tcx.types.usize
+            }
             Rvalue::NullaryOp(NullOp::ContractChecks, _)
             | Rvalue::NullaryOp(NullOp::UbChecks, _) => tcx.types.bool,
             Rvalue::Aggregate(ref ak, ref ops) => match **ak {
@@ -823,9 +822,7 @@ impl BorrowKind {
 impl<'tcx> NullOp<'tcx> {
     pub fn ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
         match self {
-            NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(_) | NullOp::FieldOffset => {
-                tcx.types.usize
-            }
+            NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(_) => 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,8 +1575,6 @@ 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,7 +420,6 @@ 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,16 +497,6 @@ 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,15 +629,6 @@ 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,18 +374,6 @@ 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,7 +456,6 @@ 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,15 +1384,6 @@ 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,10 +642,9 @@ impl Rvalue {
                     .discriminant_ty()
                     .ok_or_else(|| error!("Expected a `RigidTy` but found: {place_ty:?}"))
             }
-            Rvalue::NullaryOp(
-                NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..) | NullOp::FieldOffset,
-                _,
-            ) => Ok(Ty::usize_ty()),
+            Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {
+                Ok(Ty::usize_ty())
+            }
             Rvalue::NullaryOp(NullOp::ContractChecks, _)
             | Rvalue::NullaryOp(NullOp::UbChecks, _) => Ok(Ty::bool_ty()),
             Rvalue::Aggregate(ak, ops) => match *ak {
@@ -1056,8 +1055,6 @@ 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,7 +332,6 @@ 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(..) \| NullOp::FieldOffset, _) => {}`
	`1636`	`+ \| Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => {}`
`1637`	`1637`	`}`
`1638`	`1638`	`}`
`1639`	`1639`
Original file line number	Diff line number	Diff line change
`@@ -1073,7 +1073,6 @@ 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})"),`
`1077`	`1076`	`NullOp::UbChecks => write!(fmt, "UbChecks()"),`
`1078`	`1077`	`NullOp::ContractChecks => write!(fmt, "ContractChecks()"),`
`1079`	`1078`	`}`