Ensure that static initializers are acyclic for targets that require this

Some targets (for now only NVPTX) do not support cycles in static initializers (see #146787). LLVM produces an error when attempting to codegen such constructs (like self referential structs).

This PR attempts to instead error on Rust side before reaching codegen to not produce LLVM UB.

This is achieved by computing a new query in rustc_const_eval. It is executed as a required analysis depending on a new flag in TargetOptions. The check

1. organizes all local static items in a DirectedGraph where pointers / references to other local static items represent the edges
2. calculates the strongly connected components (SCCs) of the graph
3. checks for cycles (more than one node in a SCC)

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/json.rs

@@ -163,6 +163,7 @@ impl Target {
         forward!(relro_level);
         forward!(archive_format);
         forward!(allow_asm);
+        forward!(requires_static_initializer_acyclic);
         forward!(main_needs_argc_argv);
         forward!(has_thread_local);
         forward!(obj_is_bitcode);
@@ -360,6 +361,7 @@ impl ToJson for Target {
         target_option_val!(relro_level);
         target_option_val!(archive_format);
         target_option_val!(allow_asm);
+        target_option_val!(requires_static_initializer_acyclic);
         target_option_val!(main_needs_argc_argv);
         target_option_val!(has_thread_local);
         target_option_val!(obj_is_bitcode);
@@ -581,6 +583,7 @@ struct TargetSpecJson {
     relro_level: Option<RelroLevel>,
     archive_format: Option<StaticCow<str>>,
     allow_asm: Option<bool>,
+    requires_static_initializer_acyclic: Option<bool>,
     main_needs_argc_argv: Option<bool>,
     has_thread_local: Option<bool>,
     obj_is_bitcode: Option<bool>,

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`