Add TransCrate trait

Author: bjorn3

src/Cargo.lock

@@ -33,6 +33,7 @@ rustc_resolve = { path = "../librustc_resolve" }
 rustc_save_analysis = { path = "../librustc_save_analysis" }
 rustc_trans = { path = "../librustc_trans", optional = true }
 rustc_trans_utils = { path = "../librustc_trans_utils" }
+rustc_trans_traits = { path = "../librustc_trans_traits" }
 rustc_typeck = { path = "../librustc_typeck" }
 serialize = { path = "../libserialize" }
 syntax = { path = "../libsyntax" }

src/librustc_driver/Cargo.toml

@@ -34,15 +34,16 @@ use rustc_incremental;
 use rustc_resolve::{MakeGlobMap, Resolver};
 use rustc_metadata::creader::CrateLoader;
 use rustc_metadata::cstore::{self, CStore};
-use rustc_trans::back::write;
 use rustc_trans as trans;
+use rustc_trans_traits::TransCrate;
 use rustc_typeck as typeck;
 use rustc_privacy;
 use rustc_plugin::registry::Registry;
 use rustc_plugin as plugin;
 use rustc_passes::{ast_validation, no_asm, loops, consts, static_recursion, hir_stats};
 use rustc_const_eval::{self, check_match};
 use super::Compilation;
+use ::DefaultTransCrate;
 
 use serialize::json;
 
