Preparing the generalization of base:compile_coodegen_unit

Author: denismerigoux

src/librustc_codegen_llvm/base.rs

@@ -27,6 +27,7 @@ use super::ModuleLlvm;
 use super::ModuleCodegen;
 use super::ModuleKind;
 use super::CachedModuleCodegen;
+use super::LlvmCodegenBackend;
 
 use abi;
 use back::write;
@@ -54,8 +55,6 @@ use callee;
 use rustc_mir::monomorphize::collector::{self, MonoItemCollectionMode};
 use rustc_mir::monomorphize::item::DefPathBasedNames;
 use common::{self, IntPredicate, RealPredicate, TypeKind};
-use context::CodegenCx;
-use debuginfo;
 use meth;
 use mir;
 use monomorphize::Instance;
@@ -720,9 +719,9 @@ fn determine_cgu_reuse<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     }
 }
 
-pub fn codegen_crate<'a, 'tcx, B : BackendMethods>(
+pub fn codegen_crate<'a, 'll: 'a, 'tcx: 'll, B : BackendMethods<'a, 'll, 'tcx>>(
     backend: B,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'ll, 'tcx, 'tcx>,
     rx: mpsc::Receiver<Box<dyn Any + Send>>
 ) -> B::OngoingCodegen {
 
@@ -941,6 +940,7 @@ pub fn codegen_crate<'a, 'tcx, B : BackendMethods>(
     ongoing_codegen.into_inner()
 }
 
+=======
 /// A curious wrapper structure whose only purpose is to call `codegen_aborted`
 /// when it's dropped abnormally.
 ///
@@ -968,6 +968,83 @@ impl AbortCodegenOnDrop {
 
 impl Deref for AbortCodegenOnDrop {
     type Target = OngoingCodegen;
+}
+
+fn assert_and_save_dep_graph<'ll, 'tcx>(tcx: TyCtxt<'ll, 'tcx, 'tcx>) {
+    time(tcx.sess,
+         "assert dep graph",
+         || rustc_incremental::assert_dep_graph(tcx));
+
+    time(tcx.sess,
+         "serialize dep graph",
+         || rustc_incremental::save_dep_graph(tcx));
+}
+
+fn collect_and_partition_mono_items<'ll, 'tcx>(
+    tcx: TyCtxt<'ll, 'tcx, 'tcx>,
+    cnum: CrateNum,
+) -> (Arc<DefIdSet>, Arc<Vec<Arc<CodegenUnit<'tcx>>>>)
+{
+    assert_eq!(cnum, LOCAL_CRATE);
+
+    let collection_mode = match tcx.sess.opts.debugging_opts.print_mono_items {
+        Some(ref s) => {
+            let mode_string = s.to_lowercase();
+            let mode_string = mode_string.trim();
+            if mode_string == "eager" {
+                MonoItemCollectionMode::Eager
+            } else {
+                if mode_string != "lazy" {
+                    let message = format!("Unknown codegen-item collection mode '{}'. \
+                                           Falling back to 'lazy' mode.",
+                                          mode_string);
+                    tcx.sess.warn(&message);
+                }
+
+                MonoItemCollectionMode::Lazy
+            }
+        }
+        None => {
+            if tcx.sess.opts.cg.link_dead_code {
+                MonoItemCollectionMode::Eager
+            } else {
+                MonoItemCollectionMode::Lazy
+            }
+        }
+    };
+
+    let (items, inlining_map) =
+        time(tcx.sess, "monomorphization collection", || {
+            collector::collect_crate_mono_items(tcx, collection_mode)
+    });
+
+    tcx.sess.abort_if_errors();
+
+    ::rustc_mir::monomorphize::assert_symbols_are_distinct(tcx, items.iter());
+
+    let strategy = if tcx.sess.opts.incremental.is_some() {
+        PartitioningStrategy::PerModule
+    } else {
+        PartitioningStrategy::FixedUnitCount(tcx.sess.codegen_units())
+    };
+
+    let codegen_units = time(tcx.sess, "codegen unit partitioning", || {
+        partitioning::partition(tcx,
+                                items.iter().cloned(),
+                                strategy,
+                                &inlining_map)
+            .into_iter()
+            .map(Arc::new)
+            .collect::<Vec<_>>()
+    });
+
+    let mono_items: DefIdSet = items.iter().filter_map(|mono_item| {
+        match *mono_item {
+            MonoItem::Fn(ref instance) => Some(instance.def_id()),
+            MonoItem::Static(def_id) => Some(def_id),
+            _ => None,
+        }
+    }).collect();
 
     fn deref(&self) -> &OngoingCodegen {
         self.0.as_ref().unwrap()
@@ -1087,7 +1164,13 @@ impl CrateInfo {
     }
 }
 
-fn compile_codegen_unit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+fn is_codegened_item(tcx: TyCtxt, id: DefId) -> bool {
+    let (all_mono_items, _) =
+        tcx.collect_and_partition_mono_items(LOCAL_CRATE);
+    all_mono_items.contains(&id)
+}
+
+fn compile_codegen_unit<'ll, 'tcx>(tcx: TyCtxt<'ll, 'tcx, 'tcx>,
                                   cgu_name: InternedString)
                                   -> Stats {
     let start_time = Instant::now();
@@ -1109,67 +1192,49 @@ fn compile_codegen_unit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                            cost);
     return stats;
 
-    fn module_codegen<'a, 'tcx>(
-        tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    fn module_codegen<'ll, 'tcx>(
+        tcx: TyCtxt<'ll, 'tcx, 'tcx>,
         cgu_name: InternedString)
         -> (Stats, ModuleCodegen<ModuleLlvm>)
     {
+        let backend = LlvmCodegenBackend(());
         let cgu = tcx.codegen_unit(cgu_name);
-
         // Instantiate monomorphizations without filling out definitions yet...
-        let llvm_module = ModuleLlvm::new(tcx.sess, &cgu_name.as_str());
+        let llvm_module = backend.new_metadata(tcx.sess, &cgu_name.as_str());
         let stats = {
-            let cx = CodegenCx::new(tcx, cgu, &llvm_module);
+            let cx = backend.new_codegen_context(tcx, cgu, &llvm_module);
             let mono_items = cx.codegen_unit
                                .items_in_deterministic_order(cx.tcx);
             for &(mono_item, (linkage, visibility)) in &mono_items {
-                mono_item.predefine(&cx, linkage, visibility);
+                mono_item.predefine::<Builder<&Value>>(&cx, linkage, visibility);
             }
 
             // ... and now that we have everything pre-defined, fill out those definitions.
             for &(mono_item, _) in &mono_items {
-                mono_item.define(&cx);
+                mono_item.define::<Builder<&Value>>(&cx);
             }
 
             // If this codegen unit contains the main function, also create the
             // wrapper here
             maybe_create_entry_wrapper::<Builder<&Value>>(&cx);
 
             // Run replace-all-uses-with for statics that need it
-            for &(old_g, new_g) in cx.statics_to_rauw.borrow().iter() {
-                unsafe {
-                    let bitcast = llvm::LLVMConstPointerCast(new_g, cx.val_ty(old_g));
-                    llvm::LLVMReplaceAllUsesWith(old_g, bitcast);
-                    llvm::LLVMDeleteGlobal(old_g);
-                }
+            for &(old_g, new_g) in cx.statics_to_rauw().borrow().iter() {
+                cx.static_replace_all_uses(old_g, new_g)
             }
 
             // Create the llvm.used variable
             // This variable has type [N x i8*] and is stored in the llvm.metadata section
-            if !cx.used_statics.borrow().is_empty() {
-                let name = const_cstr!("llvm.used");
-                let section = const_cstr!("llvm.metadata");
-                let array = cx.const_array(
-                    &cx.type_ptr_to(cx.type_i8()),
-                    &*cx.used_statics.borrow()
-                );
-
-                unsafe {
-                    let g = llvm::LLVMAddGlobal(cx.llmod,
-                                                cx.val_ty(array),
-                                                name.as_ptr());
-                    llvm::LLVMSetInitializer(g, array);
-                    llvm::LLVMRustSetLinkage(g, llvm::Linkage::AppendingLinkage);
-                    llvm::LLVMSetSection(g, section.as_ptr());
-                }
+            if !cx.used_statics().borrow().is_empty() {
+                cx.create_used_variable()
             }
 
             // Finalize debuginfo
             if cx.sess().opts.debuginfo != DebugInfo::None {
-                debuginfo::finalize(&cx);
+                cx.debuginfo_finalize();
             }
 
-            cx.stats.into_inner()
+            cx.consume_stats().into_inner()
         };
 
         (stats, ModuleCodegen {

src/librustc_codegen_llvm/consts.rs

@@ -443,4 +443,11 @@ impl StaticMethods<'ll> for CodegenCx<'ll, 'tcx, &'ll Value> {
             }
         }
     }
+    fn static_replace_all_uses(&self, old_g: &'ll Value, new_g: &'ll Value) {
+        unsafe {
+            let bitcast = llvm::LLVMConstPointerCast(new_g, self.val_ty(old_g));
+            llvm::LLVMReplaceAllUsesWith(old_g, bitcast);
+            llvm::LLVMDeleteGlobal(old_g);
+        }
+    }
 }

src/librustc_codegen_llvm/context.rs

@@ -422,17 +422,48 @@ impl MiscMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
         &self.stats
     }
 
+    fn consume_stats(self) -> RefCell<Stats> {
+        self.stats
+    }
+
     fn codegen_unit(&self) -> &Arc<CodegenUnit<'tcx>> {
         &self.codegen_unit
     }
 
+    fn statics_to_rauw(&self) -> &RefCell<Vec<(&'ll Value, &'ll Value)>> {
+        &self.statics_to_rauw
+    }
+
+    fn used_statics(&self) -> &RefCell<Vec<&'ll Value>> {
+        &self.used_statics
+    }
+
     fn set_frame_pointer_elimination(&self, llfn: &'ll Value) {
         attributes::set_frame_pointer_elimination(self, llfn)
     }
 
     fn apply_target_cpu_attr(&self, llfn: &'ll Value) {
         attributes::apply_target_cpu_attr(self, llfn)
     }
+
+
+    fn create_used_variable(&self) {
+        let name = const_cstr!("llvm.used");
+        let section = const_cstr!("llvm.metadata");
+        let array = self.const_array(
+            &self.type_ptr_to(self.type_i8()),
+            &*self.used_statics.borrow()
+        );
+
+        unsafe {
+            let g = llvm::LLVMAddGlobal(self.llmod,
+                                        self.val_ty(array),
+                                        name.as_ptr());
+            llvm::LLVMSetInitializer(g, array);
+            llvm::LLVMRustSetLinkage(g, llvm::Linkage::AppendingLinkage);
+            llvm::LLVMSetSection(g, section.as_ptr());
+        }
+    }
 }
 
 impl<'ll, 'tcx: 'll> CodegenMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {}

src/librustc_codegen_llvm/debuginfo/mod.rs

@@ -592,4 +592,8 @@ impl<'ll, 'tcx: 'll> DebugInfoMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll V
     ) -> &'ll DILexicalBlock {
         metadata::extend_scope_to_file(&self, scope_metadata, file, defining_crate)
     }
+
+    fn debuginfo_finalize(&self) {
+        finalize(self)
+    }
 }

src/librustc_codegen_llvm/interfaces/backend.rs

@@ -9,14 +9,17 @@
 // except according to those terms.
 
 use super::CodegenObject;
+use super::builder::{HasCodegen, BuilderMethods};
 use ModuleCodegen;
 use rustc::session::Session;
 use rustc::middle::cstore::EncodedMetadata;
 use rustc::middle::allocator::AllocatorKind;
+use monomorphize::partitioning::CodegenUnit;
 use rustc::ty::TyCtxt;
 use time_graph::TimeGraph;
 use std::sync::mpsc::Receiver;
 use std::any::Any;
+use std::sync::Arc;
 
 pub trait Backend<'ll> {
     type Value : 'll + CodegenObject;
@@ -25,16 +28,17 @@ pub trait Backend<'ll> {
     type Context;
 }
 
