src/librustc_trans_utils/trans_crate.rs

   1 // Copyright 2014-2015 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.
   4 //
   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.
  10
  11 //! The Rust compiler.
  12 //!
  13 //! # Note
  14 //!
  15 //! This API is completely unstable and subject to change.
  16
  17 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
  18       html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
  19       html_root_url = "https://doc.rust-lang.org/nightly/")]
  20 #![deny(warnings)]
  21
  22 #![feature(box_syntax)]
  23
  24 use std::any::Any;
  25 use std::io::prelude::*;
  26 use std::io::{self, Cursor};
  27 use std::fs::File;
  28 use std::path::Path;
  29 use std::sync::mpsc;
  30
  31 use rustc_data_structures::owning_ref::{ErasedBoxRef, OwningRef};
  32 use rustc_data_structures::sync::Lrc;
  33 use ar::{Archive, Builder, Header};
  34 use flate2::Compression;
  35 use flate2::write::DeflateEncoder;
  36
  37 use syntax::symbol::Symbol;
  38 use rustc::hir::def_id::LOCAL_CRATE;
  39 use rustc::session::{Session, CompileIncomplete};
  40 use rustc::session::config::{CrateType, OutputFilenames, PrintRequest};
  41 use rustc::ty::TyCtxt;
  42 use rustc::ty::maps::Providers;
  43 use rustc::middle::cstore::EncodedMetadata;
  44 use rustc::middle::cstore::MetadataLoader;
  45 use rustc::dep_graph::DepGraph;
  46 use rustc_back::target::Target;
  47 use rustc_data_structures::fx::FxHashSet;
  48 use rustc_mir::monomorphize::collector;
  49 use link::{build_link_meta, out_filename};
  50
  51 pub trait TransCrate {
  52     fn init(&self, _sess: &Session) {}
  53     fn print(&self, _req: PrintRequest, _sess: &Session) {}
  54     fn target_features(&self, _sess: &Session) -> Vec<Symbol> { vec![] }
  55     fn print_passes(&self) {}
  56     fn print_version(&self) {}
  57     fn diagnostics(&self) -> &[(&'static str, &'static str)] { &[] }
  58
  59     fn metadata_loader(&self) -> Box<MetadataLoader>;
  60     fn provide(&self, _providers: &mut Providers);
  61     fn provide_extern(&self, _providers: &mut Providers);
  62     fn trans_crate<'a, 'tcx>(
  63         &self,
  64         tcx: TyCtxt<'a, 'tcx, 'tcx>,
  65         rx: mpsc::Receiver<Box<Any + Send>>
  66     ) -> Box<Any>;
  67
  68     /// This is called on the returned `Box<Any>` from `trans_crate`
  69     ///
  70     /// # Panics
  71     ///
  72     /// Panics when the passed `Box<Any>` was not returned by `trans_crate`.
  73     fn join_trans_and_link(
  74         &self,
  75         trans: Box<Any>,
  76         sess: &Session,
  77         dep_graph: &DepGraph,
  78         outputs: &OutputFilenames,
  79     ) -> Result<(), CompileIncomplete>;
  80 }
  81
  82 pub struct DummyTransCrate;
  83
  84 impl TransCrate for DummyTransCrate {
  85     fn metadata_loader(&self) -> Box<MetadataLoader> {
  86         box DummyMetadataLoader(())
  87     }
  88
  89     fn provide(&self, _providers: &mut Providers) {
  90         bug!("DummyTransCrate::provide");
  91     }
  92
  93     fn provide_extern(&self, _providers: &mut Providers) {
  94         bug!("DummyTransCrate::provide_extern");
  95     }
  96
  97     fn trans_crate<'a, 'tcx>(
  98         &self,
  99         _tcx: TyCtxt<'a, 'tcx, 'tcx>,
 100         _rx: mpsc::Receiver<Box<Any + Send>>
 101     ) -> Box<Any> {
 102         bug!("DummyTransCrate::trans_crate");
 103     }
 104
 105     fn join_trans_and_link(
 106         &self,
 107         _trans: Box<Any>,
 108         _sess: &Session,
 109         _dep_graph: &DepGraph,
 110         _outputs: &OutputFilenames,
 111     ) -> Result<(), CompileIncomplete> {
 112         bug!("DummyTransCrate::join_trans_and_link");
 113     }
 114 }
 115
 116 pub struct DummyMetadataLoader(());
 117
 118 impl MetadataLoader for DummyMetadataLoader {
 119     fn get_rlib_metadata(
 120         &self,
 121         _target: &Target,
 122         _filename: &Path
 123     ) -> Result<ErasedBoxRef<[u8]>, String> {
 124         bug!("DummyMetadataLoader::get_rlib_metadata");
 125     }
 126
 127     fn get_dylib_metadata(
 128         &self,
 129         _target: &Target,
 130         _filename: &Path
 131     ) -> Result<ErasedBoxRef<[u8]>, String> {
 132         bug!("DummyMetadataLoader::get_dylib_metadata");
 133     }
 134 }
 135
 136 pub struct NoLlvmMetadataLoader;
 137
 138 impl MetadataLoader for NoLlvmMetadataLoader {
 139     fn get_rlib_metadata(&self, _: &Target, filename: &Path) -> Result<ErasedBoxRef<[u8]>, String> {
 140         let file = File::open(filename)
 141             .map_err(|e| format!("metadata file open err: {:?}", e))?;
 142         let mut archive = Archive::new(file);
 143
 144         while let Some(entry_result) = archive.next_entry() {
 145             let mut entry = entry_result
 146                 .map_err(|e| format!("metadata section read err: {:?}", e))?;
 147             if entry.header().identifier() == "rust.metadata.bin" {
 148                 let mut buf = Vec::new();
 149                 io::copy(&mut entry, &mut buf).unwrap();
 150                 let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf).into();
 151                 return Ok(buf.map_owner_box().erase_owner());
 152             }
 153         }
 154
 155         Err("Couldn't find metadata section".to_string())
 156     }
 157
 158     fn get_dylib_metadata(
 159         &self,
 160         _target: &Target,
 161         _filename: &Path,
 162     ) -> Result<ErasedBoxRef<[u8]>, String> {
 163         // FIXME: Support reading dylibs from llvm enabled rustc
 164         self.get_rlib_metadata(_target, _filename)
 165     }
 166 }
 167
 168 pub struct MetadataOnlyTransCrate(());
 169 pub struct OngoingCrateTranslation {
 170     metadata: EncodedMetadata,
 171     metadata_version: Vec<u8>,
 172     crate_name: Symbol,
 173 }
 174
 175 impl MetadataOnlyTransCrate {
 176     pub fn new() -> Box<TransCrate> {
 177         box MetadataOnlyTransCrate(())
 178     }
 179 }
 180
 181 impl TransCrate for MetadataOnlyTransCrate {
 182     fn init(&self, sess: &Session) {
 183         for cty in sess.opts.crate_types.iter() {
 184             match *cty {
 185                 CrateType::CrateTypeRlib | CrateType::CrateTypeDylib |
 186                 CrateType::CrateTypeExecutable => {},
 187                 _ => {
 188                     sess.parse_sess.span_diagnostic.warn(
 189                         &format!("LLVM unsupported, so output type {} is not supported", cty)
 190                     );
 191                 },
 192             }
 193         }
 194     }
 195
 196     fn metadata_loader(&self) -> Box<MetadataLoader> {
 197         box NoLlvmMetadataLoader
 198     }
 199
 200     fn provide(&self, providers: &mut Providers) {
 201         ::symbol_names::provide(providers);
 202
 203         providers.target_features_whitelist = |_tcx, _cnum| {
 204             Lrc::new(FxHashSet()) // Just a dummy
 205         };
 206     }
 207     fn provide_extern(&self, _providers: &mut Providers) {}
 208
 209     fn trans_crate<'a, 'tcx>(
 210         &self,
 211         tcx: TyCtxt<'a, 'tcx, 'tcx>,
 212         _rx: mpsc::Receiver<Box<Any + Send>>
 213     ) -> Box<Any> {
 214         use rustc_mir::monomorphize::item::MonoItem;
 215
 216         ::check_for_rustc_errors_attr(tcx);
 217         ::symbol_names_test::report_symbol_names(tcx);
 218         ::rustc_incremental::assert_dep_graph(tcx);
 219         ::rustc_incremental::assert_module_sources::assert_module_sources(tcx);
 220         ::rustc_mir::monomorphize::assert_symbols_are_distinct(tcx,
 221             collector::collect_crate_mono_items(
 222                 tcx,
 223                 collector::MonoItemCollectionMode::Eager
 224             ).0.iter()
 225         );
 226         ::rustc::middle::dependency_format::calculate(tcx);
 227         let _ = tcx.link_args(LOCAL_CRATE);
 228         let _ = tcx.native_libraries(LOCAL_CRATE);
 229         for trans_item in
 230             collector::collect_crate_mono_items(
 231                 tcx,
 232                 collector::MonoItemCollectionMode::Eager
 233             ).0 {
 234             match trans_item {
 235                 MonoItem::Fn(inst) => {
 236                     let def_id = inst.def_id();
 237                     if def_id.is_local()  {
 238                         let _ = inst.def.is_inline(tcx);
 239                         let _ = tcx.trans_fn_attrs(def_id);
 240                     }
 241                 }
 242                 _ => {}
 243             }
 244         }
 245         tcx.sess.abort_if_errors();
 246
 247         let link_meta = build_link_meta(tcx.crate_hash(LOCAL_CRATE));
 248         let metadata = tcx.encode_metadata(&link_meta);
 249
 250         box OngoingCrateTranslation {
 251             metadata: metadata,
 252             metadata_version: tcx.metadata_encoding_version().to_vec(),
 253             crate_name: tcx.crate_name(LOCAL_CRATE),
 254         }
 255     }
 256
 257     fn join_trans_and_link(
 258         &self,
 259         trans: Box<Any>,
 260         sess: &Session,
 261         _dep_graph: &DepGraph,
 262         outputs: &OutputFilenames,
 263     ) -> Result<(), CompileIncomplete> {
 264         let trans = trans.downcast::<OngoingCrateTranslation>()
 265             .expect("Expected MetadataOnlyTransCrate's OngoingCrateTranslation, found Box<Any>");
 266         for &crate_type in sess.opts.crate_types.iter() {
 267             if crate_type != CrateType::CrateTypeRlib && crate_type != CrateType::CrateTypeDylib {
 268                 continue;
 269             }
 270             let output_name =
 271                 out_filename(sess, crate_type, &outputs, &trans.crate_name.as_str());
 272             let mut compressed = trans.metadata_version.clone();
 273             let metadata = if crate_type == CrateType::CrateTypeDylib {
 274                 DeflateEncoder::new(&mut compressed, Compression::fast())
 275                     .write_all(&trans.metadata.raw_data)
 276                     .unwrap();
 277                 &compressed
 278             } else {
 279                 &trans.metadata.raw_data
 280             };
 281             let mut builder = Builder::new(File::create(&output_name).unwrap());
 282             let header = Header::new("rust.metadata.bin".to_string(), metadata.len() as u64);
 283             builder.append(&header, Cursor::new(metadata)).unwrap();
 284         }
 285
 286         sess.abort_if_errors();
 287         if !sess.opts.crate_types.contains(&CrateType::CrateTypeRlib)
 288             && !sess.opts.crate_types.contains(&CrateType::CrateTypeDylib)
 289         {
 290             sess.fatal("Executables are not supported by the metadata-only backend.");
 291         }
 292         Ok(())
 293     }
 294 }