Replace OffsetOf by an actual sum.

Author: cjgillot

compiler/rustc_borrowck/src/lib.rs

@@ -1563,7 +1563,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
  self.consume_operand(location, (operand2, span), state);
  }
 
- Rvalue::NullaryOp(_op, _ty) => {
+ Rvalue::NullaryOp(_op) => {
  // nullary ops take no dynamic input; no borrowck effect.
  }
 

compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs

@@ -314,7 +314,7 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
  self.consume_operand(location, operand2);
  }
 
- Rvalue::NullaryOp(_op, _ty) => {}
+ Rvalue::NullaryOp(_op) => {}
 
  Rvalue::Aggregate(_, operands) => {
  for operand in operands {

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1046,8 +1046,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
  }
  }
 
- &Rvalue::NullaryOp(NullOp::ContractChecks, _) => {}
- &Rvalue::NullaryOp(NullOp::UbChecks, _) => {}
+ &Rvalue::NullaryOp(NullOp::ContractChecks | NullOp::UbChecks) => {}
 
  Rvalue::ShallowInitBox(_operand, ty) => {
  let trait_ref =
@@ -1634,8 +1633,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
  | Rvalue::BinaryOp(..)
  | Rvalue::RawPtr(..)
  | Rvalue::ThreadLocalRef(..)
- | Rvalue::Discriminant(..)
- | Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => {}
+ | Rvalue::Discriminant(..) => {}
  }
  }
 

compiler/rustc_codegen_cranelift/src/base.rs

@@ -829,40 +829,15 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
  fx.bcx.ins().nop();
  }
  }
- Rvalue::NullaryOp(ref null_op, ty) => {
+ Rvalue::NullaryOp(ref null_op) => {
  assert!(lval.layout().ty.is_sized(fx.tcx, fx.typing_env()));
- let layout = fx.layout_of(fx.monomorphize(ty));
  let val = match null_op {
- NullOp::OffsetOf(fields) => fx
- .tcx
- .offset_of_subfield(
- ty::TypingEnv::fully_monomorphized(),
- layout,
- fields.iter(),
- )
- .bytes(),
- NullOp::UbChecks => {
- let val = fx.tcx.sess.ub_checks();
- let val = CValue::by_val(
- fx.bcx.ins().iconst(types::I8, i64::from(val)),
- fx.layout_of(fx.tcx.types.bool),
- );
- lval.write_cvalue(fx, val);
- return;
- }
- NullOp::ContractChecks => {
- let val = fx.tcx.sess.contract_checks();
- let val = CValue::by_val(
- fx.bcx.ins().iconst(types::I8, i64::from(val)),
- fx.layout_of(fx.tcx.types.bool),
- );
- lval.write_cvalue(fx, val);
- return;
- }
+ NullOp::UbChecks => fx.tcx.sess.ub_checks(),
+ NullOp::ContractChecks => fx.tcx.sess.contract_checks(),
  };
  let val = CValue::by_val(
- fx.bcx.ins().iconst(fx.pointer_type, i64::try_from(val).unwrap()),
- fx.layout_of(fx.tcx.types.usize),
+ fx.bcx.ins().iconst(types::I8, i64::from(val)),
+ fx.layout_of(fx.tcx.types.bool),
  );
  lval.write_cvalue(fx, val);
  }

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -607,17 +607,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  }
  }
 
