Initial version of this check

Author: kulst

compiler/rustc_const_eval/src/check_static_initializer_acyclic.rs

@@ -0,0 +1,183 @@
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::graph::scc::Sccs;
+use rustc_data_structures::graph::{DirectedGraph, Successors};
+use rustc_hir as hir;
+use rustc_index::{IndexVec, newtype_index};
+use rustc_middle::mir::interpret::{AllocId, GlobalAlloc};
+use rustc_middle::ty::TyCtxt;
+use rustc_span::ErrorGuaranteed;
+use rustc_span::def_id::LocalDefId;
+
+// --- graph indices
+newtype_index! {
+    struct StaticNodeIdx {}
+}
+newtype_index! {
+    #[derive(Ord, PartialOrd)]
+    struct StaticSccIdx {}
+}
+
+// --- adjacency-list graph for rustc_data_structures::graph::scc
+struct StaticRefGraph {
+    succ: IndexVec<StaticNodeIdx, Vec<StaticNodeIdx>>,
+}
+
+impl DirectedGraph for StaticRefGraph {
+    type Node = StaticNodeIdx;
+
+    fn num_nodes(&self) -> usize {
+        self.succ.len()
+    }
+}
+
+impl Successors for StaticRefGraph {
+    fn successors(&self, n: StaticNodeIdx) -> impl Iterator<Item = StaticNodeIdx> {
+        self.succ[n].iter().copied()
+    }
+}
+
+pub(crate) fn check_static_initializer_acyclic(
+    tcx: TyCtxt<'_>,
+    _: (),
+) -> Result<(), ErrorGuaranteed> {
+    // Collect local statics
+    let mut statics: Vec<LocalDefId> = Vec::new();
+    for item_id in tcx.hir_free_items() {
+        let item = tcx.hir_item(item_id);
+        if matches!(item.kind, hir::ItemKind::Static(..)) {
+            statics.push(item.owner_id.def_id);
+        }
+    }
+
+    // Fast path
+    if statics.is_empty() {
+        return Ok(());
+    }
+
+    // Map statics to dense node indices
+    let mut node_of: FxHashMap<LocalDefId, StaticNodeIdx> = FxHashMap::default();
+    let mut def_of: IndexVec<StaticNodeIdx, LocalDefId> = IndexVec::new();
+    for &def_id in statics.iter() {
+        let idx = def_of.push(def_id);
+        node_of.insert(def_id, idx);
+    }
+
+    let mut graph = StaticRefGraph { succ: IndexVec::from_elem_n(Vec::new(), def_of.len()) };
+
+    // Build edges by evaluating each static initializer and scanning provenance
+    for &from_def in &statics {
+        let from_node = node_of[&from_def];
+
+        // If const-eval already errored for this static, skip (we don't want noisy follow-ups).
+        let Ok(root_alloc) = tcx.eval_static_initializer(from_def) else {
+            continue;
+        };
+
+        let mut out_edges: FxHashSet<StaticNodeIdx> = FxHashSet::default();
+        collect_referenced_local_statics(tcx, root_alloc, &node_of, &mut out_edges);
+        #[allow(rustc::potential_query_instability)]
+        graph.succ[from_node].extend(out_edges);
+    }
+
+    // 4) SCCs
+    let sccs: Sccs<StaticNodeIdx, StaticSccIdx> = Sccs::new(&graph); // :contentReference[oaicite:4]{index=4}
+
+    // Group members by SCC
+    let mut members: IndexVec<StaticSccIdx, Vec<StaticNodeIdx>> =
+        IndexVec::from_elem_n(Vec::new(), sccs.num_sccs());
+
+    for i in 0..def_of.len() {
+        let n = StaticNodeIdx::from_usize(i);
+        members[sccs.scc(n)].push(n);
+    }
+
+    // 5) Emit errors for cyclic SCCs
+    let mut first_guar: Option<ErrorGuaranteed> = None;
+
+    for scc in sccs.all_sccs() {
+        let nodes = &members[scc];
+        if nodes.is_empty() {
+            continue;
+        }
+
+        let is_cycle = nodes.len() > 1
+            || (nodes.len() == 1 && graph.successors(nodes[0]).any(|x| x == nodes[0]));
+        if !is_cycle {
+            continue;
+        }
+
+        let head_def = def_of[nodes[0]];
+        let head_span = tcx.def_span(head_def);
+
+        let mut diag = tcx.dcx().struct_span_err(
+            head_span,
+            format!(
+                "static initializer forms a cycle involving `{}`",
+                tcx.def_path_str(head_def.to_def_id()),
+            ),
+        );
+
+        for &n in nodes {
+            let d = def_of[n];
+            diag.span_label(tcx.def_span(d), "part of this cycle");
+        }
+
+        diag.note(format!(
+            "cyclic static initializer references are not supported for target `{}`",
+            tcx.sess.target.llvm_target
+        ));
+
+        let guar = diag.emit();
+        first_guar.get_or_insert(guar);
+    }
+
+    match first_guar {
+        Some(g) => Err(g),
+        None => Ok(()),
+    }
+}
+
+// Traverse allocations reachable from the static initializer allocation and collect local-static targets.
+fn collect_referenced_local_statics<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    root_alloc: rustc_middle::mir::interpret::ConstAllocation<'tcx>,
+    node_of: &FxHashMap<LocalDefId, StaticNodeIdx>,
+    out: &mut FxHashSet<StaticNodeIdx>,
+) {
+    let mut stack: Vec<AllocId> = Vec::new();
+    let mut seen: FxHashSet<AllocId> = FxHashSet::default();
+
+    // Scan the root allocation for pointers first.
+    push_ptr_alloc_ids(root_alloc.inner(), &mut stack);
+
+    while let Some(alloc_id) = stack.pop() {
+        if !seen.insert(alloc_id) {
+            continue;
+        }
+
+        match tcx.global_alloc(alloc_id) {
+            GlobalAlloc::Static(def_id) => {
+                if let Some(local_def) = def_id.as_local()
+                    && let Some(&node) = node_of.get(&local_def)
+                {
+                    out.insert(node);
+                }
+            }
+
+            GlobalAlloc::Memory(const_alloc) => {
+                push_ptr_alloc_ids(const_alloc.inner(), &mut stack);
+            }
+
+            _ => {
+                // Functions, vtables, etc: ignore
+            }
+        }
+    }
+}
+
+// Extract all AllocIds referenced by pointers in this allocation via provenance.
+fn push_ptr_alloc_ids(alloc: &rustc_middle::mir::interpret::Allocation, stack: &mut Vec<AllocId>) {
+    for (_, prov) in alloc.provenance().ptrs().iter() {
+        stack.push(prov.alloc_id());
+    }
+}

