reject projecting to fields whose offset we cannot compute

Author: RalfJung

compiler/rustc_codegen_ssa/src/mir/place.rs

@@ -99,6 +99,8 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
 let offset = self.layout.fields.offset(ix);
 let effective_field_align = self.align.restrict_for_offset(offset);
 
+// `simple` is called when we don't need to adjust the offset to
+// the dynamic alignment of the field.
 letmut simple = || {
 let llval = matchself.layout.abi{
  _ if offset.bytes() == 0 => {
@@ -141,28 +143,21 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
 };
 
 // Simple cases, which don't need DST adjustment:
-// * no metadata available - just log the case
-// * known alignment - sized types, `[T]`, `str` or a foreign type
+// * known alignment - sized types, `[T]`, `str`
+// * offset 0 -- rounding up to alignment cannot change the offset
 // Note that looking at `field.align` is incorrect since that is not necessarily equal
 // to the dynamic alignment of the type.
 match field.ty.kind(){
- _ ifself.llextra.is_none() => {
-debug!(
-"unsized field `{}`, of `{:?}` has no metadata for adjustment",
- ix,self.llval
-);
-returnsimple();
-}
  _ if field.is_sized() => returnsimple(),
- ty::Slice(..) | ty::Str | ty::Foreign(..) => returnsimple(),
+ ty::Slice(..) | ty::Str => returnsimple(),
+ _ if offset.bytes() == 0 => returnsimple(),
  _ => {}
 }
 
 // We need to get the pointer manually now.
 // We do this by casting to a `*i8`, then offsetting it by the appropriate amount.
 // We do this instead of, say, simply adjusting the pointer from the result of a GEP
-// because the field may have an arbitrary alignment in the LLVM representation
-// anyway.
+// because the field may have an arbitrary alignment in the LLVM representation.
 //
 // To demonstrate:
 //

compiler/rustc_const_eval/src/interpret/projection.rs

@@ -174,12 +174,15 @@ where
 };
 (base_meta, offset.align_to(align))
 }
-None => {
-// For unsized types with an extern type tail we perform no adjustments.
-// NOTE: keep this in sync with `PlaceRef::project_field` in the codegen backend.
-assert!(matches!(base_meta,MemPlaceMeta::None));
+Noneif offset == Size::ZERO => {
+// If the offset is 0, then rounding it up to alignment wouldn't change anything,
+// so we can do this even for types where we cannot determine the alignment.
 (base_meta, offset)
 }
+None => {
+// We don't know the alignment of this field, so we cannot adjust.
+throw_unsup_format!("`extern type` does not have a known offset")
+}
 }
 }else{
 // base_meta could be present; we might be accessing a sized field of an unsized

tests/ui/consts/const-eval/issue-91827-extern-types-field-offset.rs

@@ -0,0 +1,32 @@
+// Test that we can handle unsized types with an extern type tail part.
+// Regression test for issue #91827.
+
+#![feature(extern_types)]
+
+use std::ptr::addr_of;
+
+extern"C"{
+typeOpaque;
+}
+
+structNewtype(Opaque);
+
+structS{
+i:i32,
+a:Opaque,
+}
+
+constNEWTYPE:() = unsafe{
+// Projecting to the newtype works, because it is always at offset 0.
+let x:&Newtype = unsafe{&*(1usizeas*constNewtype)};
+let field = &x.0;
+};
+
+constOFFSET:() = unsafe{
+// This needs to compute the field offset, but we don't know the type's alignment, so this fail.
+let x:&S = unsafe{&*(1usizeas*constS)};
+let field = &x.a;//~ERROR: evaluation of constant value failed
+//~| does not have a known offset
+};
+
+fnmain(){}

tests/ui/consts/const-eval/issue-91827-extern-types-field-offset.stderr

@@ -0,0 +1,9 @@
+error[E0080]: evaluation of constant value failed
+ --> $DIR/issue-91827-extern-types-field-offset.rs:28:17
+ |
+LL | let field = &x.a;
+ | ^^^^ `extern type` does not have a known offset
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.

tests/ui/consts/const-eval/issue-91827-extern-types.rs

@@ -0,0 +1,26 @@
+// run-fail
+// check-run-results
+// normalize-stderr-test "panicking\.rs:\d+:\d+:" -> "panicking.rs:"
+#![feature(extern_types)]
+
+extern"C"{
+typeOpaque;
+}
+
+structNewtype(Opaque);
+
+structS{
+i:i32,
+a:Opaque,
+}
+
+fnmain(){
+// Projecting to the newtype works, because it is always at offset 0.
+let x:&Newtype = unsafe{&*(1usizeas*constNewtype)};
+let field = &x.0;
+
+// This needs to compute the field offset, but we don't know the type's alignment,
+// so this panics.
+let x:&S = unsafe{&*(1usizeas*constS)};
+let field = &x.a;
+}

tests/ui/extern/extern-types-field-offset.rs

@@ -0,0 +1,4 @@
+thread 'main' panicked at library/core/src/panicking.rs:
+attempted to compute the size or alignment of extern type `Opaque`
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+thread caused non-unwinding panic. aborting.