Made some progress, found what looks like a miscompile

Author: saethlin

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -390,6 +390,31 @@ fn exported_symbols_provider_local(
         }
     }
 
+    if tcx.building_mir_only_rlib() {
+        for def_id in tcx.mir_keys(()) {
+            if !matches!(tcx.def_kind(def_id.to_def_id()), DefKind::Static(_)) {
+                continue;
+            }
+            if tcx.is_reachable_non_generic(def_id.to_def_id()) {
+                continue;
+            }
+            let codegen_attrs = tcx.codegen_fn_attrs(def_id.to_def_id());
+            symbols.push((
+                ExportedSymbol::NonGeneric(def_id.to_def_id()),
+                SymbolExportInfo {
+                    level: symbol_export_level(tcx, def_id.to_def_id()),
+                    kind: if codegen_attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL) {
+                        SymbolExportKind::Tls
+                    } else {
+                        SymbolExportKind::Data
+                    },
+                    used: true,
+                    used_compiler: true,
+                },
+            ));
+        }
+    }
+
     // Sort so we get a stable incr. comp. hash.
     symbols.sort_by_cached_key(|s| s.0.symbol_name_for_local_instance(tcx));
 

compiler/rustc_interface/src/tests.rs

@@ -776,7 +776,7 @@ fn test_unstable_options_tracking_hash() {
     tracked!(mir_emit_retag, true);
     tracked!(mir_enable_passes, vec![("DestProp".to_string(), false)]);
     tracked!(mir_keep_place_mention, true);
-    tracked!(mir_only_libs, true);
+    tracked!(mir_only_rlibs, true);
     tracked!(mir_opt_level, Some(4));
     tracked!(move_size_limit, Some(4096));
     tracked!(mutable_noalias, false);

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -502,6 +502,14 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
             tcx.untracked().cstore.freeze();
             tcx.arena.alloc_from_iter(CStore::from_tcx(tcx).iter_crate_data().map(|(cnum, _)| cnum))
         },
+        mir_only_crates: |tcx, ()| {
+            tcx.untracked().cstore.freeze();
+            let store = CStore::from_tcx(tcx);
+            let crates = store
+                .iter_crate_data()
+                .filter_map(|(cnum, data)| if data.root.is_mir_only { Some(cnum) } else { None });
+            tcx.arena.alloc_from_iter(crates)
+        },
         ..providers.queries
     };
     provide_extern(&mut providers.extern_queries);

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -727,6 +727,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 impls,
                 incoherent_impls,
                 exported_symbols,
+                is_mir_only: tcx.building_mir_only_rlib(),
                 interpret_alloc_index,
                 tables,
                 syntax_contexts,
