1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Partitioning Codegen Units for Incremental Compilation
12 //! ======================================================
14 //! The task of this module is to take the complete set of translation items of
15 //! a crate and produce a set of codegen units from it, where a codegen unit
16 //! is a named set of (translation-item, linkage) pairs. That is, this module
17 //! decides which translation item appears in which codegen units with which
18 //! linkage. The following paragraphs describe some of the background on the
19 //! partitioning scheme.
21 //! The most important opportunity for saving on compilation time with
22 //! incremental compilation is to avoid re-translating and re-optimizing code.
23 //! Since the unit of translation and optimization for LLVM is "modules" or, how
24 //! we call them "codegen units", the particulars of how much time can be saved
25 //! by incremental compilation are tightly linked to how the output program is
26 //! partitioned into these codegen units prior to passing it to LLVM --
27 //! especially because we have to treat codegen units as opaque entities once
28 //! they are created: There is no way for us to incrementally update an existing
29 //! LLVM module and so we have to build any such module from scratch if it was
30 //! affected by some change in the source code.
32 //! From that point of view it would make sense to maximize the number of
33 //! codegen units by, for example, putting each function into its own module.
34 //! That way only those modules would have to be re-compiled that were actually
35 //! affected by some change, minimizing the number of functions that could have
36 //! been re-used but just happened to be located in a module that is
39 //! However, since LLVM optimization does not work across module boundaries,
40 //! using such a highly granular partitioning would lead to very slow runtime
41 //! code since it would effectively prohibit inlining and other inter-procedure
42 //! optimizations. We want to avoid that as much as possible.
44 //! Thus we end up with a trade-off: The bigger the codegen units, the better
45 //! LLVM's optimizer can do its work, but also the smaller the compilation time
46 //! reduction we get from incremental compilation.
48 //! Ideally, we would create a partitioning such that there are few big codegen
49 //! units with few interdependencies between them. For now though, we use the
50 //! following heuristic to determine the partitioning:
52 //! - There are two codegen units for every source-level module:
53 //! - One for "stable", that is non-generic, code
54 //! - One for more "volatile" code, i.e. monomorphized instances of functions
55 //! defined in that module
57 //! In order to see why this heuristic makes sense, let's take a look at when a
58 //! codegen unit can get invalidated:
60 //! 1. The most straightforward case is when the BODY of a function or global
61 //! changes. Then any codegen unit containing the code for that item has to be
62 //! re-compiled. Note that this includes all codegen units where the function
65 //! 2. The next case is when the SIGNATURE of a function or global changes. In
66 //! this case, all codegen units containing a REFERENCE to that item have to be
67 //! re-compiled. This is a superset of case 1.
69 //! 3. The final and most subtle case is when a REFERENCE to a generic function
70 //! is added or removed somewhere. Even though the definition of the function
71 //! might be unchanged, a new REFERENCE might introduce a new monomorphized
72 //! instance of this function which has to be placed and compiled somewhere.
73 //! Conversely, when removing a REFERENCE, it might have been the last one with
74 //! that particular set of generic arguments and thus we have to remove it.
76 //! From the above we see that just using one codegen unit per source-level
77 //! module is not such a good idea, since just adding a REFERENCE to some
78 //! generic item somewhere else would invalidate everything within the module
79 //! containing the generic item. The heuristic above reduces this detrimental
80 //! side-effect of references a little by at least not touching the non-generic
81 //! code of the module.
83 //! A Note on Inlining
84 //! ------------------
85 //! As briefly mentioned above, in order for LLVM to be able to inline a
86 //! function call, the body of the function has to be available in the LLVM
87 //! module where the call is made. This has a few consequences for partitioning:
89 //! - The partitioning algorithm has to take care of placing functions into all
90 //! codegen units where they should be available for inlining. It also has to
91 //! decide on the correct linkage for these functions.
93 //! - The partitioning algorithm has to know which functions are likely to get
94 //! inlined, so it can distribute function instantiations accordingly. Since
95 //! there is no way of knowing for sure which functions LLVM will decide to
96 //! inline in the end, we apply a heuristic here: Only functions marked with
97 //! `#[inline]` are considered for inlining by the partitioner. The current
98 //! implementation will not try to determine if a function is likely to be
99 //! inlined by looking at the functions definition.
101 //! Note though that as a side-effect of creating a codegen units per
102 //! source-level module, functions from the same module will be available for
103 //! inlining, even when they are not marked #[inline].
105 use monomorphize::collector::InliningMap;
106 use rustc::dep_graph::WorkProductId;
107 use rustc::hir::def_id::DefId;
108 use rustc::hir::map::DefPathData;
109 use rustc::mir::mono::{Linkage, Visibility};
110 use rustc::middle::exported_symbols::SymbolExportLevel;
111 use rustc::ty::{self, TyCtxt, InstanceDef};
112 use rustc::ty::item_path::characteristic_def_id_of_type;
113 use rustc::util::nodemap::{FxHashMap, FxHashSet};
114 use std::collections::hash_map::Entry;
116 use syntax::ast::NodeId;
117 use syntax::symbol::{Symbol, InternedString};
118 use rustc::mir::mono::MonoItem;
119 use monomorphize::item::{MonoItemExt, InstantiationMode};
121 pub use rustc::mir::mono::CodegenUnit;
123 pub enum PartitioningStrategy {
124 /// Generate one codegen unit per source-level module.
127 /// Partition the whole crate into a fixed number of codegen units.
128 FixedUnitCount(usize)
131 pub trait CodegenUnitExt<'tcx> {
132 fn as_codegen_unit(&self) -> &CodegenUnit<'tcx>;
134 fn contains_item(&self, item: &MonoItem<'tcx>) -> bool {
135 self.items().contains_key(item)
138 fn name<'a>(&'a self) -> &'a InternedString
141 &self.as_codegen_unit().name()
144 fn items(&self) -> &FxHashMap<MonoItem<'tcx>, (Linkage, Visibility)> {
145 &self.as_codegen_unit().items()
148 fn work_product_id(&self) -> WorkProductId {
149 WorkProductId::from_cgu_name(&self.name().as_str())
152 fn items_in_deterministic_order<'a>(&self,
153 tcx: TyCtxt<'a, 'tcx, 'tcx>)
154 -> Vec<(MonoItem<'tcx>,
155 (Linkage, Visibility))> {
156 // The codegen tests rely on items being process in the same order as
157 // they appear in the file, so for local items, we sort by node_id first
158 #[derive(PartialEq, Eq, PartialOrd, Ord)]
159 pub struct ItemSortKey(Option<NodeId>, ty::SymbolName);
161 fn item_sort_key<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
162 item: MonoItem<'tcx>) -> ItemSortKey {
163 ItemSortKey(match item {
164 MonoItem::Fn(ref instance) => {
166 // We only want to take NodeIds of user-defined
167 // instances into account. The others don't matter for
168 // the codegen tests and can even make item order
170 InstanceDef::Item(def_id) => {
171 tcx.hir.as_local_node_id(def_id)
173 InstanceDef::Intrinsic(..) |
174 InstanceDef::FnPtrShim(..) |
175 InstanceDef::Virtual(..) |
176 InstanceDef::ClosureOnceShim { .. } |
177 InstanceDef::DropGlue(..) |
178 InstanceDef::CloneShim(..) => {
183 MonoItem::Static(def_id) => {
184 tcx.hir.as_local_node_id(def_id)
186 MonoItem::GlobalAsm(node_id) => {
189 }, item.symbol_name(tcx))
192 let mut items: Vec<_> = self.items().iter().map(|(&i, &l)| (i, l)).collect();
193 items.sort_by_cached_key(|&(i, _)| item_sort_key(tcx, i));
198 impl<'tcx> CodegenUnitExt<'tcx> for CodegenUnit<'tcx> {
199 fn as_codegen_unit(&self) -> &CodegenUnit<'tcx> {
204 // Anything we can't find a proper codegen unit for goes into this.
205 fn fallback_cgu_name(tcx: TyCtxt) -> InternedString {
206 const FALLBACK_CODEGEN_UNIT: &'static str = "__rustc_fallback_codegen_unit";
208 if tcx.sess.opts.debugging_opts.human_readable_cgu_names {
209 Symbol::intern(FALLBACK_CODEGEN_UNIT).as_interned_str()
211 Symbol::intern(&CodegenUnit::mangle_name(FALLBACK_CODEGEN_UNIT)).as_interned_str()
216 pub fn partition<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
218 strategy: PartitioningStrategy,
219 inlining_map: &InliningMap<'tcx>)
220 -> Vec<CodegenUnit<'tcx>>
221 where I: Iterator<Item = MonoItem<'tcx>>
223 // In the first step, we place all regular translation items into their
224 // respective 'home' codegen unit. Regular translation items are all
225 // functions and statics defined in the local crate.
226 let mut initial_partitioning = place_root_translation_items(tcx,
229 initial_partitioning.codegen_units.iter_mut().for_each(|cgu| cgu.estimate_size(&tcx));
231 debug_dump(tcx, "INITIAL PARTITIONING:", initial_partitioning.codegen_units.iter());
233 // If the partitioning should produce a fixed count of codegen units, merge
234 // until that count is reached.
235 if let PartitioningStrategy::FixedUnitCount(count) = strategy {
236 merge_codegen_units(&mut initial_partitioning, count, &tcx.crate_name.as_str());
238 debug_dump(tcx, "POST MERGING:", initial_partitioning.codegen_units.iter());
241 // In the next step, we use the inlining map to determine which additional
242 // translation items have to go into each codegen unit. These additional
243 // translation items can be drop-glue, functions from external crates, and
244 // local functions the definition of which is marked with #[inline].
245 let mut post_inlining = place_inlined_translation_items(initial_partitioning,
248 post_inlining.codegen_units.iter_mut().for_each(|cgu| cgu.estimate_size(&tcx));
250 debug_dump(tcx, "POST INLINING:", post_inlining.codegen_units.iter());
252 // Next we try to make as many symbols "internal" as possible, so LLVM has
253 // more freedom to optimize.
254 if !tcx.sess.opts.cg.link_dead_code {
255 internalize_symbols(tcx, &mut post_inlining, inlining_map);
258 // Finally, sort by codegen unit name, so that we get deterministic results
259 let PostInliningPartitioning {
260 codegen_units: mut result,
261 trans_item_placements: _,
262 internalization_candidates: _,
265 result.sort_by(|cgu1, cgu2| {
266 cgu1.name().cmp(cgu2.name())
272 struct PreInliningPartitioning<'tcx> {
273 codegen_units: Vec<CodegenUnit<'tcx>>,
274 roots: FxHashSet<MonoItem<'tcx>>,
275 internalization_candidates: FxHashSet<MonoItem<'tcx>>,
278 /// For symbol internalization, we need to know whether a symbol/trans-item is
279 /// accessed from outside the codegen unit it is defined in. This type is used
280 /// to keep track of that.
281 #[derive(Clone, PartialEq, Eq, Debug)]
282 enum TransItemPlacement {
283 SingleCgu { cgu_name: InternedString },
287 struct PostInliningPartitioning<'tcx> {
288 codegen_units: Vec<CodegenUnit<'tcx>>,
289 trans_item_placements: FxHashMap<MonoItem<'tcx>, TransItemPlacement>,
290 internalization_candidates: FxHashSet<MonoItem<'tcx>>,
293 fn place_root_translation_items<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
295 -> PreInliningPartitioning<'tcx>
296 where I: Iterator<Item = MonoItem<'tcx>>
298 let mut roots = FxHashSet();
299 let mut codegen_units = FxHashMap();
300 let is_incremental_build = tcx.sess.opts.incremental.is_some();
301 let mut internalization_candidates = FxHashSet();
303 // Determine if monomorphizations instantiated in this crate will be made
304 // available to downstream crates. This depends on whether we are in
305 // share-generics mode and whether the current crate can even have
306 // downstream crates.
307 let export_generics = tcx.share_generics() &&
308 tcx.local_crate_exports_generics();
310 for trans_item in trans_items {
311 match trans_item.instantiation_mode(tcx) {
312 InstantiationMode::GloballyShared { .. } => {}
313 InstantiationMode::LocalCopy => continue,
316 let characteristic_def_id = characteristic_def_id_of_trans_item(tcx, trans_item);
317 let is_volatile = is_incremental_build &&
318 trans_item.is_generic_fn();
320 let codegen_unit_name = match characteristic_def_id {
321 Some(def_id) => compute_codegen_unit_name(tcx, def_id, is_volatile),
322 None => fallback_cgu_name(tcx),
325 let make_codegen_unit = || {
326 CodegenUnit::new(codegen_unit_name.clone())
329 let codegen_unit = codegen_units.entry(codegen_unit_name.clone())
330 .or_insert_with(make_codegen_unit);
332 let mut can_be_internalized = true;
333 let default_visibility = |id: DefId, is_generic: bool| {
334 if !tcx.sess.target.target.options.default_hidden_visibility {
335 return Visibility::Default
338 // Generic functions never have export level C
340 return Visibility::Hidden
343 // Things with export level C don't get instantiated in downstream
346 return Visibility::Hidden
349 if let Some(&SymbolExportLevel::C) = tcx.reachable_non_generics(id.krate)
356 let (linkage, mut visibility) = match trans_item.explicit_linkage(tcx) {
357 Some(explicit_linkage) => (explicit_linkage, Visibility::Default),
360 MonoItem::Fn(ref instance) => {
361 let visibility = match instance.def {
362 InstanceDef::Item(def_id) => {
363 let is_generic = instance.substs
368 // The `start_fn` lang item is actually a
369 // monomorphized instance of a function in the
370 // standard library, used for the `main`
371 // function. We don't want to export it so we
372 // tag it with `Hidden` visibility but this
373 // symbol is only referenced from the actual
374 // `main` symbol which we unfortunately don't
375 // know anything about during
376 // partitioning/collection. As a result we
377 // forcibly keep this symbol out of the
378 // `internalization_candidates` set.
380 // FIXME: eventually we don't want to always
381 // force this symbol to have hidden
382 // visibility, it should indeed be a candidate
383 // for internalization, but we have to
384 // understand that it's referenced from the
385 // `main` symbol we'll generate later.
386 if tcx.lang_items().start_fn() == Some(def_id) {
387 can_be_internalized = false;
389 } else if def_id.is_local() {
392 if tcx.is_unreachable_local_definition(def_id) {
393 // This instance cannot be used
394 // from another crate.
397 // This instance might be useful in
398 // a downstream crate.
399 can_be_internalized = false;
400 default_visibility(def_id, true)
403 // We are not exporting generics or
404 // the definition is not reachable
405 // for downstream crates, we can
406 // internalize its instantiations.
410 // This isn't a generic function.
411 if tcx.is_reachable_non_generic(def_id) {
412 can_be_internalized = false;
413 debug_assert!(!is_generic);
414 default_visibility(def_id, false)
420 // This is an upstream DefId.
421 if export_generics && is_generic {
422 // If it is a upstream monomorphization
423 // and we export generics, we must make
424 // it available to downstream crates.
425 can_be_internalized = false;
426 default_visibility(def_id, true)
432 InstanceDef::FnPtrShim(..) |
433 InstanceDef::Virtual(..) |
434 InstanceDef::Intrinsic(..) |
435 InstanceDef::ClosureOnceShim { .. } |
436 InstanceDef::DropGlue(..) |
437 InstanceDef::CloneShim(..) => {
441 (Linkage::External, visibility)
443 MonoItem::Static(def_id) => {
444 let visibility = if tcx.is_reachable_non_generic(def_id) {
445 can_be_internalized = false;
446 default_visibility(def_id, false)
450 (Linkage::External, visibility)
452 MonoItem::GlobalAsm(node_id) => {
453 let def_id = tcx.hir.local_def_id(node_id);
454 let visibility = if tcx.is_reachable_non_generic(def_id) {
455 can_be_internalized = false;
456 default_visibility(def_id, false)
460 (Linkage::External, visibility)
465 if visibility == Visibility::Hidden && can_be_internalized {
466 internalization_candidates.insert(trans_item);
469 codegen_unit.items_mut().insert(trans_item, (linkage, visibility));
470 roots.insert(trans_item);
473 // always ensure we have at least one CGU; otherwise, if we have a
474 // crate with just types (for example), we could wind up with no CGU
475 if codegen_units.is_empty() {
476 let codegen_unit_name = fallback_cgu_name(tcx);
477 codegen_units.insert(codegen_unit_name.clone(),
478 CodegenUnit::new(codegen_unit_name.clone()));
481 PreInliningPartitioning {
482 codegen_units: codegen_units.into_iter()
483 .map(|(_, codegen_unit)| codegen_unit)
486 internalization_candidates,
490 fn merge_codegen_units<'tcx>(initial_partitioning: &mut PreInliningPartitioning<'tcx>,
491 target_cgu_count: usize,
493 assert!(target_cgu_count >= 1);
494 let codegen_units = &mut initial_partitioning.codegen_units;
496 // Note that at this point in time the `codegen_units` here may not be in a
497 // deterministic order (but we know they're deterministically the same set).
498 // We want this merging to produce a deterministic ordering of codegen units
501 // Due to basically how we've implemented the merging below (merge the two
502 // smallest into each other) we're sure to start off with a deterministic
503 // order (sorted by name). This'll mean that if two cgus have the same size
504 // the stable sort below will keep everything nice and deterministic.
505 codegen_units.sort_by_key(|cgu| cgu.name().clone());
507 // Merge the two smallest codegen units until the target size is reached.
508 while codegen_units.len() > target_cgu_count {
509 // Sort small cgus to the back
510 codegen_units.sort_by_cached_key(|cgu| cmp::Reverse(cgu.size_estimate()));
511 let mut smallest = codegen_units.pop().unwrap();
512 let second_smallest = codegen_units.last_mut().unwrap();
514 second_smallest.modify_size_estimate(smallest.size_estimate());
515 for (k, v) in smallest.items_mut().drain() {
516 second_smallest.items_mut().insert(k, v);
520 for (index, cgu) in codegen_units.iter_mut().enumerate() {
521 cgu.set_name(numbered_codegen_unit_name(crate_name, index));
525 fn place_inlined_translation_items<'tcx>(initial_partitioning: PreInliningPartitioning<'tcx>,
526 inlining_map: &InliningMap<'tcx>)
527 -> PostInliningPartitioning<'tcx> {
528 let mut new_partitioning = Vec::new();
529 let mut trans_item_placements = FxHashMap();
531 let PreInliningPartitioning {
532 codegen_units: initial_cgus,
534 internalization_candidates,
535 } = initial_partitioning;
537 let single_codegen_unit = initial_cgus.len() == 1;
539 for old_codegen_unit in initial_cgus {
540 // Collect all items that need to be available in this codegen unit
541 let mut reachable = FxHashSet();
542 for root in old_codegen_unit.items().keys() {
543 follow_inlining(*root, inlining_map, &mut reachable);
546 let mut new_codegen_unit = CodegenUnit::new(old_codegen_unit.name().clone());
548 // Add all translation items that are not already there
549 for trans_item in reachable {
550 if let Some(linkage) = old_codegen_unit.items().get(&trans_item) {
551 // This is a root, just copy it over
552 new_codegen_unit.items_mut().insert(trans_item, *linkage);
554 if roots.contains(&trans_item) {
555 bug!("GloballyShared trans-item inlined into other CGU: \
559 // This is a cgu-private copy
560 new_codegen_unit.items_mut().insert(
562 (Linkage::Internal, Visibility::Default),
566 if !single_codegen_unit {
567 // If there is more than one codegen unit, we need to keep track
568 // in which codegen units each translation item is placed:
569 match trans_item_placements.entry(trans_item) {
570 Entry::Occupied(e) => {
571 let placement = e.into_mut();
572 debug_assert!(match *placement {
573 TransItemPlacement::SingleCgu { ref cgu_name } => {
574 *cgu_name != *new_codegen_unit.name()
576 TransItemPlacement::MultipleCgus => true,
578 *placement = TransItemPlacement::MultipleCgus;
580 Entry::Vacant(e) => {
581 e.insert(TransItemPlacement::SingleCgu {
582 cgu_name: new_codegen_unit.name().clone()
589 new_partitioning.push(new_codegen_unit);
592 return PostInliningPartitioning {
593 codegen_units: new_partitioning,
594 trans_item_placements,
595 internalization_candidates,
598 fn follow_inlining<'tcx>(trans_item: MonoItem<'tcx>,
599 inlining_map: &InliningMap<'tcx>,
600 visited: &mut FxHashSet<MonoItem<'tcx>>) {
601 if !visited.insert(trans_item) {
605 inlining_map.with_inlining_candidates(trans_item, |target| {
606 follow_inlining(target, inlining_map, visited);
611 fn internalize_symbols<'a, 'tcx>(_tcx: TyCtxt<'a, 'tcx, 'tcx>,
612 partitioning: &mut PostInliningPartitioning<'tcx>,
613 inlining_map: &InliningMap<'tcx>) {
614 if partitioning.codegen_units.len() == 1 {
615 // Fast path for when there is only one codegen unit. In this case we
616 // can internalize all candidates, since there is nowhere else they
617 // could be accessed from.
618 for cgu in &mut partitioning.codegen_units {
619 for candidate in &partitioning.internalization_candidates {
620 cgu.items_mut().insert(*candidate,
621 (Linkage::Internal, Visibility::Default));
628 // Build a map from every translation item to all the translation items that
630 let mut accessor_map: FxHashMap<MonoItem<'tcx>, Vec<MonoItem<'tcx>>> = FxHashMap();
631 inlining_map.iter_accesses(|accessor, accessees| {
632 for accessee in accessees {
633 accessor_map.entry(*accessee)
634 .or_insert(Vec::new())
639 let trans_item_placements = &partitioning.trans_item_placements;
641 // For each internalization candidates in each codegen unit, check if it is
642 // accessed from outside its defining codegen unit.
643 for cgu in &mut partitioning.codegen_units {
644 let home_cgu = TransItemPlacement::SingleCgu {
645 cgu_name: cgu.name().clone()
648 for (accessee, linkage_and_visibility) in cgu.items_mut() {
649 if !partitioning.internalization_candidates.contains(accessee) {
650 // This item is no candidate for internalizing, so skip it.
653 debug_assert_eq!(trans_item_placements[accessee], home_cgu);
655 if let Some(accessors) = accessor_map.get(accessee) {
657 .filter_map(|accessor| {
658 // Some accessors might not have been
659 // instantiated. We can safely ignore those.
660 trans_item_placements.get(accessor)
662 .any(|placement| *placement != home_cgu) {
663 // Found an accessor from another CGU, so skip to the next
664 // item without marking this one as internal.
669 // If we got here, we did not find any accesses from other CGUs,
670 // so it's fine to make this translation item internal.
671 *linkage_and_visibility = (Linkage::Internal, Visibility::Default);
676 fn characteristic_def_id_of_trans_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
677 trans_item: MonoItem<'tcx>)
680 MonoItem::Fn(instance) => {
681 let def_id = match instance.def {
682 ty::InstanceDef::Item(def_id) => def_id,
683 ty::InstanceDef::FnPtrShim(..) |
684 ty::InstanceDef::ClosureOnceShim { .. } |
685 ty::InstanceDef::Intrinsic(..) |
686 ty::InstanceDef::DropGlue(..) |
687 ty::InstanceDef::Virtual(..) |
688 ty::InstanceDef::CloneShim(..) => return None
691 // If this is a method, we want to put it into the same module as
692 // its self-type. If the self-type does not provide a characteristic
693 // DefId, we use the location of the impl after all.
695 if tcx.trait_of_item(def_id).is_some() {
696 let self_ty = instance.substs.type_at(0);
697 // This is an implementation of a trait method.
698 return characteristic_def_id_of_type(self_ty).or(Some(def_id));
701 if let Some(impl_def_id) = tcx.impl_of_method(def_id) {
702 // This is a method within an inherent impl, find out what the
704 let impl_self_ty = tcx.subst_and_normalize_erasing_regions(
706 ty::ParamEnv::reveal_all(),
707 &tcx.type_of(impl_def_id),
709 if let Some(def_id) = characteristic_def_id_of_type(impl_self_ty) {
716 MonoItem::Static(def_id) => Some(def_id),
717 MonoItem::GlobalAsm(node_id) => Some(tcx.hir.local_def_id(node_id)),
721 fn compute_codegen_unit_name<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
725 // Unfortunately we cannot just use the `ty::item_path` infrastructure here
726 // because we need paths to modules and the DefIds of those are not
727 // available anymore for external items.
728 let mut cgu_name = String::with_capacity(64);
730 let def_path = tcx.def_path(def_id);
731 cgu_name.push_str(&tcx.crate_name(def_path.krate).as_str());
733 for part in tcx.def_path(def_id)
738 DefPathData::Module(..) => true,
742 cgu_name.push_str("-");
743 cgu_name.push_str(&part.data.as_interned_str().as_str());
747 cgu_name.push_str(".volatile");
750 let cgu_name = if tcx.sess.opts.debugging_opts.human_readable_cgu_names {
753 CodegenUnit::mangle_name(&cgu_name)
756 Symbol::intern(&cgu_name[..]).as_interned_str()
759 fn numbered_codegen_unit_name(crate_name: &str, index: usize) -> InternedString {
760 Symbol::intern(&format!("{}{}", crate_name, index)).as_interned_str()
763 fn debug_dump<'a, 'b, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
766 where I: Iterator<Item=&'b CodegenUnit<'tcx>>,
769 if cfg!(debug_assertions) {
772 debug!("CodegenUnit {}:", cgu.name());
774 for (trans_item, linkage) in cgu.items() {
775 let symbol_name = trans_item.symbol_name(tcx).name.as_str();
776 let symbol_hash_start = symbol_name.rfind('h');
777 let symbol_hash = symbol_hash_start.map(|i| &symbol_name[i ..])
778 .unwrap_or("<no hash>");
780 debug!(" - {} [{:?}] [{}]",
781 trans_item.to_string(tcx),