- mir::Rvalue::NullaryOp(ref null_op, ty) => {
- let ty = self.monomorphize(ty);
- let layout = bx.cx().layout_of(ty);
+ mir::Rvalue::NullaryOp(ref null_op) => {
  let val = match null_op {
- mir::NullOp::OffsetOf(fields) => {
- let val = bx
- .tcx()
- .offset_of_subfield(bx.typing_env(), layout, fields.iter())
- .bytes();
- bx.cx().const_usize(val)
- }
  mir::NullOp::UbChecks => {
  let val = bx.tcx().sess.ub_checks();
  bx.cx().const_bool(val)

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -645,10 +645,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 
  Rvalue::Cast(_, _, _) => {}
 
- Rvalue::NullaryOp(
- NullOp::OffsetOf(_) | NullOp::UbChecks | NullOp::ContractChecks,
- _,
- ) => {}
+ Rvalue::NullaryOp(NullOp::UbChecks | NullOp::ContractChecks) => {}
  Rvalue::ShallowInitBox(_, _) => {}
 
  Rvalue::UnaryOp(op, operand) => {
@@ -856,7 +853,9 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  }
 
  // Intrinsics are language primitives, not regular calls, so treat them separately.
- if let Some(intrinsic) = tcx.intrinsic(callee) {
+ if let Some(intrinsic) = tcx.intrinsic(callee)
+ && intrinsic.name != sym::offset_of
+ {
  if !tcx.is_const_fn(callee) {
  // Non-const intrinsic.
  self.check_op(ops::IntrinsicNonConst { name: intrinsic.name });

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -6,7 +6,7 @@ mod simd;
 
 use std::assert_matches::assert_matches;
 
-use rustc_abi::{FieldIdx, HasDataLayout, Size};
+use rustc_abi::{FieldIdx, HasDataLayout, Size, VariantIdx};
 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};
@@ -174,6 +174,21 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  let val = layout.align.bytes();
  self.write_scalar(Scalar::from_target_usize(val, self), dest)?;
  }
+ sym::offset_of => {
+ let tp_ty = instance.args.type_at(0);
+
+ let u32_layout = self.layout_of(self.tcx.types.u32)?;
+ let variant = self.read_scalar(&args[0])?.to_bits(u32_layout.size)? as u32;
+ let field = self.read_scalar(&args[1])?.to_bits(u32_layout.size)? as usize;
+
+ let layout = self.layout_of(tp_ty)?;
+ let cx = ty::layout::LayoutCx::new(*self.tcx, self.typing_env);
+
+ let layout = layout.for_variant(&cx, VariantIdx::from_u32(variant));
+ let offset = layout.fields.offset(field).bytes();
+
+ self.write_scalar(Scalar::from_target_usize(offset, self), dest)?;
+ }
  sym::variant_count => {
  let tp_ty = instance.args.type_at(0);
  let ty = match tp_ty.kind() {

compiler/rustc_const_eval/src/interpret/operator.rs

@@ -4,7 +4,7 @@ use rustc_apfloat::{Float, FloatConvert};
 use rustc_middle::mir::NullOp;
 use rustc_middle::mir::interpret::{InterpResult, PointerArithmetic, Scalar};
 use rustc_middle::ty::layout::TyAndLayout;
-use rustc_middle::ty::{self, FloatTy, ScalarInt, Ty};
+use rustc_middle::ty::{self, FloatTy, ScalarInt};
 use rustc_middle::{bug, mir, span_bug};
 use rustc_span::sym;
 use tracing::trace;
@@ -506,22 +506,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  }
  }
 
- pub fn nullary_op(
- &self,
- null_op: NullOp<'tcx>,
- arg_ty: Ty<'tcx>,
- ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
+ pub fn nullary_op(&self, null_op: NullOp) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
  use rustc_middle::mir::NullOp::*;
-
- let layout = self.layout_of(arg_ty)?;
- let usize_layout = || self.layout_of(self.tcx.types.usize).unwrap();
-
  interp_ok(match null_op {
- OffsetOf(fields) => {
- let val =
- self.tcx.offset_of_subfield(self.typing_env, layout, fields.iter()).bytes();
- ImmTy::from_uint(val, usize_layout())
- }
  UbChecks => ImmTy::from_bool(M::ub_checks(self)?, *self.tcx),
  ContractChecks => ImmTy::from_bool(M::contract_checks(self)?, *self.tcx),
  })

compiler/rustc_const_eval/src/interpret/step.rs

@@ -203,9 +203,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  self.write_immediate(*result, &dest)?;
  }
 
- NullaryOp(null_op, ty) => {
- let ty = self.instantiate_from_current_frame_and_normalize_erasing_regions(ty)?;
- let val = self.nullary_op(null_op, ty)?;
+ NullaryOp(null_op) => {
+ let val = self.nullary_op(null_op)?;
  self.write_immediate(*val, &dest)?;
  }
 

compiler/rustc_hir/src/lang_items.rs

@@ -170,6 +170,7 @@ language_item_table! {
  Unsize, sym::unsize, unsize_trait, Target::Trait, GenericRequirement::Minimum(1);
  AlignOf, sym::mem_align_const, align_const, Target::AssocConst, GenericRequirement::Exact(0);
  SizeOf, sym::mem_size_const, size_const, Target::AssocConst, GenericRequirement::Exact(0);
+ OffsetOf, sym::offset_of, offset_of, Target::Fn, GenericRequirement::Exact(1);
  /// Trait injected by `#[derive(PartialEq)]`, (i.e. "Partial EQ").
  StructuralPeq, sym::structural_peq, structural_peq_trait, Target::Trait, GenericRequirement::None;
  Copy, sym::copy, copy_trait, Target::Trait, GenericRequirement::Exact(0);