Auto merge of #149973 - ShoyuVanilla:static-ref-cycle, r=<try>

Prohibit cycles behind references while static initialization

Author: rust-bors[bot]

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -856,6 +856,36 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
         interp_ok(())
     }
 
+    fn before_static_ref_eval(
+        tcx: TyCtxtAt<'tcx>,
+        machine: &Self,
+        ptr: Pointer<Self::Provenance>,
+        static_def_id: DefId,
+    ) -> InterpResult<'tcx> {
+        // We are only interested in immediate references to statics here.
+        // Indirect references should not be checked because:
+        //  - they may be references to some other legitimate static reference
+        //    (e.g. via a raw pointer), and
+        //  - if they originate from an illegal static reference, that illegal
+        //    reference must already appear in the body and will be checked there.
+        if ptr.provenance.shared_ref() {
+            return interp_ok(());
+        }
+
+        // Check if this is the currently evaluated static.
+        if Some(static_def_id) == machine.static_root_ids.map(|(_, def_id)| def_id.into()) {
+            return Err(ConstEvalErrKind::RecursiveStatic).into();
+        }
+
+        if !tcx.is_foreign_item(static_def_id) {
+            // Fire the query to detect cycles. We cannot restrict this to only when
+            // evaluating statics, since static reference cycles can also be formed
+            // through consts, especially promoted ones.
+            tcx.eval_static_initializer(static_def_id)?;
+        }
+        interp_ok(())
+    }
+
     fn cached_union_data_range<'e>(
         ecx: &'e mut InterpCx<'tcx, Self>,
         ty: Ty<'tcx>,

compiler/rustc_const_eval/src/interpret/machine.rs

@@ -447,6 +447,20 @@ pub trait Machine<'tcx>: Sized {
         interp_ok(())
     }
 
+    /// Hook for performing extra checks on any reference to static.
+    /// This is not invoked for raw pointers such as `unsafe { &*&raw const STATIC }`.
+    ///
+    /// Used to prevent statics from constructing uninhabitated values by referencing themselves
+    /// as it is being initialized.
+    fn before_static_ref_eval(
+        _tcx: TyCtxtAt<'tcx>,
+        _machine: &Self,
+        _ptr: Pointer<Self::Provenance>,
+        _static_def_id: DefId,
+    ) -> InterpResult<'tcx> {
+        interp_ok(())
+    }
+
     /// Hook for performing extra checks on a memory write access.
     /// This is not invoked for ZST accesses, as no write actually happens.
     /// `ptr` will always be a pointer with the provenance in `prov` pointing to the beginning of

compiler/rustc_const_eval/src/interpret/step.rs

@@ -3,11 +3,13 @@
 //! The main entry point is the `step` method.
 
 use std::iter;
+use std::ops::Deref;
 
 use either::Either;
 use rustc_abi::{FIRST_VARIANT, FieldIdx};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_index::IndexSlice;
+use rustc_middle::mir::interpret::{GlobalAlloc, Provenance, Scalar};
 use rustc_middle::ty::{self, Instance, Ty};
 use rustc_middle::{bug, mir, span_bug};
 use rustc_span::source_map::Spanned;