@@ -76,7 +77,6 @@ pub fn compile_input(sess: &Session,
                      output: &Option<PathBuf>,
                      addl_plugins: Option<Vec<String>>,
                      control: &CompileController) -> CompileResult {
-    use rustc_trans::back::write::OngoingCrateTranslation;
     use rustc::session::config::CrateType;
 
     macro_rules! controller_entry_point {
@@ -122,7 +122,7 @@ pub fn compile_input(sess: &Session,
     // We need nested scopes here, because the intermediate results can keep
     // large chunks of memory alive and we want to free them as soon as
     // possible to keep the peak memory usage low
-    let (outputs, trans, dep_graph): (OutputFilenames, OngoingCrateTranslation, DepGraph) = {
+    let (outputs, trans, dep_graph) = {
         let krate = match phase_1_parse_input(control, sess, input) {
             Ok(krate) => krate,
             Err(mut parse_error) => {
@@ -251,7 +251,7 @@ pub fn compile_input(sess: &Session,
                 tcx.print_debug_stats();
             }
 
-            let trans = phase_4_translate_to_llvm(tcx, rx);
+            let trans = phase_4_translate_to_llvm::<DefaultTransCrate>(tcx, rx);
 
             if log_enabled!(::log::LogLevel::Info) {
                 println!("Post-trans");
@@ -285,15 +285,15 @@ pub fn compile_input(sess: &Session,
             sess.code_stats.borrow().print_type_sizes();
         }
 
-        let (phase5_result, trans) = phase_5_run_llvm_passes(sess, &dep_graph, trans);
+        let (phase5_result, trans) = phase_5_run_llvm_passes::<DefaultTransCrate>(sess, &dep_graph, trans);
 
         controller_entry_point!(after_llvm,
                                 sess,
                                 CompileState::state_after_llvm(input, sess, outdir, output, &trans),
                                 phase5_result);
         phase5_result?;
 
-        phase_6_link_output(sess, &trans, &outputs);
+        phase_6_link_output::<DefaultTransCrate>(sess, &trans, &outputs);
 
         // Now that we won't touch anything in the incremental compilation directory
         // any more, we can finalize it (which involves renaming it)
@@ -972,7 +972,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
     mir::provide(&mut local_providers);
     reachable::provide(&mut local_providers);
     rustc_privacy::provide(&mut local_providers);
-    trans::provide_local(&mut local_providers);
+    DefaultTransCrate::provide_local(&mut local_providers);
     typeck::provide(&mut local_providers);
     ty::provide(&mut local_providers);
     traits::provide(&mut local_providers);
@@ -984,7 +984,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
 
     let mut extern_providers = ty::maps::Providers::default();
     cstore::provide(&mut extern_providers);
-    trans::provide_extern(&mut extern_providers);
+    DefaultTransCrate::provide_extern(&mut extern_providers);
     ty::provide_extern(&mut extern_providers);
     traits::provide_extern(&mut extern_providers);
     // FIXME(eddyb) get rid of this once we replace const_eval with miri.
@@ -1130,9 +1130,9 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
 
 /// Run the translation phase to LLVM, after which the AST and analysis can
 /// be discarded.
-pub fn phase_4_translate_to_llvm<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+pub fn phase_4_translate_to_llvm<'a, 'tcx, T: TransCrate>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                            rx: mpsc::Receiver<Box<Any + Send>>)
-                                           -> write::OngoingCrateTranslation {
+                                           -> <T as TransCrate>::OngoingCrateTranslation {
     let time_passes = tcx.sess.time_passes();
 
     time(time_passes,
@@ -1141,9 +1141,8 @@ pub fn phase_4_translate_to_llvm<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
     let translation =
         time(time_passes, "translation", move || {
-            trans::trans_crate(tcx, rx)
+            T::trans_crate(tcx, rx)
         });
-
     if tcx.sess.profile_queries() {
         profile::dump("profile_queries".to_string())
     }
@@ -1153,15 +1152,14 @@ pub fn phase_4_translate_to_llvm<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
 /// Run LLVM itself, producing a bitcode file, assembly file or object file
 /// as a side effect.
-#[cfg(feature="llvm")]
-pub fn phase_5_run_llvm_passes(sess: &Session,
+pub fn phase_5_run_llvm_passes<T: TransCrate>(sess: &Session,
                                dep_graph: &DepGraph,
-                               trans: write::OngoingCrateTranslation)
-                               -> (CompileResult, trans::CrateTranslation) {
-    let trans = trans.join(sess, dep_graph);
+                               trans: <T as TransCrate>::OngoingCrateTranslation)
+                               -> (CompileResult, <T as TransCrate>::TranslatedCrate) {
+    let trans = T::join_trans(trans, sess, dep_graph);
 
     if sess.opts.debugging_opts.incremental_info {
-        write::dump_incremental_data(&trans);
+        T::dump_incremental_data(&trans);
     }
 
     time(sess.time_passes(),
@@ -1174,14 +1172,11 @@ pub fn phase_5_run_llvm_passes(sess: &Session,
 /// Run the linker on any artifacts that resulted from the LLVM run.
 /// This should produce either a finished executable or library.
 #[cfg(feature="llvm")]
-pub fn phase_6_link_output(sess: &Session,
-                           trans: &trans::CrateTranslation,
+pub fn phase_6_link_output<T: TransCrate>(sess: &Session,
+                           trans: &<T as TransCrate>::TranslatedCrate,
                            outputs: &OutputFilenames) {
     time(sess.time_passes(), "linking", || {
-        ::rustc_trans::back::link::link_binary(sess,
-                                               trans,
-                                               outputs,
-                                               &trans.crate_name.as_str())
+        T::link_binary(sess, trans, outputs)
     });
 }
 

src/librustc_driver/driver.rs

@@ -25,9 +25,7 @@
 #![feature(rustc_diagnostic_macros)]
 #![feature(set_stdio)]
 
-#[cfg(not(feature="llvm"))]
 extern crate ar;
-#[cfg(not(feature="llvm"))]
 extern crate flate2;
 extern crate arena;
 extern crate getopts;
@@ -54,6 +52,7 @@ extern crate rustc_save_analysis;
 #[cfg(feature="llvm")]
 extern crate rustc_trans;
 extern crate rustc_trans_utils;
+extern crate rustc_trans_traits;
 extern crate rustc_typeck;
 extern crate serialize;
 #[macro_use]
@@ -79,6 +78,7 @@ use rustc::middle::cstore::CrateStore;
 use rustc_metadata::locator;
 use rustc_metadata::cstore::CStore;
 use rustc::util::common::{time, ErrorReported};
+use rustc_trans_traits::TransCrate;
 
 use serialize::json::ToJson;
 
@@ -155,11 +155,10 @@ pub fn run<F>(run_compiler: F) -> isize
 }
 
 #[cfg(not(feature="llvm"))]
-pub use no_llvm_metadata_loader::NoLLvmMetadataLoader as MetadataLoader;
+pub use trans_metadata_only::MetadataOnlyTransCrate as DefaultTransCrate;
 #[cfg(feature="llvm")]
-pub use rustc_trans::LlvmMetadataLoader as MetadataLoader;
+pub use rustc_trans::LlvmTransCrate as DefaultTransCrate;
 
-#[cfg(not(feature="llvm"))]
 mod no_llvm_metadata_loader {
     extern crate owning_ref;
 
@@ -172,9 +171,9 @@ mod no_llvm_metadata_loader {
     use ar::Archive;
     use self::owning_ref::{OwningRef, ErasedBoxRef};
 
-    pub struct NoLLvmMetadataLoader;
+    pub struct NoLlvmMetadataLoader;
 
-    impl MetadataLoaderTrait for NoLLvmMetadataLoader {
+    impl MetadataLoaderTrait for NoLlvmMetadataLoader {
         fn get_rlib_metadata(
             &self,
             _: &Target,
@@ -210,40 +209,131 @@ mod no_llvm_metadata_loader {
     }
 }
 
-#[cfg(not(feature="llvm"))]
-mod rustc_trans {
-    use syntax_pos::symbol::Symbol;
+mod trans_metadata_only {
+    use std::io::prelude::*;
+    use std::io::Cursor;
+    use std::fs::File;
+
+    use ar::{Builder, Header};
+    use flate2::Compression;
+    use flate2::write::DeflateEncoder;
+
+    use syntax::symbol::Symbol;
+    use rustc::hir::def_id::LOCAL_CRATE;
     use rustc::session::Session;
-    use rustc::session::config::{PrintRequest, OutputFilenames};
+    use rustc::session::config::{OutputFilenames, CrateType};
     use rustc::ty::{TyCtxt, CrateAnalysis};
     use rustc::ty::maps::Providers;
+    use rustc::middle::cstore::{MetadataLoader, EncodedMetadata};
+    use rustc::dep_graph::DepGraph;
     use rustc_incremental::IncrementalHashesMap;
+    use rustc_trans_utils::find_exported_symbols;
+    use rustc_trans_utils::link::{out_filename, build_link_meta};
+    use rustc_trans_traits::TransCrate;
+
+    #[allow(dead_code)]
+    pub struct MetadataOnlyTransCrate;
+    pub struct OngoingCrateTranslation {
+        metadata: EncodedMetadata,
+        metadata_version: Vec<u8>,
+        crate_name: Symbol,
+    }
+    pub struct TranslatedCrate(OngoingCrateTranslation);
+
+    impl MetadataOnlyTransCrate {
+        #[allow(dead_code)]
+        pub fn new(/*_sess: &Session*/) -> Self {
+            MetadataOnlyTransCrate
+        }
+    }
+
+    impl TransCrate for MetadataOnlyTransCrate {
+        type MetadataLoader = ::no_llvm_metadata_loader::NoLlvmMetadataLoader;
+        type OngoingCrateTranslation = OngoingCrateTranslation;
+        type TranslatedCrate = TranslatedCrate;
+
+        fn metadata_loader() -> Box<MetadataLoader> {
+            box ::no_llvm_metadata_loader::NoLlvmMetadataLoader
+        }
+
+        fn provide(_providers: &mut Providers) {}
+
+        fn trans_crate<'a, 'tcx>(
+            tcx: TyCtxt<'a, 'tcx, 'tcx>,
+            analysis: CrateAnalysis,
+            incr_hashes_map: IncrementalHashesMap,
+            _output_filenames: &OutputFilenames
+        ) -> Self::OngoingCrateTranslation {
+            let link_meta = build_link_meta(&incr_hashes_map);
+            let exported_symbols = find_exported_symbols(tcx, &analysis.reachable);
+            let (metadata, _hashes) = tcx.encode_metadata(&link_meta, &exported_symbols);
+
+            OngoingCrateTranslation {
+                metadata: metadata,
+                metadata_version: tcx.metadata_encoding_version().to_vec(),
+                crate_name: tcx.crate_name(LOCAL_CRATE),
+            }
+        }
 
-    use self::back::write::OngoingCrateTranslation;
+        fn join_trans(
+            trans: Self::OngoingCrateTranslation,
+            _sess: &Session,
+            _dep_graph: &DepGraph,
+        ) -> Self::TranslatedCrate {
+            TranslatedCrate(trans)
+        }
+
+        fn link_binary(sess: &Session,
+                       trans: &Self::TranslatedCrate,
+                       outputs: &OutputFilenames) {
+            for &crate_type in sess.opts.crate_types.iter() {
+                if crate_type != CrateType::CrateTypeRlib &&
+                   crate_type != CrateType::CrateTypeDylib {
+                    continue;
+                }
+                let output_name =
+                    out_filename(sess, crate_type, &outputs, &trans.0.crate_name.as_str());
+                let mut compressed = trans.0.metadata_version.clone();
+                let metadata = if crate_type == CrateType::CrateTypeDylib {
+                    DeflateEncoder::new(&mut compressed, Compression::Fast)
+                        .write_all(&trans.0.metadata.raw_data).unwrap();
+                    &compressed
+                } else {
+                    &trans.0.metadata.raw_data
+                };
+                let mut builder = Builder::new(File::create(&output_name).unwrap());
+                let header = Header::new(
+                    "rust.metadata.bin".to_string(),
+                    metadata.len() as u64
+                );
+                builder
+                    .append(&header, Cursor::new(metadata))
+                    .unwrap();
+            }
+        }
+
+        fn dump_incremental_data(_trans: &Self::TranslatedCrate) {}
+    }
+}
+
+#[cfg(not(feature="llvm"))]
+mod rustc_trans {
+    use syntax_pos::symbol::Symbol;
+    use rustc::session::Session;
+    use rustc::session::config::PrintRequest;
+    pub use trans_metadata_only::MetadataOnlyTransCrate as LlvmTransCrate;
 
     pub fn init(_sess: &Session) {}
     pub fn enable_llvm_debug() {}
-    pub fn provide(_providers: &mut Providers) {}
     pub fn print_version() {}
     pub fn print_passes() {}
     pub fn print(_req: PrintRequest, _sess: &Session) {}
     pub fn target_features(_sess: &Session) -> Vec<Symbol> { vec![] }
 
-    pub fn trans_crate<'a, 'tcx>(
-        _tcx: TyCtxt<'a, 'tcx, 'tcx>,
-        _analysis: CrateAnalysis,
-        _incr_hashes_map: IncrementalHashesMap,
-        _output_filenames: &OutputFilenames
-    ) -> OngoingCrateTranslation {
-        OngoingCrateTranslation(())
-    }
-
     pub struct CrateTranslation(());
 
     pub mod back {
         pub mod write {
-            pub struct OngoingCrateTranslation(pub (in ::rustc_trans) ());
-
             pub const RELOC_MODEL_ARGS: [(&'static str, ()); 0] = [];
             pub const CODE_GEN_MODEL_ARGS: [(&'static str, ()); 0] = [];
         }
@@ -297,7 +387,7 @@ pub fn run_compiler<'a>(args: &[String],
         },
     };
 
-    let cstore = Rc::new(CStore::new(box ::MetadataLoader));
+    let cstore = Rc::new(CStore::new(DefaultTransCrate::metadata_loader()));
 
     let loader = file_loader.unwrap_or(box RealFileLoader);
     let codemap = Rc::new(CodeMap::with_file_loader(loader, sopts.file_path_mapping()));