1use std::cmp;
2use std::collections::BTreeSet;
3use std::sync::Arc;
4use std::time::{Duration, Instant};
5
6use itertools::Itertools;
7use rustc_abi::FIRST_VARIANT;
8use rustc_ast as ast;
9use rustc_ast::expand::allocator::AllocatorKind;
10use rustc_attr_data_structures::OptimizeAttr;
11use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
12use rustc_data_structures::profiling::{get_resident_set_size, print_time_passes_entry};
13use rustc_data_structures::sync::{IntoDynSyncSend, par_map};
14use rustc_data_structures::unord::UnordMap;
15use rustc_hir::def_id::{DefId, LOCAL_CRATE};
16use rustc_hir::lang_items::LangItem;
17use rustc_hir::{ItemId, Target};
18use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
19use rustc_middle::middle::debugger_visualizer::{DebuggerVisualizerFile, DebuggerVisualizerType};
20use rustc_middle::middle::exported_symbols::{self, SymbolExportKind};
21use rustc_middle::middle::lang_items;
22use rustc_middle::mir::BinOp;
23use rustc_middle::mir::interpret::ErrorHandled;
24use rustc_middle::mir::mono::{CodegenUnit, CodegenUnitNameBuilder, MonoItem, MonoItemPartitions};
25use rustc_middle::query::Providers;
26use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf, TyAndLayout};
27use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
28use rustc_middle::{bug, span_bug};
29use rustc_session::Session;
30use rustc_session::config::{self, CrateType, EntryFnType};
31use rustc_span::{DUMMY_SP, Symbol, sym};
32use rustc_symbol_mangling::mangle_internal_symbol;
33use rustc_trait_selection::infer::{BoundRegionConversionTime, TyCtxtInferExt};
34use rustc_trait_selection::traits::{ObligationCause, ObligationCtxt};
35use tracing::{debug, info};
36
37use crate::assert_module_sources::CguReuse;
38use crate::back::link::are_upstream_rust_objects_already_included;
39use crate::back::write::{
40 ComputedLtoType, OngoingCodegen, compute_per_cgu_lto_type, start_async_codegen,
41 submit_codegened_module_to_llvm, submit_post_lto_module_to_llvm, submit_pre_lto_module_to_llvm,
42};
43use crate::common::{self, IntPredicate, RealPredicate, TypeKind};
44use crate::meth::load_vtable;
45use crate::mir::operand::OperandValue;
46use crate::mir::place::PlaceRef;
47use crate::traits::*;
48use crate::{
49 CachedModuleCodegen, CodegenLintLevels, CrateInfo, ModuleCodegen, ModuleKind, errors, meth, mir,
50};
51
52pub(crate) fn bin_op_to_icmp_predicate(op: BinOp, signed: bool) -> IntPredicate {
53 match (op, signed) {
54 (BinOp::Eq, _) => IntPredicate::IntEQ,
55 (BinOp::Ne, _) => IntPredicate::IntNE,
56 (BinOp::Lt, true) => IntPredicate::IntSLT,
57 (BinOp::Lt, false) => IntPredicate::IntULT,
58 (BinOp::Le, true) => IntPredicate::IntSLE,
59 (BinOp::Le, false) => IntPredicate::IntULE,
60 (BinOp::Gt, true) => IntPredicate::IntSGT,
61 (BinOp::Gt, false) => IntPredicate::IntUGT,
62 (BinOp::Ge, true) => IntPredicate::IntSGE,
63 (BinOp::Ge, false) => IntPredicate::IntUGE,
64 op => bug!("bin_op_to_icmp_predicate: expected comparison operator, found {:?}", op),
65 }
66}
67
68pub(crate) fn bin_op_to_fcmp_predicate(op: BinOp) -> RealPredicate {
69 match op {
70 BinOp::Eq => RealPredicate::RealOEQ,
71 BinOp::Ne => RealPredicate::RealUNE,
72 BinOp::Lt => RealPredicate::RealOLT,
73 BinOp::Le => RealPredicate::RealOLE,
74 BinOp::Gt => RealPredicate::RealOGT,
75 BinOp::Ge => RealPredicate::RealOGE,
76 op => bug!("bin_op_to_fcmp_predicate: expected comparison operator, found {:?}", op),
77 }
78}
79
80pub fn compare_simd_types<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
81 bx: &mut Bx,
82 lhs: Bx::Value,
83 rhs: Bx::Value,
84 t: Ty<'tcx>,
85 ret_ty: Bx::Type,
86 op: BinOp,
87) -> Bx::Value {
88 let signed = match t.kind() {
89 ty::Float(_) => {
90 let cmp = bin_op_to_fcmp_predicate(op);
91 let cmp = bx.fcmp(cmp, lhs, rhs);
92 return bx.sext(cmp, ret_ty);
93 }
94 ty::Uint(_) => false,
95 ty::Int(_) => true,
96 _ => bug!("compare_simd_types: invalid SIMD type"),
97 };
98
99 let cmp = bin_op_to_icmp_predicate(op, signed);
100 let cmp = bx.icmp(cmp, lhs, rhs);
101 bx.sext(cmp, ret_ty)
106}
107
108pub fn validate_trivial_unsize<'tcx>(
117 tcx: TyCtxt<'tcx>,
118 source_data: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
119 target_data: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
120) -> bool {
121 match (source_data.principal(), target_data.principal()) {
122 (Some(hr_source_principal), Some(hr_target_principal)) => {
123 let (infcx, param_env) =
124 tcx.infer_ctxt().build_with_typing_env(ty::TypingEnv::fully_monomorphized());
125 let universe = infcx.universe();
126 let ocx = ObligationCtxt::new(&infcx);
127 infcx.enter_forall(hr_target_principal, |target_principal| {
128 let source_principal = infcx.instantiate_binder_with_fresh_vars(
129 DUMMY_SP,
130 BoundRegionConversionTime::HigherRankedType,
131 hr_source_principal,
132 );
133 let Ok(()) = ocx.eq(
134 &ObligationCause::dummy(),
135 param_env,
136 target_principal,
137 source_principal,
138 ) else {
139 return false;
140 };
141 if !ocx.select_all_or_error().is_empty() {
142 return false;
143 }
144 infcx.leak_check(universe, None).is_ok()
145 })
146 }
147 (_, None) => true,
148 _ => false,
149 }
150}
151
152fn unsized_info<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
158 bx: &mut Bx,
159 source: Ty<'tcx>,
160 target: Ty<'tcx>,
161 old_info: Option<Bx::Value>,
162) -> Bx::Value {
163 let cx = bx.cx();
164 let (source, target) =
165 cx.tcx().struct_lockstep_tails_for_codegen(source, target, bx.typing_env());
166 match (source.kind(), target.kind()) {
167 (&ty::Array(_, len), &ty::Slice(_)) => cx.const_usize(
168 len.try_to_target_usize(cx.tcx()).expect("expected monomorphic const in codegen"),
169 ),
170 (&ty::Dynamic(data_a, _, src_dyn_kind), &ty::Dynamic(data_b, _, target_dyn_kind))
171 if src_dyn_kind == target_dyn_kind =>
172 {
173 let old_info =
174 old_info.expect("unsized_info: missing old info for trait upcasting coercion");
175 let b_principal_def_id = data_b.principal_def_id();
176 if data_a.principal_def_id() == b_principal_def_id || b_principal_def_id.is_none() {
177 debug_assert!(
186 validate_trivial_unsize(cx.tcx(), data_a, data_b),
187 "NOP unsize vtable changed principal trait ref: {data_a} -> {data_b}"
188 );
189
190 return old_info;
196 }
197
198 let vptr_entry_idx = cx.tcx().supertrait_vtable_slot((source, target));
201
202 if let Some(entry_idx) = vptr_entry_idx {
203 let ptr_size = bx.data_layout().pointer_size();
204 let vtable_byte_offset = u64::try_from(entry_idx).unwrap() * ptr_size.bytes();
205 load_vtable(bx, old_info, bx.type_ptr(), vtable_byte_offset, source, true)
206 } else {
207 old_info
208 }
209 }
210 (_, ty::Dynamic(data, _, _)) => meth::get_vtable(
211 cx,
212 source,
213 data.principal()
214 .map(|principal| bx.tcx().instantiate_bound_regions_with_erased(principal)),
215 ),
216 _ => bug!("unsized_info: invalid unsizing {:?} -> {:?}", source, target),
217 }
218}
219
220pub(crate) fn unsize_ptr<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
222 bx: &mut Bx,
223 src: Bx::Value,
224 src_ty: Ty<'tcx>,
225 dst_ty: Ty<'tcx>,
226 old_info: Option<Bx::Value>,
227) -> (Bx::Value, Bx::Value) {
228 debug!("unsize_ptr: {:?} => {:?}", src_ty, dst_ty);
229 match (src_ty.kind(), dst_ty.kind()) {
230 (&ty::Ref(_, a, _), &ty::Ref(_, b, _) | &ty::RawPtr(b, _))
231 | (&ty::RawPtr(a, _), &ty::RawPtr(b, _)) => {
232 assert_eq!(bx.cx().type_is_sized(a), old_info.is_none());
233 (src, unsized_info(bx, a, b, old_info))
234 }
235 (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
236 assert_eq!(def_a, def_b); let src_layout = bx.cx().layout_of(src_ty);
238 let dst_layout = bx.cx().layout_of(dst_ty);
239 if src_ty == dst_ty {
240 return (src, old_info.unwrap());
241 }
242 let mut result = None;
243 for i in 0..src_layout.fields.count() {
244 let src_f = src_layout.field(bx.cx(), i);
245 if src_f.is_1zst() {
246 continue;
248 }
249
250 assert_eq!(src_layout.fields.offset(i).bytes(), 0);
251 assert_eq!(dst_layout.fields.offset(i).bytes(), 0);
252 assert_eq!(src_layout.size, src_f.size);
253
254 let dst_f = dst_layout.field(bx.cx(), i);
255 assert_ne!(src_f.ty, dst_f.ty);
256 assert_eq!(result, None);
257 result = Some(unsize_ptr(bx, src, src_f.ty, dst_f.ty, old_info));
258 }
259 result.unwrap()
260 }
261 _ => bug!("unsize_ptr: called on bad types"),
262 }
263}
264
265pub(crate) fn coerce_unsized_into<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
268 bx: &mut Bx,
269 src: PlaceRef<'tcx, Bx::Value>,
270 dst: PlaceRef<'tcx, Bx::Value>,
271) {
272 let src_ty = src.layout.ty;
273 let dst_ty = dst.layout.ty;
274 match (src_ty.kind(), dst_ty.kind()) {
275 (&ty::Ref(..), &ty::Ref(..) | &ty::RawPtr(..)) | (&ty::RawPtr(..), &ty::RawPtr(..)) => {
276 let (base, info) = match bx.load_operand(src).val {
277 OperandValue::Pair(base, info) => unsize_ptr(bx, base, src_ty, dst_ty, Some(info)),
278 OperandValue::Immediate(base) => unsize_ptr(bx, base, src_ty, dst_ty, None),
279 OperandValue::Ref(..) | OperandValue::ZeroSized => bug!(),
280 };
281 OperandValue::Pair(base, info).store(bx, dst);
282 }
283
284 (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
285 assert_eq!(def_a, def_b); for i in def_a.variant(FIRST_VARIANT).fields.indices() {
288 let src_f = src.project_field(bx, i.as_usize());
289 let dst_f = dst.project_field(bx, i.as_usize());
290
291 if dst_f.layout.is_zst() {
292 continue;
294 }
295
296 if src_f.layout.ty == dst_f.layout.ty {
297 bx.typed_place_copy(dst_f.val, src_f.val, src_f.layout);
298 } else {
299 coerce_unsized_into(bx, src_f, dst_f);
300 }
301 }
302 }
303 _ => bug!("coerce_unsized_into: invalid coercion {:?} -> {:?}", src_ty, dst_ty,),
304 }
305}
306
307pub(crate) fn build_shift_expr_rhs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
323 bx: &mut Bx,
324 lhs: Bx::Value,
325 mut rhs: Bx::Value,
326 is_unchecked: bool,
327) -> Bx::Value {
328 let mut rhs_llty = bx.cx().val_ty(rhs);
330 let mut lhs_llty = bx.cx().val_ty(lhs);
331
332 let mask = common::shift_mask_val(bx, lhs_llty, rhs_llty, false);
333 if !is_unchecked {
334 rhs = bx.and(rhs, mask);
335 }
336
337 if bx.cx().type_kind(rhs_llty) == TypeKind::Vector {
338 rhs_llty = bx.cx().element_type(rhs_llty)
339 }
340 if bx.cx().type_kind(lhs_llty) == TypeKind::Vector {
341 lhs_llty = bx.cx().element_type(lhs_llty)
342 }
343 let rhs_sz = bx.cx().int_width(rhs_llty);
344 let lhs_sz = bx.cx().int_width(lhs_llty);
345 if lhs_sz < rhs_sz {
346 if is_unchecked { bx.unchecked_utrunc(rhs, lhs_llty) } else { bx.trunc(rhs, lhs_llty) }
347 } else if lhs_sz > rhs_sz {
348 assert!(lhs_sz <= 256);
355 bx.zext(rhs, lhs_llty)
356 } else {
357 rhs
358 }
359}
360
361pub fn wants_wasm_eh(sess: &Session) -> bool {
365 sess.target.is_like_wasm
366 && (sess.target.os != "emscripten" || sess.opts.unstable_opts.emscripten_wasm_eh)
367}
368
369pub fn wants_msvc_seh(sess: &Session) -> bool {
375 sess.target.is_like_msvc
376}
377
378pub(crate) fn wants_new_eh_instructions(sess: &Session) -> bool {
382 wants_wasm_eh(sess) || wants_msvc_seh(sess)
383}
384
385pub(crate) fn codegen_instance<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
386 cx: &'a Bx::CodegenCx,
387 instance: Instance<'tcx>,
388) {
389 info!("codegen_instance({})", instance);
393
394 mir::codegen_mir::<Bx>(cx, instance);
395}
396
397pub fn codegen_global_asm<'tcx, Cx>(cx: &mut Cx, item_id: ItemId)
398where
399 Cx: LayoutOf<'tcx, LayoutOfResult = TyAndLayout<'tcx>> + AsmCodegenMethods<'tcx>,
400{
401 let item = cx.tcx().hir_item(item_id);
402 if let rustc_hir::ItemKind::GlobalAsm { asm, .. } = item.kind {
403 let operands: Vec<_> = asm
404 .operands
405 .iter()
406 .map(|(op, op_sp)| match *op {
407 rustc_hir::InlineAsmOperand::Const { ref anon_const } => {
408 match cx.tcx().const_eval_poly(anon_const.def_id.to_def_id()) {
409 Ok(const_value) => {
410 let ty =
411 cx.tcx().typeck_body(anon_const.body).node_type(anon_const.hir_id);
412 let string = common::asm_const_to_str(
413 cx.tcx(),
414 *op_sp,
415 const_value,
416 cx.layout_of(ty),
417 );
418 GlobalAsmOperandRef::Const { string }
419 }
420 Err(ErrorHandled::Reported { .. }) => {
421 GlobalAsmOperandRef::Const { string: String::new() }
426 }
427 Err(ErrorHandled::TooGeneric(_)) => {
428 span_bug!(*op_sp, "asm const cannot be resolved; too generic")
429 }
430 }
431 }
432 rustc_hir::InlineAsmOperand::SymFn { expr } => {
433 let ty = cx.tcx().typeck(item_id.owner_id).expr_ty(expr);
434 let instance = match ty.kind() {
435 &ty::FnDef(def_id, args) => Instance::expect_resolve(
436 cx.tcx(),
437 ty::TypingEnv::fully_monomorphized(),
438 def_id,
439 args,
440 expr.span,
441 ),
442 _ => span_bug!(*op_sp, "asm sym is not a function"),
443 };
444
445 GlobalAsmOperandRef::SymFn { instance }
446 }
447 rustc_hir::InlineAsmOperand::SymStatic { path: _, def_id } => {
448 GlobalAsmOperandRef::SymStatic { def_id }
449 }
450 rustc_hir::InlineAsmOperand::In { .. }
451 | rustc_hir::InlineAsmOperand::Out { .. }
452 | rustc_hir::InlineAsmOperand::InOut { .. }
453 | rustc_hir::InlineAsmOperand::SplitInOut { .. }
454 | rustc_hir::InlineAsmOperand::Label { .. } => {
455 span_bug!(*op_sp, "invalid operand type for global_asm!")
456 }
457 })
458 .collect();
459
460 cx.codegen_global_asm(asm.template, &operands, asm.options, asm.line_spans);
461 } else {
462 span_bug!(item.span, "Mismatch between hir::Item type and MonoItem type")
463 }
464}
465
466pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
469 cx: &'a Bx::CodegenCx,
470 cgu: &CodegenUnit<'tcx>,
471) -> Option<Bx::Function> {
472 let (main_def_id, entry_type) = cx.tcx().entry_fn(())?;
473 let main_is_local = main_def_id.is_local();
474 let instance = Instance::mono(cx.tcx(), main_def_id);
475
476 if main_is_local {
477 if !cgu.contains_item(&MonoItem::Fn(instance)) {
480 return None;
481 }
482 } else if !cgu.is_primary() {
483 return None;
485 }
486
487 let main_llfn = cx.get_fn_addr(instance);
488
489 let entry_fn = create_entry_fn::<Bx>(cx, main_llfn, main_def_id, entry_type);
490 return Some(entry_fn);
491
492 fn create_entry_fn<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
493 cx: &'a Bx::CodegenCx,
494 rust_main: Bx::Value,
495 rust_main_def_id: DefId,
496 entry_type: EntryFnType,
497 ) -> Bx::Function {
498 let llfty = if cx.sess().target.os.contains("uefi") {
501 cx.type_func(&[cx.type_ptr(), cx.type_ptr()], cx.type_isize())
502 } else if cx.sess().target.main_needs_argc_argv {
503 cx.type_func(&[cx.type_int(), cx.type_ptr()], cx.type_int())
504 } else {
505 cx.type_func(&[], cx.type_int())
506 };
507
508 let main_ret_ty = cx.tcx().fn_sig(rust_main_def_id).no_bound_vars().unwrap().output();
509 let main_ret_ty = cx
515 .tcx()
516 .normalize_erasing_regions(cx.typing_env(), main_ret_ty.no_bound_vars().unwrap());
517
518 let Some(llfn) = cx.declare_c_main(llfty) else {
519 let span = cx.tcx().def_span(rust_main_def_id);
521 cx.tcx().dcx().emit_fatal(errors::MultipleMainFunctions { span });
522 };
523
524 cx.set_frame_pointer_type(llfn);
526 cx.apply_target_cpu_attr(llfn);
527
528 let llbb = Bx::append_block(cx, llfn, "top");
529 let mut bx = Bx::build(cx, llbb);
530
531 bx.insert_reference_to_gdb_debug_scripts_section_global();
532
533 let isize_ty = cx.type_isize();
534 let ptr_ty = cx.type_ptr();
535 let (arg_argc, arg_argv) = get_argc_argv(&mut bx);
536
537 let EntryFnType::Main { sigpipe } = entry_type;
538 let (start_fn, start_ty, args, instance) = {
539 let start_def_id = cx.tcx().require_lang_item(LangItem::Start, DUMMY_SP);
540 let start_instance = ty::Instance::expect_resolve(
541 cx.tcx(),
542 cx.typing_env(),
543 start_def_id,
544 cx.tcx().mk_args(&[main_ret_ty.into()]),
545 DUMMY_SP,
546 );
547 let start_fn = cx.get_fn_addr(start_instance);
548
549 let i8_ty = cx.type_i8();
550 let arg_sigpipe = bx.const_u8(sigpipe);
551
552 let start_ty = cx.type_func(&[cx.val_ty(rust_main), isize_ty, ptr_ty, i8_ty], isize_ty);
553 (
554 start_fn,
555 start_ty,
556 vec![rust_main, arg_argc, arg_argv, arg_sigpipe],
557 Some(start_instance),
558 )
559 };
560
561 let result = bx.call(start_ty, None, None, start_fn, &args, None, instance);
562 if cx.sess().target.os.contains("uefi") {
563 bx.ret(result);
564 } else {
565 let cast = bx.intcast(result, cx.type_int(), true);
566 bx.ret(cast);
567 }
568
569 llfn
570 }
571}
572
573fn get_argc_argv<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(bx: &mut Bx) -> (Bx::Value, Bx::Value) {
576 if bx.cx().sess().target.os.contains("uefi") {
577 let param_handle = bx.get_param(0);
579 let param_system_table = bx.get_param(1);
580 let ptr_size = bx.tcx().data_layout.pointer_size();
581 let ptr_align = bx.tcx().data_layout.pointer_align().abi;
582 let arg_argc = bx.const_int(bx.cx().type_isize(), 2);
583 let arg_argv = bx.alloca(2 * ptr_size, ptr_align);
584 bx.store(param_handle, arg_argv, ptr_align);
585 let arg_argv_el1 = bx.inbounds_ptradd(arg_argv, bx.const_usize(ptr_size.bytes()));
586 bx.store(param_system_table, arg_argv_el1, ptr_align);
587 (arg_argc, arg_argv)
588 } else if bx.cx().sess().target.main_needs_argc_argv {
589 let param_argc = bx.get_param(0);
591 let param_argv = bx.get_param(1);
592 let arg_argc = bx.intcast(param_argc, bx.cx().type_isize(), true);
593 let arg_argv = param_argv;
594 (arg_argc, arg_argv)
595 } else {
596 let arg_argc = bx.const_int(bx.cx().type_int(), 0);
598 let arg_argv = bx.const_null(bx.cx().type_ptr());
599 (arg_argc, arg_argv)
600 }
601}
602
603pub fn collect_debugger_visualizers_transitive(
607 tcx: TyCtxt<'_>,
608 visualizer_type: DebuggerVisualizerType,
609) -> BTreeSet<DebuggerVisualizerFile> {
610 tcx.debugger_visualizers(LOCAL_CRATE)
611 .iter()
612 .chain(
613 tcx.crates(())
614 .iter()
615 .filter(|&cnum| {
616 let used_crate_source = tcx.used_crate_source(*cnum);
617 used_crate_source.rlib.is_some() || used_crate_source.rmeta.is_some()
618 })
619 .flat_map(|&cnum| tcx.debugger_visualizers(cnum)),
620 )
621 .filter(|visualizer| visualizer.visualizer_type == visualizer_type)
622 .cloned()
623 .collect::<BTreeSet<_>>()
624}
625
626pub fn allocator_kind_for_codegen(tcx: TyCtxt<'_>) -> Option<AllocatorKind> {
630 let any_dynamic_crate = tcx.dependency_formats(()).iter().any(|(_, list)| {
637 use rustc_middle::middle::dependency_format::Linkage;
638 list.iter().any(|&linkage| linkage == Linkage::Dynamic)
639 });
640 if any_dynamic_crate { None } else { tcx.allocator_kind(()) }
641}
642
643pub fn codegen_crate<B: ExtraBackendMethods>(
644 backend: B,
645 tcx: TyCtxt<'_>,
646 target_cpu: String,
647) -> OngoingCodegen<B> {
648 if tcx.sess.opts.unstable_opts.no_codegen || !tcx.sess.opts.output_types.should_codegen() {
650 let ongoing_codegen = start_async_codegen(backend, tcx, target_cpu);
651
652 ongoing_codegen.codegen_finished(tcx);
653
654 ongoing_codegen.check_for_errors(tcx.sess);
655
656 return ongoing_codegen;
657 }
658
659 if tcx.sess.target.need_explicit_cpu && tcx.sess.opts.cg.target_cpu.is_none() {
660 tcx.dcx().emit_fatal(errors::CpuRequired);
662 }
663
664 let cgu_name_builder = &mut CodegenUnitNameBuilder::new(tcx);
665
666 let MonoItemPartitions { codegen_units, autodiff_items, .. } =
669 tcx.collect_and_partition_mono_items(());
670 let autodiff_fncs = autodiff_items.to_vec();
671
672 if tcx.dep_graph.is_fully_enabled() {
678 for cgu in codegen_units {
679 tcx.ensure_ok().codegen_unit(cgu.name());
680 }
681 }
682
683 let ongoing_codegen = start_async_codegen(backend.clone(), tcx, target_cpu);
684
685 if let Some(kind) = allocator_kind_for_codegen(tcx) {
687 let llmod_id =
688 cgu_name_builder.build_cgu_name(LOCAL_CRATE, &["crate"], Some("allocator")).to_string();
689 let module_llvm = tcx.sess.time("write_allocator_module", || {
690 backend.codegen_allocator(
691 tcx,
692 &llmod_id,
693 kind,
694 tcx.alloc_error_handler_kind(()).unwrap(),
697 )
698 });
699
700 ongoing_codegen.wait_for_signal_to_codegen_item();
701 ongoing_codegen.check_for_errors(tcx.sess);
702
703 let cost = 0;
705 submit_codegened_module_to_llvm(
706 &backend,
707 &ongoing_codegen.coordinator.sender,
708 ModuleCodegen::new_allocator(llmod_id, module_llvm),
709 cost,
710 );
711 }
712
713 if !autodiff_fncs.is_empty() {
714 ongoing_codegen.submit_autodiff_items(autodiff_fncs);
715 }
716
717 let codegen_units: Vec<_> = {
729 let mut sorted_cgus = codegen_units.iter().collect::<Vec<_>>();
730 sorted_cgus.sort_by_key(|cgu| cmp::Reverse(cgu.size_estimate()));
731
732 let (first_half, second_half) = sorted_cgus.split_at(sorted_cgus.len() / 2);
733 first_half.iter().interleave(second_half.iter().rev()).copied().collect()
734 };
735
736 let cgu_reuse = tcx.sess.time("find_cgu_reuse", || {
738 codegen_units.iter().map(|cgu| determine_cgu_reuse(tcx, cgu)).collect::<Vec<_>>()
739 });
740
741 crate::assert_module_sources::assert_module_sources(tcx, &|cgu_reuse_tracker| {
742 for (i, cgu) in codegen_units.iter().enumerate() {
743 let cgu_reuse = cgu_reuse[i];
744 cgu_reuse_tracker.set_actual_reuse(cgu.name().as_str(), cgu_reuse);
745 }
746 });
747
748 let mut total_codegen_time = Duration::new(0, 0);
749 let start_rss = tcx.sess.opts.unstable_opts.time_passes.then(|| get_resident_set_size());
750
751 let mut pre_compiled_cgus = if tcx.sess.threads() > 1 {
762 tcx.sess.time("compile_first_CGU_batch", || {
763 let cgus: Vec<_> = cgu_reuse
765 .iter()
766 .enumerate()
767 .filter(|&(_, reuse)| reuse == &CguReuse::No)
768 .take(tcx.sess.threads())
769 .collect();
770
771 let start_time = Instant::now();
773
774 let pre_compiled_cgus = par_map(cgus, |(i, _)| {
775 let module = backend.compile_codegen_unit(tcx, codegen_units[i].name());
776 (i, IntoDynSyncSend(module))
777 });
778
779 total_codegen_time += start_time.elapsed();
780
781 pre_compiled_cgus
782 })
783 } else {
784 FxHashMap::default()
785 };
786
787 for (i, cgu) in codegen_units.iter().enumerate() {
788 ongoing_codegen.wait_for_signal_to_codegen_item();
789 ongoing_codegen.check_for_errors(tcx.sess);
790
791 let cgu_reuse = cgu_reuse[i];
792
793 match cgu_reuse {
794 CguReuse::No => {
795 let (module, cost) = if let Some(cgu) = pre_compiled_cgus.remove(&i) {
796 cgu.0
797 } else {
798 let start_time = Instant::now();
799 let module = backend.compile_codegen_unit(tcx, cgu.name());
800 total_codegen_time += start_time.elapsed();
801 module
802 };
803 tcx.dcx().abort_if_errors();
807
808 submit_codegened_module_to_llvm(
809 &backend,
810 &ongoing_codegen.coordinator.sender,
811 module,
812 cost,
813 );
814 }
815 CguReuse::PreLto => {
816 submit_pre_lto_module_to_llvm(
817 &backend,
818 tcx,
819 &ongoing_codegen.coordinator.sender,
820 CachedModuleCodegen {
821 name: cgu.name().to_string(),
822 source: cgu.previous_work_product(tcx),
823 },
824 );
825 }
826 CguReuse::PostLto => {
827 submit_post_lto_module_to_llvm(
828 &backend,
829 &ongoing_codegen.coordinator.sender,
830 CachedModuleCodegen {
831 name: cgu.name().to_string(),
832 source: cgu.previous_work_product(tcx),
833 },
834 );
835 }
836 }
837 }
838
839 ongoing_codegen.codegen_finished(tcx);
840
841 if tcx.sess.opts.unstable_opts.time_passes {
844 let end_rss = get_resident_set_size();
845
846 print_time_passes_entry(
847 "codegen_to_LLVM_IR",
848 total_codegen_time,
849 start_rss.unwrap(),
850 end_rss,
851 tcx.sess.opts.unstable_opts.time_passes_format,
852 );
853 }
854
855 ongoing_codegen.check_for_errors(tcx.sess);
856 ongoing_codegen
857}
858
859pub fn is_call_from_compiler_builtins_to_upstream_monomorphization<'tcx>(
869 tcx: TyCtxt<'tcx>,
870 instance: Instance<'tcx>,
871) -> bool {
872 fn is_llvm_intrinsic(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
873 if let Some(name) = tcx.codegen_fn_attrs(def_id).link_name {
874 name.as_str().starts_with("llvm.")
875 } else {
876 false
877 }
878 }
879
880 let def_id = instance.def_id();
881 !def_id.is_local()
882 && tcx.is_compiler_builtins(LOCAL_CRATE)
883 && !is_llvm_intrinsic(tcx, def_id)
884 && !tcx.should_codegen_locally(instance)
885}
886
887impl CrateInfo {
888 pub fn new(tcx: TyCtxt<'_>, target_cpu: String) -> CrateInfo {
889 let crate_types = tcx.crate_types().to_vec();
890 let exported_symbols = crate_types
891 .iter()
892 .map(|&c| (c, crate::back::linker::exported_symbols(tcx, c)))
893 .collect();
894 let linked_symbols =
895 crate_types.iter().map(|&c| (c, crate::back::linker::linked_symbols(tcx, c))).collect();
896 let local_crate_name = tcx.crate_name(LOCAL_CRATE);
897 let crate_attrs = tcx.hir_attrs(rustc_hir::CRATE_HIR_ID);
898 let subsystem =
899 ast::attr::first_attr_value_str_by_name(crate_attrs, sym::windows_subsystem);
900 let windows_subsystem = subsystem.map(|subsystem| {
901 if subsystem != sym::windows && subsystem != sym::console {
902 tcx.dcx().emit_fatal(errors::InvalidWindowsSubsystem { subsystem });
903 }
904 subsystem.to_string()
905 });
906
907 let mut compiler_builtins = None;
916 let mut used_crates: Vec<_> = tcx
917 .postorder_cnums(())
918 .iter()
919 .rev()
920 .copied()
921 .filter(|&cnum| {
922 let link = !tcx.dep_kind(cnum).macros_only();
923 if link && tcx.is_compiler_builtins(cnum) {
924 compiler_builtins = Some(cnum);
925 return false;
926 }
927 link
928 })
929 .collect();
930 used_crates.extend(compiler_builtins);
932
933 let crates = tcx.crates(());
934 let n_crates = crates.len();
935 let mut info = CrateInfo {
936 target_cpu,
937 target_features: tcx.global_backend_features(()).clone(),
938 crate_types,
939 exported_symbols,
940 linked_symbols,
941 local_crate_name,
942 compiler_builtins,
943 profiler_runtime: None,
944 is_no_builtins: Default::default(),
945 native_libraries: Default::default(),
946 used_libraries: tcx.native_libraries(LOCAL_CRATE).iter().map(Into::into).collect(),
947 crate_name: UnordMap::with_capacity(n_crates),
948 used_crates,
949 used_crate_source: UnordMap::with_capacity(n_crates),
950 dependency_formats: Arc::clone(tcx.dependency_formats(())),
951 windows_subsystem,
952 natvis_debugger_visualizers: Default::default(),
953 lint_levels: CodegenLintLevels::from_tcx(tcx),
954 metadata_symbol: exported_symbols::metadata_symbol_name(tcx),
955 };
956
957 info.native_libraries.reserve(n_crates);
958
959 for &cnum in crates.iter() {
960 info.native_libraries
961 .insert(cnum, tcx.native_libraries(cnum).iter().map(Into::into).collect());
962 info.crate_name.insert(cnum, tcx.crate_name(cnum));
963
964 let used_crate_source = tcx.used_crate_source(cnum);
965 info.used_crate_source.insert(cnum, Arc::clone(used_crate_source));
966 if tcx.is_profiler_runtime(cnum) {
967 info.profiler_runtime = Some(cnum);
968 }
969 if tcx.is_no_builtins(cnum) {
970 info.is_no_builtins.insert(cnum);
971 }
972 }
973
974 let target = &tcx.sess.target;
983 if !are_upstream_rust_objects_already_included(tcx.sess) {
984 let add_prefix = match (target.is_like_windows, target.arch.as_ref()) {
985 (true, "x86") => |name: String, _: SymbolExportKind| format!("_{name}"),
986 (true, "arm64ec") => {
987 |name: String, export_kind: SymbolExportKind| match export_kind {
989 SymbolExportKind::Text => format!("#{name}"),
990 _ => name,
991 }
992 }
993 _ => |name: String, _: SymbolExportKind| name,
994 };
995 let missing_weak_lang_items: FxIndexSet<(Symbol, SymbolExportKind)> = info
996 .used_crates
997 .iter()
998 .flat_map(|&cnum| tcx.missing_lang_items(cnum))
999 .filter(|l| l.is_weak())
1000 .filter_map(|&l| {
1001 let name = l.link_name()?;
1002 let export_kind = match l.target() {
1003 Target::Fn => SymbolExportKind::Text,
1004 Target::Static => SymbolExportKind::Data,
1005 _ => bug!(
1006 "Don't know what the export kind is for lang item of kind {:?}",
1007 l.target()
1008 ),
1009 };
1010 lang_items::required(tcx, l).then_some((name, export_kind))
1011 })
1012 .collect();
1013
1014 #[allow(rustc::potential_query_instability)]
1017 info.linked_symbols
1018 .iter_mut()
1019 .filter(|(crate_type, _)| {
1020 !matches!(crate_type, CrateType::Rlib | CrateType::Staticlib)
1021 })
1022 .for_each(|(_, linked_symbols)| {
1023 let mut symbols = missing_weak_lang_items
1024 .iter()
1025 .map(|(item, export_kind)| {
1026 (
1027 add_prefix(
1028 mangle_internal_symbol(tcx, item.as_str()),
1029 *export_kind,
1030 ),
1031 *export_kind,
1032 )
1033 })
1034 .collect::<Vec<_>>();
1035 symbols.sort_unstable_by(|a, b| a.0.cmp(&b.0));
1036 linked_symbols.extend(symbols);
1037 });
1038 }
1039
1040 let embed_visualizers = tcx.crate_types().iter().any(|&crate_type| match crate_type {
1041 CrateType::Executable | CrateType::Dylib | CrateType::Cdylib | CrateType::Sdylib => {
1042 true
1045 }
1046 CrateType::ProcMacro => {
1047 false
1051 }
1052 CrateType::Staticlib | CrateType::Rlib => {
1053 false
1056 }
1057 });
1058
1059 if target.is_like_msvc && embed_visualizers {
1060 info.natvis_debugger_visualizers =
1061 collect_debugger_visualizers_transitive(tcx, DebuggerVisualizerType::Natvis);
1062 }
1063
1064 info
1065 }
1066}
1067
1068pub(crate) fn provide(providers: &mut Providers) {
1069 providers.backend_optimization_level = |tcx, cratenum| {
1070 let for_speed = match tcx.sess.opts.optimize {
1071 config::OptLevel::No => return config::OptLevel::No,
1078 config::OptLevel::Less => return config::OptLevel::Less,
1080 config::OptLevel::More => return config::OptLevel::More,
1081 config::OptLevel::Aggressive => return config::OptLevel::Aggressive,
1082 config::OptLevel::Size => config::OptLevel::More,
1085 config::OptLevel::SizeMin => config::OptLevel::More,
1086 };
1087
1088 let defids = tcx.collect_and_partition_mono_items(cratenum).all_mono_items;
1089
1090 let any_for_speed = defids.items().any(|id| {
1091 let CodegenFnAttrs { optimize, .. } = tcx.codegen_fn_attrs(*id);
1092 matches!(optimize, OptimizeAttr::Speed)
1093 });
1094
1095 if any_for_speed {
1096 return for_speed;
1097 }
1098
1099 tcx.sess.opts.optimize
1100 };
1101}
1102
1103pub fn determine_cgu_reuse<'tcx>(tcx: TyCtxt<'tcx>, cgu: &CodegenUnit<'tcx>) -> CguReuse {
1104 if !tcx.dep_graph.is_fully_enabled() {
1105 return CguReuse::No;
1106 }
1107
1108 let work_product_id = &cgu.work_product_id();
1109 if tcx.dep_graph.previous_work_product(work_product_id).is_none() {
1110 return CguReuse::No;
1113 }
1114
1115 let dep_node = cgu.codegen_dep_node(tcx);
1122 tcx.dep_graph.assert_dep_node_not_yet_allocated_in_current_session(&dep_node, || {
1123 format!(
1124 "CompileCodegenUnit dep-node for CGU `{}` already exists before marking.",
1125 cgu.name()
1126 )
1127 });
1128
1129 if tcx.try_mark_green(&dep_node) {
1130 match compute_per_cgu_lto_type(
1134 &tcx.sess.lto(),
1135 &tcx.sess.opts,
1136 tcx.crate_types(),
1137 ModuleKind::Regular,
1138 ) {
1139 ComputedLtoType::No => CguReuse::PostLto,
1140 _ => CguReuse::PreLto,
1141 }
1142 } else {
1143 CguReuse::No
1144 }
1145}