avoid codegenunit clone

Author: csmoe

compiler/rustc_middle/src/mir/mono.rs

@@ -223,7 +223,7 @@ impl<'tcx> fmt::Display for MonoItem<'tcx> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct CodegenUnit<'tcx> {
     /// A name for this CGU. Incremental compilation requires that
     /// name be unique amongst **all** crates. Therefore, it should
@@ -236,6 +236,7 @@ pub struct CodegenUnit<'tcx> {
     /// True if this is CGU is used to hold code coverage information for dead code,
     /// false otherwise.
     is_code_coverage_dead_code_cgu: bool,
+    was_merged: bool,
 }
 
 /// Specifies the linkage type for a `MonoItem`.
@@ -272,6 +273,7 @@ impl<'tcx> CodegenUnit<'tcx> {
             size_estimate: None,
             primary: false,
             is_code_coverage_dead_code_cgu: false,
+            was_merged: false,
         }
     }
 
@@ -291,6 +293,14 @@ impl<'tcx> CodegenUnit<'tcx> {
         self.primary = true;
     }
 
+    pub fn was_merged(&self) -> bool {
+        self.was_merged
+    }
+
+    pub fn make_merged(&mut self) {
+        self.was_merged = true;
+    }
+
     /// The order of these items is non-determinstic.
     pub fn items(&self) -> &FxHashMap<MonoItem<'tcx>, (Linkage, Visibility)> {
         &self.items
@@ -411,6 +421,7 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for CodegenUnit<'tcx> {
             size_estimate: _,
             primary: _,
             is_code_coverage_dead_code_cgu,
+            was_merged: _,
         } = *self;
 
         name.hash_stable(hcx, hasher);

compiler/rustc_monomorphize/src/partitioning.rs

@@ -336,27 +336,30 @@ fn merge_codegen_units<'tcx>(
         // Sort small cgus to the back.
         codegen_units.sort_by_cached_key(|cgu| cmp::Reverse(cgu.size_estimate()));
         let fallback_cgu_name = fallback_cgu_name(cgu_name_builder);
+        let mut default = CodegenUnit::new(fallback_cgu_name);
+        default.create_size_estimate(cx.tcx);
         let mut merged_subsets: Vec<CodegenUnit<'_>> =
-            vec![CodegenUnit::new(fallback_cgu_name); cx.tcx.sess.codegen_units().as_usize()];
+            vec![default; cx.tcx.sess.codegen_units().as_usize()];
 
-        for cgu in codegen_units.iter_mut() {
+        codegen_units.iter_mut().for_each(|cgu| {
             let min = merged_subsets
                 .iter()
                 .enumerate()
                 .min_by_key(|(_, cgu)| cgu.size_estimate())
                 .map(|(i, _)| i)
                 .unwrap_or(0);
             let min_cgu = &mut merged_subsets[min];
-            if min_cgu.name() == fallback_cgu_name {
+            if !min_cgu.was_merged() {
                 *min_cgu = std::mem::replace(cgu, CodegenUnit::new(fallback_cgu_name));
+                min_cgu.make_merged();
             } else {
                 min_cgu.modify_size_estimate(cgu.size_estimate());
                 min_cgu.items_mut().extend(cgu.items_mut().drain());
                 let mut consumed_cgu_names = cgu_contents.remove(&cgu.name()).unwrap();
                 cgu_contents.get_mut(&min_cgu.name()).unwrap().append(&mut consumed_cgu_names);
                 debug!("CodegenUnit {} merged into CodegenUnit {}", cgu.name(), min_cgu.name());
             }
-        }
+        });
         *codegen_units = merged_subsets;
     }