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