-pub trait BackendMethods {
+pub trait BackendMethods<'a, 'll: 'a, 'tcx: 'll> {
     type Metadata;
     type OngoingCodegen;
+    type Builder : BuilderMethods<'a, 'll, 'tcx>;
 
     fn thin_lto_available(&self) -> bool;
     fn pgo_available(&self) -> bool;
     fn new_metadata(&self, sess: &Session, mod_name: &str) -> Self::Metadata;
-    fn write_metadata<'a, 'gcx>(
+    fn write_metadata<'b, 'gcx>(
         &self,
-        tcx: TyCtxt<'a, 'gcx, 'gcx>,
+        tcx: TyCtxt<'b, 'gcx, 'gcx>,
         metadata: &Self::Metadata
     ) -> EncodedMetadata;
     fn codegen_allocator(&self, tcx: TyCtxt, mods: &Self::Metadata, kind: AllocatorKind);
@@ -56,4 +60,10 @@ pub trait BackendMethods {
     fn codegen_finished(&self, codegen: &Self::OngoingCodegen, tcx: TyCtxt);
     fn check_for_errors(&self, codegen: &Self::OngoingCodegen, sess: &Session);
     fn wait_for_signal_to_codegen_item(&self, codegen: &Self::OngoingCodegen);
+    fn new_codegen_context(
+        &self,
+        tcx: TyCtxt<'ll, 'tcx, 'tcx>,
+        codegen_unit: Arc<CodegenUnit<'tcx>>,
+        llvm_module: &'ll Self::Metadata
+    ) -> <Self::Builder as HasCodegen<'a, 'll, 'tcx>>::CodegenCx;
 }

src/librustc_codegen_llvm/interfaces/debuginfo.rs

@@ -41,7 +41,7 @@ pub trait DebugInfoMethods<'ll, 'tcx: 'll> : Backend<'ll> {
         llfn: Self::Value,
         mir: &mir::Mir,
     ) -> FunctionDebugContext<'ll>;
-    
+
     fn create_mir_scopes(
         &self,
         mir: &mir::Mir,
@@ -53,6 +53,7 @@ pub trait DebugInfoMethods<'ll, 'tcx: 'll> : Backend<'ll> {
         file: &syntax_pos::SourceFile,
         defining_crate: CrateNum,
     ) -> Self::DIScope;
+    fn debuginfo_finalize(&self);
 }
 
 pub trait DebugInfoBuilderMethods<'a, 'll: 'a, 'tcx: 'll> : HasCodegen<'a, 'll, 'tcx> {

src/librustc_codegen_llvm/interfaces/misc.rs

@@ -29,7 +29,11 @@ pub trait MiscMethods<'ll, 'tcx: 'll> : Backend<'ll> {
     fn eh_unwind_resume(&self) -> Self::Value;
     fn sess(&self) -> &Session;
     fn stats(&self) -> &RefCell<Stats>;
+    fn consume_stats(self) -> RefCell<Stats>;
     fn codegen_unit(&self) -> &Arc<CodegenUnit<'tcx>>;
+    fn statics_to_rauw(&self) -> &RefCell<Vec<(Self::Value, Self::Value)>>;
+    fn used_statics(&self) -> &RefCell<Vec<Self::Value>>;
     fn set_frame_pointer_elimination(&self, llfn: Self::Value);
     fn apply_target_cpu_attr(&self, llfn: Self::Value);
+    fn create_used_variable(&self);
 }

src/librustc_codegen_llvm/interfaces/statics.rs

@@ -33,4 +33,5 @@ pub trait StaticMethods<'ll> : Backend<'ll> {
         def_id: DefId,
         is_mutable: bool,
     );
+    fn static_replace_all_uses(&self, old_g: Self::Value, new_g: Self::Value);
 }