Ensure that static initializers are acyclic for NVPTX

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,162 @@
+use rustc_data_structures::fx::FxIndexSet;
+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, Allocation, ConstAllocation, 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
+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 statics: FxIndexSet<LocalDefId> = tcx
+        .hir_free_items()
+        .filter_map(|item_id| {
+            let item = tcx.hir_item(item_id);
+            match item.kind {
+                hir::ItemKind::Static(..) => Some(item.owner_id.def_id),
+                _ => None,
+            }
+        })
+        .collect();
+
+    // Fast path
+    if statics.is_empty() {
+        return Ok(());
+    }
+
+    // For all statics collect all reachable statics to create a graph
+    let graph = StaticRefGraph {
+        succ: statics
+            .iter()
+            .map(|&id| {
+                if let Ok(root_alloc) = tcx.eval_static_initializer(id) {
+                    collect_referenced_local_statics(tcx, root_alloc, &statics)
+                } else {
+                    Vec::new()
+                }
+            })
+            .collect(),
+    };
+
+    // Calculate all SCCs from the graph
+    let sccs: Sccs<StaticNodeIdx, StaticSccIdx> = Sccs::new(&graph);
+    // Group statics by SCCs
+    let mut members: IndexVec<StaticSccIdx, Vec<StaticNodeIdx>> =
+        IndexVec::from_elem_n(Vec::new(), sccs.num_sccs());
+    for i in graph.succ.indices() {
+        members[sccs.scc(i)].push(i);
+    }
+    let mut first_guar: Option<ErrorGuaranteed> = None;
+
+    for scc in sccs.all_sccs() {
+        let nodes = &members[scc];
+        let acyclic = match nodes.len() {
+            0 => true,
+            1 => !graph.successors(nodes[0]).any(|x| x == nodes[0]),
+            2.. => false,
+        };
+
+        if acyclic {
+            continue;
+        }
+
+        let head_def = statics.get_index(nodes[0].into()).unwrap();
+        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()),
+            ),
+        );
+        diag.span_labels(
+            nodes.iter().map(|&n| tcx.def_span(*statics.get_index(n.into()).unwrap())),
+            "part of this cycle",
+        )
+        .note(format!(
+            "cyclic static initializer references are not supported for target `{}`",
+            tcx.sess.target.llvm_target
+        ));
+        first_guar.get_or_insert(diag.emit());
+    }
+
+    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: ConstAllocation<'tcx>,
+    node_of: &FxIndexSet<LocalDefId>,
+) -> Vec<StaticNodeIdx> {
+    let mut nodes: Vec<StaticNodeIdx> = Vec::default();
+    let mut alloc_ids: FxIndexSet<AllocId> = FxIndexSet::default();
+
+    let add_ids_from_alloc = |alloc: &Allocation, ids: &mut FxIndexSet<AllocId>| {
+        ids.extend(alloc.provenance().ptrs().iter().map(|(_, prov)| prov.alloc_id()));
+    };
+
+    // Scan the root allocation for pointers first.
+    add_ids_from_alloc(root_alloc.inner(), &mut alloc_ids);
+
+    let mut visited_allocs: usize = 0;
+
+    while let Some(&alloc_id) = alloc_ids.get_index(visited_allocs) {
+        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_index_of(&local_def)
+                {
+                    nodes.push(node.into());
+                }
+            }
+
+            GlobalAlloc::Memory(const_alloc) => {
+                add_ids_from_alloc(const_alloc.inner(), &mut alloc_ids);
+            }
+
+            _ => {
+                // Functions, vtables, etc: ignore
+            }
+        }
+        visited_allocs += 1;
+    }
+    nodes
+}

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,9 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
             }
         });
     });
-
+    if tcx.sess.target.options.static_initializer_must_be_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!(static_initializer_must_be_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!(static_initializer_must_be_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>,
+    static_initializer_must_be_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 static_initializer_must_be_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,
+            static_initializer_must_be_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
+            static_initializer_must_be_acyclic: true,
+
             ..Default::default()
         },
     }

tests/auxiliary/minicore.rs

@@ -211,7 +211,7 @@ impl Neg for isize {
 }
 
 #[lang = "sync"]
-trait Sync {}
+pub trait Sync {}
 impl_marker_trait!(
     Sync => [
         char, bool,

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

@@ -0,0 +1,29 @@
+//@ add-minicore
+//@ needs-llvm-components: nvptx
+//@ compile-flags: --target=nvptx64-nvidia-cuda
+//@ ignore-backends: gcc
+#![crate_type = "rlib"]
+#![feature(no_core)]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+struct Foo(&'static Foo);
+impl Sync for Foo {}
+
+static A: Foo = Foo(&A); //~ ERROR static initializer forms a cycle involving `A`
+
+static B0: Foo = Foo(&B1); //~ ERROR static initializer forms a cycle involving `B0`
+static B1: Foo = Foo(&B0);
+
+static C0: Foo = Foo(&C1); //~ ERROR static initializer forms a cycle involving `C0`
+static C1: Foo = Foo(&C2);
+static C2: Foo = Foo(&C0);
+
+struct Bar(&'static u32);
+impl Sync for Bar {}
+
+static BAR: Bar = Bar(&INT);
+static INT: u32 = 42u32;