Change:
Compiling following under some circumstances result in undefined references to : This linking issue occurs only under for some codegen partitioning but not the others. Reproducing it requires controlling the options that influence the number of codegen units. I can reproduce it with either , or combined with . The weak lang items introduce cyclic dependencies between crates. For example, the alloc crate depends on oom lang item which is defined in std. When linking the std comes first, and it may so happen that object file that contains definition is not used and omitted (this suggest why large number of codegen units is necessary to reproduce the issue), and subsequently alloc crate will fail to link. The [linking code][0] tries to account for cyclic dependencies using start-group and end-group, but as far as I can see it based on assumption that weak lang items dependencies are always reversed, which no longer holds true. [0]:

Discussion:
// for the current implementation of the standard library. let mut group_end = None; let mut group_start = None; <del> let mut end_with = FxHashSet::default(); </del> <ins> // Crates available for linking thus far. let mut available = FxHashSet::default(); // Crates required to satisfy dependencies discovered so far. let mut required = FxHashSet::default(); </ins> let info = &codegen_results.crate_info; for &(cnum, _) in deps.iter().rev() { if let Some(missing) = info.missing_lang_items.get(&cnum) { <del> end_with.extend(missing.iter().cloned()); if !end_with.is_empty() && group_end.is_none() { group_end = Some(cnum); } </del> <ins> let missing_crates = missing.iter().map(|i| info.lang_item_to_crate.get(i).copied()); required.extend(missing_crates); } required.insert(Some(cnum)); available.insert(Some(cnum)); if required.len() > available.len() && group_end.is_none() { group_end = Some(cnum); </ins> } <del> end_with.retain(|item| info.lang_item_to_crate.get(item) != Some(&cnum)); if end_with.is_empty() && group_end.is_some() { </del> <ins> if required.len() == available.len() && group_end.is_some() { </ins> group_start = Some(cnum); break; }

<ins> -include ../tools.mk # Test that previously triggered a linker failure with root cause # similar to one found in the issue #69368. # # The crate that provides oom lang item is missing some other lang # items. Necessary to prevent the use of start-group / end-group. # # The weak lang items are defined in a separate compilation units, # so that linker could omit them if not used. # # The crates that need those weak lang items are dependencies of # crates that provide them. all: $(RUSTC) a.rs $(RUSTC) b.rs $(RUSTC) c.rs </ins>

<ins> #![crate_type = "rlib"] #![feature(lang_items)] #![feature(panic_unwind)] #![no_std] extern crate panic_unwind; #[panic_handler] pub fn panic_handler(_: &core::panic::PanicInfo) -> ! { loop {} } #[no_mangle] extern "C" fn __rust_drop_panic() -> ! { loop {} } </ins>

<ins> #![crate_type = "rlib"] #![feature(alloc_error_handler)] #![no_std] #[alloc_error_handler] pub fn error_handler(_: core::alloc::Layout) -> ! { panic!(); } </ins>

<ins> #![crate_type = "bin"] #![feature(start)] #![no_std] extern crate alloc; extern crate a; extern crate b; use alloc::vec::Vec; use core::alloc::*; struct Allocator; unsafe impl GlobalAlloc for Allocator { unsafe fn alloc(&self, _: Layout) -> *mut u8 { loop {} } unsafe fn dealloc(&self, _: *mut u8, _: Layout) { loop {} } } #[global_allocator] static ALLOCATOR: Allocator = Allocator; #[start] fn main(argc: isize, _argv: *const *const u8) -> isize { let mut v = Vec::new(); for i in 0..argc { v.push(i); } v.iter().sum() } </ins>