@@ -217,9 +219,30 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             }
 
             Ref(_, borrow_kind, place) => {
+                let is_reborrow_of_ref = if let Some(local) = place.local_or_deref_local()
+                    && place.is_indirect()
+                {
+                    self.layout_of_local(self.frame(), local, None)?.ty.is_ref()
+                } else {
+                    false
+                };
+
                 let src = self.eval_place(place)?;
                 let place = self.force_allocation(&src)?;
                 let val = ImmTy::from_immediate(place.to_ref(self), dest.layout);
+
+                // Check whether this forms a cycle involving a static reference.
+                // Ensure the place is not a reborrow from a raw pointer, since we do not want to
+                // forbid static reference cycles that go through raw pointers.
+                if is_reborrow_of_ref
+                    && let Immediate::Scalar(Scalar::Ptr(ptr, _)) = val.deref()
+                    && let Some(alloc_id) = ptr.provenance.get_alloc_id()
+                    && let Some(GlobalAlloc::Static(def_id)) =
+                        self.tcx.try_get_global_alloc(alloc_id)
+                {
+                    M::before_static_ref_eval(self.tcx, &self.machine, *ptr, def_id)?;
+                }
+
                 // A fresh reference was created, make sure it gets retagged.
                 let val = M::retag_ptr_value(
                     self,

tests/ui/consts/const-eval/issue-47971.rs

@@ -1,9 +1,8 @@
-//@ check-pass
-
 struct S(pub &'static u32, pub u32);
 
 const fn g(ss: &S) -> &u32 { &ss.1 }
 
 static T: S = S(g(&T), 0);
+//~^ ERROR: encountered static that tried to access itself during initialization
 
 fn main () { }

tests/ui/consts/const-eval/issue-47971.stderr

@@ -0,0 +1,9 @@
+error[E0080]: encountered static that tried to access itself during initialization
+  --> $DIR/issue-47971.rs:5:19
+   |
+LL | static T: S = S(g(&T), 0);
+   |                   ^^ evaluation of `T` failed here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.

tests/ui/consts/cycle-static-promoted.rs

@@ -1,12 +1,11 @@
-//@ check-pass
-
 struct Value {
     values: &'static [&'static Value],
 }
 
 // This `static` recursively points to itself through a promoted (the slice).
 static VALUE: Value = Value {
     values: &[&VALUE],
+    //~^ ERROR: cycle detected when evaluating initializer of static `VALUE`
 };
 
 fn main() {}

tests/ui/consts/cycle-static-promoted.stderr

@@ -0,0 +1,23 @@
+error[E0391]: cycle detected when evaluating initializer of static `VALUE`
+  --> $DIR/cycle-static-promoted.rs:7:13
+   |
+LL |     values: &[&VALUE],
+   |             ^^^^^^^^^
+   |
+note: ...which requires simplifying constant for the type system `VALUE::promoted[0]`...
+  --> $DIR/cycle-static-promoted.rs:6:1
+   |
+LL | static VALUE: Value = Value {
+   | ^^^^^^^^^^^^^^^^^^^
+note: ...which requires const-evaluating + checking `VALUE::promoted[0]`...
+  --> $DIR/cycle-static-promoted.rs:6:1
+   |
+LL | static VALUE: Value = Value {
+   | ^^^^^^^^^^^^^^^^^^^
+   = note: ...which again requires evaluating initializer of static `VALUE`, completing the cycle
+   = note: cycle used when running analysis passes on crate `cycle_static_promoted`
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0391`.

tests/ui/consts/static-cycle-error.rs

@@ -1,11 +1,10 @@
-//@ check-pass
-
 struct Foo {
     foo: Option<&'static Foo>
 }
 
 static FOO: Foo = Foo {
     foo: Some(&FOO),
+    //~^ ERROR: encountered static that tried to access itself during initialization
 };
 
 fn main() {}

tests/ui/consts/static-cycle-error.stderr

@@ -0,0 +1,9 @@
+error[E0080]: encountered static that tried to access itself during initialization
+  --> $DIR/static-cycle-error.rs:6:15
+   |
+LL |     foo: Some(&FOO),
+   |               ^^^^ evaluation of `FOO` failed here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.

tests/ui/statics/recursive_interior_mut.rs

@@ -13,7 +13,7 @@ unsafe impl Sync for EmptyChunkFooter {}
 
 static EMPTY_CHUNK: EmptyChunkFooter = EmptyChunkFooter(ChunkFooter {
     prev: Cell::new(unsafe {
-        NonNull::new_unchecked(&EMPTY_CHUNK as *const EmptyChunkFooter as *mut ChunkFooter)
+        NonNull::new_unchecked(&raw const EMPTY_CHUNK as *mut ChunkFooter)
     }),
 });