add unaligned_field_offset intrinsic

Author: BennoLossin

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, ty};
 use rustc_span::{Symbol, sym};
 use tracing::trace;
 
@@ -637,6 +637,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),
         }
@@ -646,6 +648,21 @@ 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);
+        match instance.args.type_at(0).kind() {
+            &ty::Field(container, field_path) => {
+                let offset = self.nullary_op(NullOp::OffsetOf(field_path), container)?;
+                self.write_immediate(*offset, dest)
+            }
+            _ => Err(err_inval!(TooGeneric)).into(),
+        }
+    }
+
     pub(super) fn eval_nondiverging_intrinsic(
         &mut self,
         intrinsic: &NonDivergingIntrinsic<'tcx>,

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -140,7 +140,8 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::prefetch_write_data
         | sym::prefetch_read_instruction
         | sym::prefetch_write_instruction
-        | sym::const_eval_select => hir::Safety::Safe,
+        | sym::const_eval_select
+        | sym::unaligned_field_offset => hir::Safety::Safe,
         _ => hir::Safety::Unsafe,
     };
 
@@ -673,6 +674,8 @@ pub(crate) fn check_intrinsic_type(
         | sym::atomic_xor => (2, 1, vec![Ty::new_mut_ptr(tcx, param(0)), param(1)], param(0)),
         sym::atomic_fence | sym::atomic_singlethreadfence => (0, 1, Vec::new(), tcx.types.unit),
 
+        sym::unaligned_field_offset => (1, 0, Vec::new(), tcx.types.usize),
+
         other => {
             tcx.dcx().emit_err(UnrecognizedIntrinsicFunction { span, name: other });
             return;

compiler/rustc_middle/src/ty/context.rs

@@ -3431,6 +3431,9 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn intrinsic(self, def_id: impl IntoQueryParam<DefId> + Copy) -> Option<ty::IntrinsicDef> {
         match self.def_kind(def_id) {
             DefKind::Fn | DefKind::AssocFn => {}
+            DefKind::AssocConst
+                if self.is_lang_item(def_id.into_query_param(), LangItem::UnalignedFieldOFFSET) => {
+            }
             _ => return None,
         }
         self.intrinsic_raw(def_id)

compiler/rustc_span/src/symbol.rs

@@ -2282,6 +2282,7 @@ symbols! {
         u128_legacy_fn_min_value,
         u128_legacy_mod,
         ub_checks,
+        unaligned_field_offset,
         unaligned_volatile_load,
         unaligned_volatile_store,
         unboxed_closures,

library/core/src/field.rs

@@ -19,7 +19,7 @@ pub unsafe trait UnalignedField: Sized {
 
     /// The offset of the field in bytes.
     #[lang = "UnalignedFieldOFFSET"]
-    const OFFSET: usize;
+    const OFFSET: usize = crate::intrinsics::unaligned_field_offset::<Self>();
 }
 
 /// Type representing an aligned field of a `struct`.

library/core/src/intrinsics/mod.rs

@@ -3314,3 +3314,11 @@ pub unsafe fn va_arg<T: VaArgSafe>(ap: &mut VaListImpl<'_>) -> T;
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub unsafe fn va_end(ap: &mut VaListImpl<'_>);
+
+/// `offset_of!` for `UnalignedField` trait.
+#[rustc_intrinsic_const_stable_indirect]
+#[rustc_intrinsic]
+#[lang = "unaligned_field_offset"]
+#[unstable(feature = "field_projections", issue = "145383")]
+#[rustc_const_unstable(feature = "field_projections", issue = "145383")]
+pub const fn unaligned_field_offset<F: crate::field::UnalignedField>() -> usize;

library/core/src/lib.rs

@@ -154,6 +154,7 @@
 #![feature(extern_types)]
 #![feature(f16)]
 #![feature(f128)]
+#![feature(field_projections)]
 #![feature(freeze_impls)]
 #![feature(fundamental)]
 #![feature(funnel_shifts)]