From eb584a23bfba55512af0a223cf4133b806ede178 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 8 Jun 2024 11:26:56 +0200
Subject: [PATCH] offset_of: allow (unstably) taking the offset of slice tail
fields
---
compiler/rustc_codegen_cranelift/src/base.rs | 7 ++--
compiler/rustc_codegen_ssa/src/mir/rvalue.rs | 5 ++-
.../rustc_const_eval/src/interpret/step.rs | 5 ++-
compiler/rustc_feature/src/unstable.rs | 2 ++
compiler/rustc_hir_typeck/src/expr.rs | 35 +++++++++++++++----
.../rustc_hir_typeck/src/fn_ctxt/_impl.rs | 20 +++++++++++
compiler/rustc_middle/src/ty/layout.rs | 34 ++++++++++++++++++
.../src/dataflow_const_prop.rs | 10 +++---
compiler/rustc_mir_transform/src/gvn.rs | 10 +++---
.../src/known_panics_lint.rs | 7 ++--
compiler/rustc_span/src/symbol.rs | 1 +
compiler/rustc_target/src/abi/mod.rs | 23 ------------
.../feature-gate-offset-of-slice.rs | 26 ++++++++++++++
.../feature-gate-offset-of-slice.stderr | 35 +++++++++++++++++++
tests/ui/offset-of/offset-of-dst-field.rs | 4 +++
tests/ui/offset-of/offset-of-dst-field.stderr | 11 +++++-
tests/ui/offset-of/offset-of-slice.rs | 26 ++++++++++++++
17 files changed, 215 insertions(+), 46 deletions(-)
create mode 100644 tests/ui/feature-gates/feature-gate-offset-of-slice.rs
create mode 100644 tests/ui/feature-gates/feature-gate-offset-of-slice.stderr
create mode 100644 tests/ui/offset-of/offset-of-slice.rs
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index 963e5de91ce..6d26ca0b899 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -832,9 +832,10 @@ fn codegen_stmt<'tcx>(
let val = match null_op {
NullOp::SizeOf => layout.size.bytes(),
NullOp::AlignOf => layout.align.abi.bytes(),
- NullOp::OffsetOf(fields) => {
- layout.offset_of_subfield(fx, fields.iter()).bytes()
- }
+ NullOp::OffsetOf(fields) => fx
+ .tcx
+ .offset_of_subfield(ParamEnv::reveal_all(), layout, fields.iter())
+ .bytes(),
NullOp::UbChecks => {
let val = fx.tcx.sess.ub_checks();
let val = CValue::by_val(
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index c23867be3a1..ad6b3f1159d 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -680,7 +680,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
bx.cx().const_usize(val)
}
mir::NullOp::OffsetOf(fields) => {
- let val = layout.offset_of_subfield(bx.cx(), fields.iter()).bytes();
+ let val = bx
+ .tcx()
+ .offset_of_subfield(bx.param_env(), layout, fields.iter())
+ .bytes();
bx.cx().const_usize(val)
}
mir::NullOp::UbChecks => {
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index d0bb821862a..1baf62baa81 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -253,7 +253,10 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
Scalar::from_target_usize(val, self)
}
mir::NullOp::OffsetOf(fields) => {
- let val = layout.offset_of_subfield(self, fields.iter()).bytes();
+ let val = self
+ .tcx
+ .offset_of_subfield(self.param_env, layout, fields.iter())
+ .bytes();
Scalar::from_target_usize(val, self)
}
mir::NullOp::UbChecks => Scalar::from_bool(self.tcx.sess.ub_checks()),
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index d67422849d8..2410019868a 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -559,6 +559,8 @@ declare_features! (
(unstable, offset_of_enum, "1.75.0", Some(120141)),
/// Allows using multiple nested field accesses in offset_of!
(unstable, offset_of_nested, "1.77.0", Some(120140)),
+ /// Allows using fields with slice type in offset_of!
+ (unstable, offset_of_slice, "CURRENT_RUSTC_VERSION", Some(126151)),
/// Allows using `#[optimize(X)]`.
(unstable, optimize_attribute, "1.34.0", Some(54882)),
/// Allows postfix match `expr.match { ... }`
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index d5d360ca047..5b27ebe3416 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -3363,7 +3363,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let field_ty = self.field_ty(expr.span, field, args);
- // FIXME: DSTs with static alignment should be allowed
+ // Enums are anyway always sized. But just to safeguard against future
+ // language extensions, let's double-check.
self.require_type_is_sized(field_ty, expr.span, ObligationCauseCode::Misc);
if field.vis.is_accessible_from(sub_def_scope, self.tcx) {
@@ -3391,8 +3392,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
{
let field_ty = self.field_ty(expr.span, field, args);
- // FIXME: DSTs with static alignment should be allowed
- self.require_type_is_sized(field_ty, expr.span, ObligationCauseCode::Misc);
+ if self.tcx.features().offset_of_slice {
+ self.require_type_has_static_alignment(
+ field_ty,
+ expr.span,
+ ObligationCauseCode::Misc,
+ );
+ } else {
+ self.require_type_is_sized(
+ field_ty,
+ expr.span,
+ ObligationCauseCode::Misc,
+ );
+ }
if field.vis.is_accessible_from(def_scope, self.tcx) {
self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span, None);
@@ -3412,10 +3424,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let Ok(index) = field.as_str().parse::<usize>()
&& field.name == sym::integer(index)
{
- for ty in tys.iter().take(index + 1) {
- self.require_type_is_sized(ty, expr.span, ObligationCauseCode::Misc);
- }
if let Some(&field_ty) = tys.get(index) {
+ if self.tcx.features().offset_of_slice {
+ self.require_type_has_static_alignment(
+ field_ty,
+ expr.span,
+ ObligationCauseCode::Misc,
+ );
+ } else {
+ self.require_type_is_sized(
+ field_ty,
+ expr.span,
+ ObligationCauseCode::Misc,
+ );
+ }
+
field_indices.push((FIRST_VARIANT, index.into()));
current_container = field_ty;
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 85c6d4dc12c..e354e1ec59c 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -386,6 +386,26 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
}
+ pub fn require_type_has_static_alignment(
+ &self,
+ ty: Ty<'tcx>,
+ span: Span,
+ code: traits::ObligationCauseCode<'tcx>,
+ ) {
+ if !ty.references_error() {
+ let tail =
+ self.tcx.struct_tail_with_normalize(ty, |ty| self.normalize(span, ty), || {});
+ // Sized types have static alignment, and so do slices.
+ if tail.is_trivially_sized(self.tcx) || matches!(tail.kind(), ty::Slice(..)) {
+ // Nothing else is required here.
+ } else {
+ // We can't be sure, let's required full `Sized`.
+ let lang_item = self.tcx.require_lang_item(LangItem::Sized, None);
+ self.require_type_meets(ty, span, code, lang_item);
+ }
+ }
+ }
+
pub fn register_bound(
&self,
ty: Ty<'tcx>,
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 142872009bf..56945bf6be4 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -1351,3 +1351,37 @@ pub trait FnAbiOf<'tcx>: FnAbiOfHelpers<'tcx> {
}
impl<'tcx, C: FnAbiOfHelpers<'tcx>> FnAbiOf<'tcx> for C {}
+
+impl<'tcx> TyCtxt<'tcx> {
+ pub fn offset_of_subfield<I>(
+ self,
+ param_env: ty::ParamEnv<'tcx>,
+ mut layout: TyAndLayout<'tcx>,
+ indices: I,
+ ) -> Size
+ where
+ I: Iterator<Item = (VariantIdx, FieldIdx)>,
+ {
+ let cx = LayoutCx { tcx: self, param_env };
+ let mut offset = Size::ZERO;
+
+ for (variant, field) in indices {
+ layout = layout.for_variant(&cx, variant);
+ let index = field.index();
+ offset += layout.fields.offset(index);
+ layout = layout.field(&cx, index);
+ if !layout.is_sized() {
+ // If it is not sized, then the tail must still have at least a known static alignment.
+ let tail = self.struct_tail_erasing_lifetimes(layout.ty, param_env);
+ if !matches!(tail.kind(), ty::Slice(..)) {
+ bug!(
+ "offset of not-statically-aligned field (type {:?}) cannot be computed statically",
+ layout.ty
+ );
+ }
+ }
+ }
+
+ offset
+ }
+}
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index a8caead46f2..eba5d13d33f 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -10,7 +10,7 @@ use rustc_middle::bug;
use rustc_middle::mir::interpret::{InterpResult, Scalar};
use rustc_middle::mir::visit::{MutVisitor, PlaceContext, Visitor};
use rustc_middle::mir::*;
-use rustc_middle::ty::layout::LayoutOf;
+use rustc_middle::ty::layout::{HasParamEnv, LayoutOf};
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_mir_dataflow::value_analysis::{
Map, PlaceIndex, State, TrackElem, ValueAnalysis, ValueAnalysisWrapper, ValueOrPlace,
@@ -285,9 +285,11 @@ impl<'tcx> ValueAnalysis<'tcx> for ConstAnalysis<'_, 'tcx> {
let val = match null_op {
NullOp::SizeOf if layout.is_sized() => layout.size.bytes(),
NullOp::AlignOf if layout.is_sized() => layout.align.abi.bytes(),
- NullOp::OffsetOf(fields) => {
- layout.offset_of_subfield(&self.ecx, fields.iter()).bytes()
- }
+ NullOp::OffsetOf(fields) => self
+ .ecx
+ .tcx
+ .offset_of_subfield(self.ecx.param_env(), layout, fields.iter())
+ .bytes(),
_ => return ValueOrPlace::Value(FlatSet::Top),
};
FlatSet::Elem(Scalar::from_target_usize(val, &self.tcx))
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index acde16fcb75..ebfb372329e 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -95,7 +95,7 @@ use rustc_middle::bug;
use rustc_middle::mir::interpret::GlobalAlloc;
use rustc_middle::mir::visit::*;
use rustc_middle::mir::*;
-use rustc_middle::ty::layout::LayoutOf;
+use rustc_middle::ty::layout::{HasParamEnv, LayoutOf};
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_span::def_id::DefId;
use rustc_span::DUMMY_SP;
@@ -484,9 +484,11 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
let val = match null_op {
NullOp::SizeOf => layout.size.bytes(),
NullOp::AlignOf => layout.align.abi.bytes(),
- NullOp::OffsetOf(fields) => {
- layout.offset_of_subfield(&self.ecx, fields.iter()).bytes()
- }
+ NullOp::OffsetOf(fields) => self
+ .ecx
+ .tcx
+ .offset_of_subfield(self.ecx.param_env(), layout, fields.iter())
+ .bytes(),
NullOp::UbChecks => return None,
};
let usize_layout = self.ecx.layout_of(self.tcx.types.usize).unwrap();
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
index 8b46658b322..47bbddbc31d 100644
--- a/compiler/rustc_mir_transform/src/known_panics_lint.rs
+++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -625,9 +625,10 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
let val = match null_op {
NullOp::SizeOf => op_layout.size.bytes(),
NullOp::AlignOf => op_layout.align.abi.bytes(),
- NullOp::OffsetOf(fields) => {
- op_layout.offset_of_subfield(self, fields.iter()).bytes()
- }
+ NullOp::OffsetOf(fields) => self
+ .tcx
+ .offset_of_subfield(self.param_env, op_layout, fields.iter())
+ .bytes(),
NullOp::UbChecks => return None,
};
ImmTy::from_scalar(Scalar::from_target_usize(val, self), layout).into()
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 93594264167..e245dfb9f5d 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1304,6 +1304,7 @@ symbols! {
offset_of,
offset_of_enum,
offset_of_nested,
+ offset_of_slice,
ok_or_else,
omit_gdb_pretty_printer_section,
on,
diff --git a/compiler/rustc_target/src/abi/mod.rs b/compiler/rustc_target/src/abi/mod.rs
index 666efd9deca..737e9a8eab0 100644
--- a/compiler/rustc_target/src/abi/mod.rs
+++ b/compiler/rustc_target/src/abi/mod.rs
@@ -256,29 +256,6 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
Ty::is_transparent(self)
}
- pub fn offset_of_subfield<C, I>(self, cx: &C, indices: I) -> Size
- where
- Ty: TyAbiInterface<'a, C>,
- I: Iterator<Item = (VariantIdx, FieldIdx)>,
- {
- let mut layout = self;
- let mut offset = Size::ZERO;
-
- for (variant, field) in indices {
- layout = layout.for_variant(cx, variant);
- let index = field.index();
- offset += layout.fields.offset(index);
- layout = layout.field(cx, index);
- assert!(
- layout.is_sized(),
- "offset of unsized field (type {:?}) cannot be computed statically",
- layout.ty
- );
- }
-
- offset
- }
-
/// Finds the one field that is not a 1-ZST.
/// Returns `None` if there are multiple non-1-ZST fields or only 1-ZST-fields.
pub fn non_1zst_field<C>(&self, cx: &C) -> Option<(usize, Self)>
diff --git a/tests/ui/feature-gates/feature-gate-offset-of-slice.rs b/tests/ui/feature-gates/feature-gate-offset-of-slice.rs
new file mode 100644
index 00000000000..23e8668bc68
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-offset-of-slice.rs
@@ -0,0 +1,26 @@
+use std::mem::offset_of;
+
+struct S {
+ a: u8,
+ b: (u8, u8),
+ c: [i32],
+}
+
+struct T {
+ x: i32,
+ y: S,
+}
+
+type Tup = (i32, [i32]);
+
+fn main() {
+ offset_of!(S, c); //~ ERROR size for values of type `[i32]` cannot be known at compilation time
+}
+
+fn other() {
+ offset_of!(T, y); //~ ERROR size for values of type `[i32]` cannot be known at compilation time
+}
+
+fn tuple() {
+ offset_of!(Tup, 1); //~ ERROR size for values of type `[i32]` cannot be known at compilation time
+}
diff --git a/tests/ui/feature-gates/feature-gate-offset-of-slice.stderr b/tests/ui/feature-gates/feature-gate-offset-of-slice.stderr
new file mode 100644
index 00000000000..5cf34a897f4
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-offset-of-slice.stderr
@@ -0,0 +1,35 @@
+error[E0277]: the size for values of type `[i32]` cannot be known at compilation time
+ --> $DIR/feature-gate-offset-of-slice.rs:17:5
+ |
+LL | offset_of!(S, c);
+ | ^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+ |
+ = help: the trait `Sized` is not implemented for `[i32]`
+ = note: this error originates in the macro `offset_of` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the size for values of type `[i32]` cannot be known at compilation time
+ --> $DIR/feature-gate-offset-of-slice.rs:21:5
+ |
+LL | offset_of!(T, y);
+ | ^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+ |
+ = help: within `S`, the trait `Sized` is not implemented for `[i32]`, which is required by `S: Sized`
+note: required because it appears within the type `S`
+ --> $DIR/feature-gate-offset-of-slice.rs:3:8
+ |
+LL | struct S {
+ | ^
+ = note: this error originates in the macro `offset_of` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the size for values of type `[i32]` cannot be known at compilation time
+ --> $DIR/feature-gate-offset-of-slice.rs:25:5
+ |
+LL | offset_of!(Tup, 1);
+ | ^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+ |
+ = help: the trait `Sized` is not implemented for `[i32]`
+ = note: this error originates in the macro `offset_of` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/offset-of/offset-of-dst-field.rs b/tests/ui/offset-of/offset-of-dst-field.rs
index 016ebfadd14..5ae15f32357 100644
--- a/tests/ui/offset-of/offset-of-dst-field.rs
+++ b/tests/ui/offset-of/offset-of-dst-field.rs
@@ -49,3 +49,7 @@ fn delta() {
fn generic_with_maybe_sized<T: ?Sized>() -> usize {
offset_of!(Delta<T>, z) //~ ERROR the size for values of type
}
+
+fn illformed_tuple() {
+ offset_of!(([u8], u8), 1); //~ ERROR the size for values of type
+}
diff --git a/tests/ui/offset-of/offset-of-dst-field.stderr b/tests/ui/offset-of/offset-of-dst-field.stderr
index adfd16c6f2b..bcfe796897e 100644
--- a/tests/ui/offset-of/offset-of-dst-field.stderr
+++ b/tests/ui/offset-of/offset-of-dst-field.stderr
@@ -81,6 +81,15 @@ LL - fn generic_with_maybe_sized<T: ?Sized>() -> usize {
LL + fn generic_with_maybe_sized<T>() -> usize {
|
-error: aborting due to 8 previous errors
+error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
+ --> $DIR/offset-of-dst-field.rs:54:16
+ |
+LL | offset_of!(([u8], u8), 1);
+ | ^^^^^^^^^^ doesn't have a size known at compile-time
+ |
+ = help: the trait `Sized` is not implemented for `[u8]`
+ = note: only the last element of a tuple may have a dynamically sized type
+
+error: aborting due to 9 previous errors
For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/offset-of/offset-of-slice.rs b/tests/ui/offset-of/offset-of-slice.rs
new file mode 100644
index 00000000000..a0fe3198f68
--- /dev/null
+++ b/tests/ui/offset-of/offset-of-slice.rs
@@ -0,0 +1,26 @@
+//@run-pass
+#![feature(offset_of_slice, offset_of_nested)]
+
+use std::mem::offset_of;
+
+#[repr(C)]
+struct S {
+ a: u8,
+ b: (u8, u8),
+ c: [i32],
+}
+
+#[repr(C)]
+struct T {
+ x: i8,
+ y: S,
+}
+
+type Tup = (i16, [i32]);
+
+fn main() {
+ assert_eq!(offset_of!(S, c), 4);
+ assert_eq!(offset_of!(T, y), 4);
+ assert_eq!(offset_of!(T, y.c), 8);
+ assert_eq!(offset_of!(Tup, 1), 4);
+}