// No linkage happens with rlibs, we just needed the metadata (which we
// got long ago), so don't bother with anything.
- config::CrateTypeRlib => return Vec::new(),
+ config::CrateTypeRlib | config::CrateTypeMetadata => return Vec::new(),
// Staticlibs and cdylibs must have all static dependencies. If any fail
// to be found, we generate some nice pretty errors.
fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> ReachableContext<'a, 'tcx> {
let any_library = tcx.sess.crate_types.borrow().iter().any(|ty| {
*ty == config::CrateTypeRlib || *ty == config::CrateTypeDylib ||
- *ty == config::CrateTypeProcMacro
+ *ty == config::CrateTypeProcMacro || *ty == config::CrateTypeMetadata
});
ReachableContext {
tcx: tcx,
config::CrateTypeCdylib |
config::CrateTypeExecutable |
config::CrateTypeStaticlib => true,
- config::CrateTypeRlib => false,
+ config::CrateTypeRlib |
+ config::CrateTypeMetadata => false,
}
});
if !needs_check {
DepInfo,
}
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum ErrorOutputType {
- HumanReadable(ColorConfig),
- Json,
-}
-
-impl Default for ErrorOutputType {
- fn default() -> ErrorOutputType {
- ErrorOutputType::HumanReadable(ColorConfig::Auto)
- }
-}
-
impl OutputType {
fn is_compatible_with_codegen_units_and_single_output_file(&self) -> bool {
match *self {
}
}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ErrorOutputType {
+ HumanReadable(ColorConfig),
+ Json,
+}
+
+impl Default for ErrorOutputType {
+ fn default() -> ErrorOutputType {
+ ErrorOutputType::HumanReadable(ColorConfig::Auto)
+ }
+}
+
// Use tree-based collections to cheaply get a deterministic Hash implementation.
// DO NOT switch BTreeMap out for an unsorted container type! That would break
// dependency tracking for commandline arguments.
CrateTypeStaticlib,
CrateTypeCdylib,
CrateTypeProcMacro,
+ CrateTypeMetadata,
}
#[derive(Clone, Hash)]
assumed.", "[KIND=]NAME"),
opt::multi_s("", "crate-type", "Comma separated list of types of crates
for the compiler to emit",
- "[bin|lib|rlib|dylib|cdylib|staticlib]"),
+ "[bin|lib|rlib|dylib|cdylib|staticlib|metadata]"),
opt::opt_s("", "crate-name", "Specify the name of the crate being built",
"NAME"),
opt::multi_s("", "emit", "Comma separated list of types of output for \
"cdylib" => CrateTypeCdylib,
"bin" => CrateTypeExecutable,
"proc-macro" => CrateTypeProcMacro,
+ "metadata" => CrateTypeMetadata,
_ => {
return Err(format!("unknown crate type: `{}`",
part));
CrateTypeStaticlib => "staticlib".fmt(f),
CrateTypeCdylib => "cdylib".fmt(f),
CrateTypeProcMacro => "proc-macro".fmt(f),
+ CrateTypeMetadata => "rmeta".fmt(f),
}
}
}
"serialize work products",
move || rustc_incremental::save_work_products(sess));
+ println!("finish phase 5: {}", sess.err_count());
if sess.err_count() > 0 {
Err(sess.err_count())
} else {
config::CrateTypeProcMacro |
config::CrateTypeCdylib |
config::CrateTypeStaticlib => need_lib_alloc = true,
- config::CrateTypeRlib => {}
+ config::CrateTypeRlib |
+ config::CrateTypeMetadata => {}
}
}
if !need_lib_alloc && !need_exe_alloc { return }
}
fn llvm_archive_kind(&self) -> Result<ArchiveKind, &str> {
- let kind = &self.config.sess.target.target.options.archive_format[..];
+ let kind = &*self.config.sess.target.target.options.archive_format;
kind.parse().map_err(|_| kind)
}
let mut out_filenames = Vec::new();
for &crate_type in sess.crate_types.borrow().iter() {
// Ignore executable crates if we have -Z no-trans, as they will error.
+ // TODO do we need to check for CrateTypeMetadata here?
if sess.opts.debugging_opts.no_trans &&
crate_type == config::CrateTypeExecutable {
continue;
config::CrateTypeRlib => {
outputs.out_directory.join(&format!("lib{}.rlib", libname))
}
+ config::CrateTypeMetadata => {
+ outputs.out_directory.join(&format!("lib{}.rmeta", libname))
+ }
config::CrateTypeCdylib |
config::CrateTypeProcMacro |
config::CrateTypeDylib => {
outputs: &OutputFilenames,
crate_name: &str) -> PathBuf {
let objects = object_filenames(trans, outputs);
+ println!("objects: {:?}", objects);
let default_filename = filename_for_input(sess, crate_type, crate_name,
outputs);
let out_filename = outputs.outputs.get(&OutputType::Exe)
};
match crate_type {
- config::CrateTypeRlib => {
+ config::CrateTypeRlib | config::CrateTypeMetadata => {
link_rlib(sess, Some(trans), &objects, &out_filename,
tmpdir.path()).build();
}
tmpdir: &Path) -> ArchiveBuilder<'a> {
info!("preparing rlib from {:?} to {:?}", objects, out_filename);
let mut ab = ArchiveBuilder::new(archive_config(sess, out_filename, None));
+
for obj in objects {
ab.add_file(obj);
}
// Whenever an rlib is created, the bitcode is inserted into the
// archive in order to allow LTO against it.
let needs_crate_bitcode =
- sess.crate_types.borrow().contains(&config::CrateTypeRlib) &&
- sess.opts.output_types.contains_key(&OutputType::Exe);
+ (sess.crate_types.borrow().contains(&config::CrateTypeRlib) &&
+ sess.opts.output_types.contains_key(&OutputType::Exe)) ||
+ sess.crate_types.borrow().contains(&config::CrateTypeMetadata);
let needs_crate_object =
- sess.opts.output_types.contains_key(&OutputType::Exe);
+ sess.opts.output_types.contains_key(&OutputType::Exe) ||
+ sess.crate_types.borrow().contains(&config::CrateTypeMetadata);
if needs_crate_bitcode {
modules_config.emit_bc = true;
}
use rustc::dep_graph::{DepNode, WorkProduct};
use rustc::hir::map as hir_map;
use rustc::util::common::time;
-use session::config::{self, NoDebugInfo};
+use session::config::{self, NoDebugInfo, OutputType};
use rustc_incremental::IncrementalHashesMap;
use session::Session;
use abi::{self, Abi, FnType};
config::CrateTypeStaticlib |
config::CrateTypeCdylib => MetadataKind::None,
- config::CrateTypeRlib => MetadataKind::Uncompressed,
+ config::CrateTypeRlib |
+ config::CrateTypeMetadata => MetadataKind::Uncompressed,
config::CrateTypeDylib |
config::CrateTypeProcMacro => MetadataKind::Compressed,
assert_module_sources::assert_module_sources(tcx, &modules);
// Skip crate items and just output metadata in -Z no-trans mode.
- if tcx.sess.opts.debugging_opts.no_trans {
+ if tcx.sess.opts.debugging_opts.no_trans ||
+ tcx.sess.crate_types.borrow().iter().all(|ct| ct == &config::CrateTypeMetadata) {
let linker_info = LinkerInfo::new(&shared_ccx, &[]);
return CrateTranslation {
modules: modules,
// FIXME (#9639): This needs to handle non-utf8 paths
let mut args = vec!["-".to_owned(),
- "-Zno-trans".to_owned(),
+ "--emit".to_owned(),
+ "metadata".to_owned(),
"--out-dir".to_owned(),
out_dir.to_str().unwrap().to_owned(),
format!("--target={}", target),