@@ -1038,7 +1039,7 @@ fn should_encode_mir(
     def_id: LocalDefId,
 ) -> (bool, bool) {
     let opts = &tcx.sess.opts;
-    let mir_required = opts.unstable_opts.always_encode_mir || opts.unstable_opts.mir_only_libs;
+    let mir_required = opts.unstable_opts.always_encode_mir || tcx.building_mir_only_rlib();
     match tcx.def_kind(def_id) {
         // Constructors
         DefKind::Ctor(_, _) => {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -276,6 +276,7 @@ pub(crate) struct CrateRoot {
     debugger_visualizers: LazyArray<DebuggerVisualizerFile>,
 
     exported_symbols: LazyArray<(ExportedSymbol<'static>, SymbolExportInfo)>,
+    is_mir_only: bool,
 
     syntax_contexts: SyntaxContextTable,
     expn_data: ExpnDataTable,

compiler/rustc_middle/src/mir/mono.rs

@@ -99,7 +99,7 @@ impl<'tcx> MonoItem<'tcx> {
 
     pub fn instantiation_mode(&self, tcx: TyCtxt<'tcx>) -> InstantiationMode {
         // Always do LocalCopy codegen when building a MIR-only rlib
-        if tcx.building_mir_only_lib() {
+        if tcx.building_mir_only_rlib() {
             return InstantiationMode::LocalCopy;
         }
         let generate_cgu_internal_copies = tcx
@@ -112,17 +112,6 @@ impl<'tcx> MonoItem<'tcx> {
 
         match *self {
             MonoItem::Fn(ref instance) => {
-                // See the check in MirUsedCollector for building_mir_only_bin for background.
-                // Here, we need to give the symbols that the collector feeds to use GloballyShared
-                // linkage so that CGU partitioning doesn't try to assign them lazily, then find no
-                // uses of them. They might only be used by an upstream crate, so we need to force
-                // codegen, which is what GloballyShared does.
-                if tcx.building_mir_only_bin()
-                    && tcx.codegen_fn_attrs(instance.def_id()).contains_extern_indicator()
-                {
-                    return InstantiationMode::GloballyShared { may_conflict: false };
-                }
-
                 let entry_def_id = tcx.entry_fn(()).map(|(id, _)| id);
                 // If this function isn't inlined or otherwise has an extern
                 // indicator, then we'll be creating a globally shared version.

compiler/rustc_middle/src/query/mod.rs

@@ -2195,6 +2195,11 @@ rustc_queries! {
         desc { "whether the item should be made inlinable across crates" }
         separate_provide_extern
     }
+
+    query mir_only_crates(_: ()) -> &'tcx [CrateNum] {
+        eval_always
+        desc { "fetching all foreign crates built in mir-only mode" }
+    }
 }
 
 rustc_query_append! { define_callbacks! }

compiler/rustc_middle/src/ty/context.rs

@@ -1029,12 +1029,8 @@ impl<'tcx> TyCtxt<'tcx> {
         self.sess.dcx()
     }
 
-    pub fn building_mir_only_lib(self) -> bool {
-        self.sess.opts.unstable_opts.mir_only_libs && self.crate_types() == &[CrateType::Rlib]
-    }
-
-    pub fn building_mir_only_bin(self) -> bool {
-        self.sess.opts.unstable_opts.mir_only_libs && self.crate_types() == &[CrateType::Executable]
+    pub fn building_mir_only_rlib(self) -> bool {
+        self.sess.opts.unstable_opts.mir_only_rlibs && self.crate_types() == &[CrateType::Rlib]
     }
 }
 

compiler/rustc_monomorphize/src/collector.rs

@@ -185,6 +185,7 @@ use rustc_middle::ty::{
 };
 use rustc_middle::ty::{GenericArgKind, GenericArgs};
 use rustc_middle::{middle::codegen_fn_attrs::CodegenFnAttrFlags, mir::visit::TyContext};
+use rustc_session::config::CrateType;
 use rustc_session::config::EntryFnType;
 use rustc_session::lint::builtin::LARGE_ASSIGNMENTS;
 use rustc_session::Limit;
@@ -317,6 +318,7 @@ fn collect_roots(tcx: TyCtxt<'_>, mode: MonoItemCollectionMode) -> Vec<MonoItem<
         }
 
         collector.push_extra_entry_roots();
+        collector.push_extra_roots_from_mir_only_rlibs();
     }
 
     // We can only codegen items that are instantiable - items all of
@@ -976,15 +978,15 @@ fn should_codegen_locally<'tcx>(tcx: TyCtxt<'tcx>, instance: &Instance<'tcx>) ->
     };
 
     if tcx.is_foreign_item(def_id) {
-        if tcx.sess.opts.unstable_opts.mir_only_libs {
+        if tcx.building_mir_only_rlib() {
             return tcx.is_mir_available(instance.def_id());
         } else {
             // Foreign items are always linked against, there's no way of instantiating them.
             return false;
         }
     }
 
-    if tcx.sess.opts.unstable_opts.mir_only_libs {
+    if tcx.building_mir_only_rlib() {
         let has_mir = tcx.is_mir_available(instance.def_id());
         return has_mir || matches!(tcx.def_kind(instance.def_id()), DefKind::Static(_));
     }
@@ -1281,7 +1283,6 @@ impl<'v> RootCollector<'_, 'v> {
         let Some((main_def_id, EntryFnType::Main { .. })) = self.entry_fn else {
             return;
         };
-
         let start_def_id = self.tcx.require_lang_item(LangItem::Start, None);
         let main_ret_ty = self.tcx.fn_sig(main_def_id).no_bound_vars().unwrap().output();
 
@@ -1305,34 +1306,50 @@ impl<'v> RootCollector<'_, 'v> {
         .unwrap();
 
         self.output.push(create_fn_mono_item(self.tcx, start_instance, DUMMY_SP));
+    }
 
+    fn push_extra_roots_from_mir_only_rlibs(&mut self) {
         // An upstream extern function may be used anywhere in the dependency tree, so we
         // cannot do any reachability analysis on them. We blindly monomorphize every
         // extern function declared anywhere in our dependency tree. We must give them
         // GloballyShared codegen because we don't know if the only call to an upstream
         // extern function is also upstream: We don't have reachability information. All we
         // can do is codegen all extern functions and pray for the linker to delete the
         // ones that are reachable.
-        if self.tcx.building_mir_only_bin() {
-            for (symbol, _info) in
-                self.tcx.crates(()).into_iter().flat_map(|krate| self.tcx.exported_symbols(*krate))
-            {
-                let def_id = match symbol {
-                    ExportedSymbol::NonGeneric(def_id) => def_id,
-                    _ => {
-                        continue;
-                    }
-                };
-                if self.tcx.def_kind(def_id) != DefKind::Fn {
+        if !self.tcx.crate_types().iter().any(|c| !matches!(c, CrateType::Rlib)) {
+            return;
+        }
+
+        for (symbol, _info) in self
+            .tcx
+            .mir_only_crates(())
+            .into_iter()
+            .flat_map(|krate| self.tcx.exported_symbols(*krate))
+        {
+            let def_id = match symbol {
+                ExportedSymbol::NonGeneric(def_id) => def_id,
+                ExportedSymbol::ThreadLocalShim(def_id) => {
+                    let item = MonoItem::Fn(Instance {
+                        def: InstanceDef::ThreadLocalShim(*def_id),
+                        args: GenericArgs::empty(),
+                    });
+                    self.output.push(respan(DUMMY_SP, item));
                     continue;
                 }
-                let instance = Instance::mono(self.tcx, *def_id);
-                // FIXME: This is probably not the right span. What is?
-                let item = create_fn_mono_item(self.tcx, instance, DUMMY_SP);
-                // FIXME: Do we need this check?
-                if !self.output.iter().any(|out| out.node.def_id() == *def_id) {
-                    self.output.push(item);
+                _ => continue,
+            };
+            match self.tcx.def_kind(def_id) {
+                DefKind::Fn | DefKind::AssocFn => {
+                    let instance = Instance::mono(self.tcx, *def_id);
+                    let item = create_fn_mono_item(self.tcx, instance, DUMMY_SP);
+                    if !self.output.iter().any(|out| out.node.def_id() == *def_id) {
+                        self.output.push(item);
+                    }
+                }
+                DefKind::Static(_) => {
+                    self.output.push(dummy_spanned(MonoItem::Static(*def_id)));
                 }
+                _ => {}
             }
         }
     }

compiler/rustc_monomorphize/src/partitioning.rs

@@ -141,8 +141,10 @@ fn partition<'tcx, I>(
 where
     I: Iterator<Item = MonoItem<'tcx>>,
 {
-    if tcx.sess.opts.unstable_opts.mir_only_libs {
-        assert!(tcx.building_mir_only_lib() || tcx.building_mir_only_bin());
+    if tcx.building_mir_only_rlib() {
+        let cgu_name_builder = &mut CodegenUnitNameBuilder::new(tcx);
+        let cgu_name = fallback_cgu_name(cgu_name_builder);
+        return vec![CodegenUnit::new(cgu_name)];
     }
 
     let _prof_timer = tcx.prof.generic_activity("cgu_partitioning");
@@ -169,6 +171,10 @@ where
         debug_dump(tcx, "MERGE", &codegen_units);
     }
 
+    if !codegen_units.is_sorted_by(|a, b| Some(a.name().as_str().cmp(b.name().as_str()))) {
+        bug!("unsorted CGUs");
+    }
+
     // Make as many symbols "internal" as possible, so LLVM has more freedom to
     // optimize.
     if !tcx.sess.link_dead_code() {
@@ -191,7 +197,12 @@ where
         for cgu in codegen_units.iter() {
             names += &format!("- {}\n", cgu.name());
         }
-        bug!("unsorted CGUs:\n{names}");
+        codegen_units.sort_by(|a, b| a.name().as_str().cmp(b.name().as_str()));
+        let mut sorted_names = String::new();
+        for cgu in codegen_units.iter() {
+            sorted_names += &format!("- {}\n", cgu.name());
+        }
+        bug!("unsorted CGUs:\n{names}\n{sorted_names}");
     }
 
     codegen_units
@@ -264,9 +275,6 @@ where
         cgu.items_mut()
             .insert(mono_item, MonoItemData { inlined: false, linkage, visibility, size_estimate });
 
-        if cx.tcx.building_mir_only_lib() {
-            continue;
-        }
         // Get all inlined items that are reachable from `mono_item` without
         // going via another root item. This includes drop-glue, functions from
         // external crates, and local functions the definition of which is