Added compile codegen to backend trait

Author: denismerigoux

src/librustc_codegen_llvm/base.rs

@@ -57,6 +57,7 @@ use rustc_mir::monomorphize::item::DefPathBasedNames;
 use common::{self, IntPredicate, RealPredicate, TypeKind};
 use meth;
 use mir;
+use context::CodegenCx;
 use monomorphize::Instance;
 use monomorphize::partitioning::{self, PartitioningStrategy, CodegenUnit, CodegenUnitExt};
 use rustc_codegen_utils::symbol_names_test;
@@ -719,7 +720,7 @@ fn determine_cgu_reuse<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     }
 }
 
-pub fn codegen_crate<'a, 'll: 'a, 'tcx: 'll, B : BackendMethods<'a, 'll, 'tcx>>(
+pub fn codegen_crate<B : BackendMethods>(
     backend: B,
     tcx: TyCtxt<'ll, 'tcx, 'tcx>,
     rx: mpsc::Receiver<Box<dyn Any + Send>>
@@ -877,7 +878,7 @@ pub fn codegen_crate<'a, 'll: 'a, 'tcx: 'll, B : BackendMethods<'a, 'll, 'tcx>>(
                                      &format!("codegen {}", cgu.name()))
                 });
                 let start_time = Instant::now();
-                let stats = compile_codegen_unit(tcx, *cgu.name());
+                let stats = backend.compile_codegen_unit(tcx, *cgu.name());
                 all_stats.extend(stats);
                 total_codegen_time += start_time.elapsed();
                 false
@@ -1166,7 +1167,7 @@ fn is_codegened_item(tcx: TyCtxt, id: DefId) -> bool {
     all_mono_items.contains(&id)
 }
 
-fn compile_codegen_unit<'ll, 'tcx>(tcx: TyCtxt<'ll, 'tcx, 'tcx>,
+pub fn compile_codegen_unit<'ll, 'tcx>(tcx: TyCtxt<'ll, 'tcx, 'tcx>,
                                   cgu_name: InternedString)
                                   -> Stats {
     let start_time = Instant::now();
@@ -1198,7 +1199,7 @@ fn compile_codegen_unit<'ll, 'tcx>(tcx: TyCtxt<'ll, 'tcx, 'tcx>,
         // Instantiate monomorphizations without filling out definitions yet...
         let llvm_module = backend.new_metadata(tcx.sess, &cgu_name.as_str());
         let stats = {
-            let cx = backend.new_codegen_context(tcx, cgu, &llvm_module);
+            let cx = CodegenCx::new(tcx, cgu, &llvm_module);
             let mono_items = cx.codegen_unit
                                .items_in_deterministic_order(cx.tcx);
             for &(mono_item, (linkage, visibility)) in &mono_items {

src/librustc_codegen_llvm/interfaces/backend.rs

@@ -9,17 +9,16 @@
 // 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 rustc::mir::mono::Stats;
+use syntax_pos::symbol::InternedString;
 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;
@@ -28,10 +27,9 @@ pub trait Backend<'ll> {
     type Context;
 }
 
-pub trait BackendMethods<'a, 'll: 'a, 'tcx: 'll> {
+pub trait BackendMethods {
     type Metadata;
     type OngoingCodegen;
-    type Builder : BuilderMethods<'a, 'll, 'tcx>;
 
     fn thin_lto_available(&self) -> bool;
     fn pgo_available(&self) -> bool;
@@ -60,10 +58,9 @@ pub trait BackendMethods<'a, 'll: 'a, 'tcx: 'll> {
     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(
+    fn compile_codegen_unit<'ll, 'tcx: 'll>(
         &self,
         tcx: TyCtxt<'ll, 'tcx, 'tcx>,
-        codegen_unit: Arc<CodegenUnit<'tcx>>,
-        llvm_module: &'ll Self::Metadata
-    ) -> <Self::Builder as HasCodegen<'a, 'll, 'tcx>>::CodegenCx;
+        cgu_name: InternedString
+    ) -> Stats ;
 }

src/librustc_codegen_llvm/lib.rs

@@ -72,14 +72,11 @@ use interfaces::*;
 use time_graph::TimeGraph;
 use std::sync::mpsc::Receiver;
 use back::write::{self, OngoingCodegen};
-use builder::Builder;
-use value::Value;
-use context::CodegenCx;
-use monomorphize::partitioning::CodegenUnit;
+use syntax_pos::symbol::InternedString;
+use rustc::mir::mono::Stats;
 
 pub use llvm_util::target_features;
 use std::any::Any;
-use std::sync::Arc;
 use std::path::{PathBuf};
 use std::sync::mpsc;
 use rustc_data_structures::sync::Lrc;
@@ -147,10 +144,9 @@ mod value;
 
 pub struct LlvmCodegenBackend(());
 
-impl<'a, 'll: 'a, 'tcx: 'll> BackendMethods<'a, 'll, 'tcx> for LlvmCodegenBackend {
+impl BackendMethods for LlvmCodegenBackend {
     type Metadata = ModuleLlvm;
     type OngoingCodegen = OngoingCodegen;
-    type Builder = Builder<'a, 'll, 'tcx, &'ll Value>;
 
     fn thin_lto_available(&self) -> bool {
          unsafe { !llvm::LLVMRustThinLTOAvailable() }
@@ -198,13 +194,12 @@ impl<'a, 'll: 'a, 'tcx: 'll> BackendMethods<'a, 'll, 'tcx> for LlvmCodegenBacken
     fn wait_for_signal_to_codegen_item(&self, codegen: &OngoingCodegen) {
         codegen.wait_for_signal_to_codegen_item()
     }
-    fn new_codegen_context(
+    fn compile_codegen_unit<'ll, 'tcx: 'll>(
         &self,
         tcx: TyCtxt<'ll, 'tcx, 'tcx>,
-        codegen_unit: Arc<CodegenUnit<'tcx>>,
-        llvm_module: &'ll ModuleLlvm
-    ) -> CodegenCx<'ll, 'tcx, &'ll Value> {
-        CodegenCx::new(tcx, codegen_unit, llvm_module)
+        cgu_name: InternedString
+    ) -> Stats {
+        base::compile_codegen_unit(tcx, cgu_name)
     }
 }