compiler/rustc_const_eval/src/lib.rs

@@ -15,6 +15,7 @@
 // tidy-alphabetical-end
 
 pub mod check_consts;
+mod check_static_initializer_acyclic;
 pub mod const_eval;
 mod errors;
 pub mod interpret;
@@ -48,6 +49,8 @@ pub fn provide(providers: &mut Providers) {
     };
     providers.hooks.validate_scalar_in_layout =
         |tcx, scalar, layout| util::validate_scalar_in_layout(tcx, scalar, layout);
+    providers.check_static_initializer_acyclic =
+        check_static_initializer_acyclic::check_static_initializer_acyclic;
 }
 
 /// `rustc_driver::main` installs a handler that will set this to `true` if

compiler/rustc_interface/src/passes.rs

@@ -1133,7 +1133,10 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
             }
         });
     });
-
+    // NEW: target-gated pre-codegen error
+    if tcx.sess.target.options.requires_static_initializer_acyclic {
+        tcx.ensure_ok().check_static_initializer_acyclic(());
+    }
     sess.time("layout_testing", || layout_test::test_layout(tcx));
     sess.time("abi_testing", || abi_test::test_abi(tcx));
 }

compiler/rustc_middle/src/query/mod.rs

@@ -258,6 +258,9 @@ rustc_queries! {
         desc { |tcx| "getting HIR parent of `{}`", tcx.def_path_str(key) }
     }
 
+    query check_static_initializer_acyclic(_: ()) -> Result<(), ErrorGuaranteed> {
+        desc { "checking that static initializers are acyclic" }
+    }
     /// Gives access to the HIR nodes and bodies inside `key` if it's a HIR owner.
     ///
     /// This can be conveniently accessed by `tcx.hir_*` methods.

compiler/rustc_target/src/spec/mod.rs

@@ -2394,6 +2394,9 @@ pub struct TargetOptions {
     pub archive_format: StaticCow<str>,
     /// Is asm!() allowed? Defaults to true.
     pub allow_asm: bool,
+    /// Static initializers must be acyclic.
+    /// Defaults to false
+    pub requires_static_initializer_acyclic: bool,
     /// Whether the runtime startup code requires the `main` function be passed
     /// `argc` and `argv` values.
     pub main_needs_argc_argv: bool,
@@ -2777,6 +2780,7 @@ impl Default for TargetOptions {
             archive_format: "gnu".into(),
             main_needs_argc_argv: true,
             allow_asm: true,
+            requires_static_initializer_acyclic: false,
             has_thread_local: false,
             obj_is_bitcode: false,
             min_atomic_width: None,

compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs

@@ -59,6 +59,9 @@ pub(crate) fn target() -> Target {
             // Support using `self-contained` linkers like the llvm-bitcode-linker
             link_self_contained: LinkSelfContainedDefault::True,
 
+            // Static initializers must not have cycles on this target
+            requires_static_initializer_acyclic: true,
+
             ..Default::default()
         },
     }

tests/ui/static/static-initializer-acyclic-issue-146787.rs

@@ -0,0 +1,6 @@
+//@ only-nvptx64
+//@ ignore-backends: gcc
+#![crate_type = "rlib"]
+#![no_std]
+struct Bar(&'static Bar);
+static FOO: Bar = Bar(&FOO); //~ ERROR static initializer forms a cycle involving `FOO`