diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 4a28872b1b8d..39c9ac32801c 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -242,7 +242,7 @@ impl<'a> CrateReader<'a> { // We're also sure to compare *paths*, not actual byte slices. The // `source` stores paths which are normalized which may be different // from the strings on the command line. - let source = self.sess.cstore.get_used_crate_source(cnum).unwrap(); + let source = self.sess.cstore.do_get_used_crate_source(cnum).unwrap(); if let Some(locs) = self.sess.opts.externs.get(name) { let found = locs.iter().any(|l| { let l = fs::canonicalize(l).ok(); @@ -414,7 +414,7 @@ impl<'a> CrateReader<'a> { if explicitly_linked && !data.explicitly_linked.get() { data.explicitly_linked.set(explicitly_linked); } - (cnum, data, self.sess.cstore.get_used_crate_source(cnum).unwrap()) + (cnum, data, self.sess.cstore.do_get_used_crate_source(cnum).unwrap()) } LookupResult::Loaded(library) => { self.register_crate(root, ident, name, span, library, diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 873c22c35d85..6cfec87e7049 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -159,7 +159,7 @@ impl CStore { I: FnMut(ast::CrateNum, &crate_metadata, Option), { for (&k, v) in self.metas.borrow().iter() { - let origin = self.get_used_crate_source(k); + let origin = self.do_get_used_crate_source(k); origin.as_ref().map(|cs| { assert!(k == cs.cnum); }); i(k, &**v, origin); } @@ -172,8 +172,9 @@ impl CStore { } } - pub fn get_used_crate_source(&self, cnum: ast::CrateNum) - -> Option { + // TODO: killdo + pub fn do_get_used_crate_source(&self, cnum: ast::CrateNum) + -> Option { self.used_crate_sources.borrow_mut() .iter().find(|source| source.cnum == cnum).cloned() } @@ -196,8 +197,9 @@ impl CStore { // In order to get this left-to-right dependency ordering, we perform a // topological sort of all crates putting the leaves at the right-most // positions. - pub fn get_used_crates(&self, prefer: LinkagePreference) - -> Vec<(ast::CrateNum, Option)> { + // TODO: killdo + pub fn do_get_used_crates(&self, prefer: LinkagePreference) + -> Vec<(ast::CrateNum, Option)> { let mut ordering = Vec::new(); fn visit(cstore: &CStore, cnum: ast::CrateNum, ordering: &mut Vec) { diff --git a/src/librustc/metadata/util.rs b/src/librustc/metadata/util.rs index d78d580daa0d..23ae8df0e97b 100644 --- a/src/librustc/metadata/util.rs +++ b/src/librustc/metadata/util.rs @@ -11,24 +11,36 @@ use front::map as ast_map; use metadata::cstore; use metadata::decoder; +use metadata::encoder; +use metadata::loader; use middle::astencode; +use middle::def; use middle::lang_items; -use middle::ty; +use middle::ty::{self, Ty}; use middle::def_id::{DefId, DefIndex}; +use util::nodemap::{NodeMap, NodeSet}; use std::any::Any; +use std::cell::RefCell; use std::rc::Rc; +use std::path::PathBuf; use syntax::ast; use syntax::attr; +use rustc_back::target::Target; use rustc_front::hir; +pub use metadata::common::LinkMeta; +pub use metadata::creader::validate_crate_name; pub use metadata::csearch::FoundAst; +pub use metadata::cstore::CrateSource; pub use metadata::cstore::LinkagePreference; +pub use metadata::cstore::NativeLibraryKind; pub use metadata::decoder::DecodeInlinedItem; pub use metadata::decoder::DefLike; pub use metadata::inline::InlinedItem; pub use self::DefLike::{DlDef, DlField, DlImpl}; +pub use self::NativeLibraryKind::{NativeStatic, NativeFramework, NativeUnknown}; pub struct ChildItem { pub def: DefLike, @@ -54,6 +66,7 @@ pub trait CrateStore<'tcx> : Any { fn item_super_predicates(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::GenericPredicates<'tcx>; fn item_attrs(&self, def_id: DefId) -> Vec; + fn item_symbol(&self, def: DefId) -> String; fn trait_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId)-> ty::TraitDef<'tcx>; fn adt_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::AdtDefMaster<'tcx>; fn inherent_implementations_for_type(&self, def_id: DefId) -> Vec; @@ -86,14 +99,21 @@ pub trait CrateStore<'tcx> : Any { fn is_defaulted_trait(&self, did: DefId) -> bool; fn is_impl(&self, did: DefId) -> bool; fn is_static_method(&self, did: DefId) -> bool; + fn is_extern_fn(&self, tcx: &ty::ctxt<'tcx>, did: DefId) -> bool; + fn is_static(&self, did: DefId) -> bool; - // metadata + // crate metadata fn dylib_dependency_formats(&self, cnum: ast::CrateNum) -> Vec<(ast::CrateNum, LinkagePreference)>; fn lang_items(&self, cnum: ast::CrateNum) -> Vec<(DefIndex, usize)>; fn missing_lang_items(&self, cnum: ast::CrateNum) -> Vec; fn is_staged_api(&self, cnum: ast::CrateNum) -> bool; + fn is_explicitly_linked(&self, cnum: ast::CrateNum) -> bool; + fn is_allocator(&self, cnum: ast::CrateNum) -> bool; + fn crate_name(&self, cnum: ast::CrateNum) -> String; fn plugin_registrar_fn(&self, cnum: ast::CrateNum) -> Option; + fn native_libraries(&self, cnum: ast::CrateNum) -> Vec<(NativeLibraryKind, String)>; + fn reachable_ids(&self, cnum: ast::CrateNum) -> Vec; // resolve fn def_path(&self, def: DefId) -> ast_map::DefPath; @@ -102,9 +122,24 @@ pub trait CrateStore<'tcx> : Any { fn item_children(&self, did: DefId) -> Vec; fn crate_top_level_items(&self, cnum: ast::CrateNum) -> Vec; - // misc. + // misc. metadata fn maybe_get_item_ast(&'tcx self, tcx: &ty::ctxt<'tcx>, def: DefId) -> FoundAst<'tcx>; + + // utility functions + fn metadata_filename(&self) -> &str; + fn metadata_section_name(&self, target: &Target) -> &str; + fn encode_type(&self, tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Vec; + fn used_crates(&self, prefer: LinkagePreference) -> Vec<(ast::CrateNum, Option)>; + fn used_crate_source(&self, cnum: ast::CrateNum) -> CrateSource; + fn encode_metadata(&self, + tcx: &ty::ctxt<'tcx>, + reexports: &def::ExportMap, + item_symbols: &RefCell>, + link_meta: &LinkMeta, + reachable: &NodeSet, + krate: &hir::Crate) -> Vec; + fn metadata_encoding_version(&self) -> &[u8]; } impl<'tcx> CrateStore<'tcx> for cstore::CStore { @@ -165,6 +200,12 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore { decoder::get_item_attrs(&*cdata, def_id.index) } + fn item_symbol(&self, def: DefId) -> String + { + let cdata = self.get_crate_data(def.krate); + decoder::get_symbol(&cdata, def.index) + } + fn trait_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::TraitDef<'tcx> { let cdata = self.get_crate_data(def.krate); @@ -285,21 +326,36 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore { decoder::is_const_fn(&cdata, did.index) } - fn is_defaulted_trait(&self, trait_def_id: DefId) -> bool { + fn is_defaulted_trait(&self, trait_def_id: DefId) -> bool + { let cdata = self.get_crate_data(trait_def_id.krate); decoder::is_defaulted_trait(&*cdata, trait_def_id.index) } - fn is_impl(&self, did: DefId) -> bool { + fn is_impl(&self, did: DefId) -> bool + { let cdata = self.get_crate_data(did.krate); decoder::is_impl(&*cdata, did.index) } - fn is_static_method(&self, def: DefId) -> bool { + fn is_static_method(&self, def: DefId) -> bool + { let cdata = self.get_crate_data(def.krate); decoder::is_static_method(&*cdata, def.index) } + fn is_extern_fn(&self, tcx: &ty::ctxt<'tcx>, did: DefId) -> bool + { + let cdata = self.get_crate_data(did.krate); + decoder::is_extern_fn(&*cdata, did.index, tcx) + } + + fn is_static(&self, did: DefId) -> bool + { + let cdata = self.get_crate_data(did.krate); + decoder::is_static(&*cdata, did.index) + } + fn dylib_dependency_formats(&self, cnum: ast::CrateNum) -> Vec<(ast::CrateNum, LinkagePreference)> { @@ -329,6 +385,21 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore { self.get_crate_data(cnum).staged_api } + fn is_explicitly_linked(&self, cnum: ast::CrateNum) -> bool + { + self.get_crate_data(cnum).explicitly_linked.get() + } + + fn is_allocator(&self, cnum: ast::CrateNum) -> bool + { + self.get_crate_data(cnum).is_allocator() + } + + fn crate_name(&self, cnum: ast::CrateNum) -> String + { + self.get_crate_data(cnum).name.clone() + } + fn plugin_registrar_fn(&self, cnum: ast::CrateNum) -> Option { let cdata = self.get_crate_data(cnum); @@ -338,6 +409,18 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore { }) } + fn native_libraries(&self, cnum: ast::CrateNum) -> Vec<(NativeLibraryKind, String)> + { + let cdata = self.get_crate_data(cnum); + decoder::get_native_libraries(&*cdata) + } + + fn reachable_ids(&self, cnum: ast::CrateNum) -> Vec + { + let cdata = self.get_crate_data(cnum); + decoder::get_reachable_ids(&*cdata) + } + fn def_path(&self, def: DefId) -> ast_map::DefPath { let cdata = self.get_crate_data(def.krate); @@ -396,4 +479,58 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore { let decode_inlined_item = Box::new(astencode::decode_inlined_item); decoder::maybe_get_item_ast(&*cdata, tcx, def.index, decode_inlined_item) } + + fn metadata_filename(&self) -> &str + { + loader::METADATA_FILENAME + } + + fn metadata_section_name(&self, target: &Target) -> &str + { + loader::meta_section_name(target) + } + fn encode_type(&self, tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Vec + { + encoder::encoded_ty(tcx, ty) + } + + fn used_crates(&self, prefer: LinkagePreference) -> Vec<(ast::CrateNum, Option)> + { + self.do_get_used_crates(prefer) + } + + fn used_crate_source(&self, cnum: ast::CrateNum) -> CrateSource + { + self.do_get_used_crate_source(cnum).unwrap() + } + + fn encode_metadata(&self, + tcx: &ty::ctxt<'tcx>, + reexports: &def::ExportMap, + item_symbols: &RefCell>, + link_meta: &LinkMeta, + reachable: &NodeSet, + krate: &hir::Crate) -> Vec + { + let encode_inlined_item: encoder::EncodeInlinedItem = + Box::new(|ecx, rbml_w, ii| astencode::encode_inlined_item(ecx, rbml_w, ii)); + + let encode_params = encoder::EncodeParams { + diag: tcx.sess.diagnostic(), + tcx: tcx, + reexports: reexports, + item_symbols: item_symbols, + link_meta: link_meta, + cstore: self, + encode_inlined_item: encode_inlined_item, + reachable: reachable + }; + encoder::encode_metadata(encode_params, krate) + + } + + fn metadata_encoding_version(&self) -> &[u8] + { + encoder::metadata_encoding_version + } } diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 3be95d54ce54..786d2a8b81f0 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -124,7 +124,7 @@ fn calculate_type(sess: &session::Session, None => {} } sess.cstore.iter_crate_data(|cnum, data| { - let src = sess.cstore.get_used_crate_source(cnum).unwrap(); + let src = sess.cstore.used_crate_source(cnum); if src.rlib.is_some() { return } sess.err(&format!("dependency `{}` not found in rlib format", data.name)); @@ -152,14 +152,14 @@ fn calculate_type(sess: &session::Session, // dependencies, ensuring there are no conflicts. The only valid case for a // dependency to be relied upon twice is for both cases to rely on a dylib. sess.cstore.iter_crate_data(|cnum, data| { - let src = sess.cstore.get_used_crate_source(cnum).unwrap(); + let src = sess.cstore.used_crate_source(cnum); if src.dylib.is_some() { info!("adding dylib: {}", data.name); add_library(sess, cnum, RequireDynamic, &mut formats); let deps = sess.cstore.dylib_dependency_formats(cnum); for &(depnum, style) in &deps { info!("adding {:?}: {}", style, - sess.cstore.get_crate_data(depnum).name.clone()); + sess.cstore.crate_name(depnum)); add_library(sess, depnum, style, &mut formats); } } @@ -180,7 +180,7 @@ fn calculate_type(sess: &session::Session, // If the crate hasn't been included yet and it's not actually required // (e.g. it's an allocator) then we skip it here as well. sess.cstore.iter_crate_data(|cnum, data| { - let src = sess.cstore.get_used_crate_source(cnum).unwrap(); + let src = sess.cstore.used_crate_source(cnum); if src.dylib.is_none() && !formats.contains_key(&cnum) && data.explicitly_linked.get() { @@ -205,7 +205,7 @@ fn calculate_type(sess: &session::Session, // making sure that everything is available in the requested format. for (cnum, kind) in ret.iter().enumerate() { let cnum = (cnum + 1) as ast::CrateNum; - let src = sess.cstore.get_used_crate_source(cnum).unwrap(); + let src = sess.cstore.used_crate_source(cnum); match *kind { Linkage::NotLinked | Linkage::IncludedFromDylib => {} @@ -216,10 +216,10 @@ fn calculate_type(sess: &session::Session, Linkage::Static => "rlib", _ => "dylib", }; - let data = sess.cstore.get_crate_data(cnum); + let name = sess.cstore.crate_name(cnum); sess.err(&format!("crate `{}` required to be available in {}, \ but it was not available in this form", - data.name, kind)); + name, kind)); } } } @@ -241,9 +241,8 @@ fn add_library(sess: &session::Session, // This error is probably a little obscure, but I imagine that it // can be refined over time. if link2 != link || link == RequireStatic { - let data = sess.cstore.get_crate_data(cnum); sess.err(&format!("cannot satisfy dependencies so `{}` only \ - shows up once", data.name)); + shows up once", sess.cstore.crate_name(cnum))); sess.help("having upstream crates all available in one format \ will likely make this go away"); } @@ -253,7 +252,7 @@ fn add_library(sess: &session::Session, } fn attempt_static(sess: &session::Session) -> Option { - let crates = sess.cstore.get_used_crates(RequireStatic); + let crates = sess.cstore.used_crates(RequireStatic); if !crates.iter().by_ref().all(|&(_, ref p)| p.is_some()) { return None } @@ -261,7 +260,7 @@ fn attempt_static(sess: &session::Session) -> Option { // All crates are available in an rlib format, so we're just going to link // everything in explicitly so long as it's actually required. let mut ret = (1..sess.cstore.next_crate_num()).map(|cnum| { - if sess.cstore.get_crate_data(cnum).explicitly_linked.get() { + if sess.cstore.is_explicitly_linked(cnum) { Linkage::Static } else { Linkage::NotLinked @@ -288,7 +287,7 @@ fn activate_allocator(sess: &session::Session, list: &mut DependencyList) { let mut allocator_found = false; for (i, slot) in list.iter().enumerate() { let cnum = (i + 1) as ast::CrateNum; - if !sess.cstore.get_crate_data(cnum).is_allocator() { + if !sess.cstore.is_allocator(cnum) { continue } if let Linkage::NotLinked = *slot { @@ -314,18 +313,18 @@ fn verify_ok(sess: &session::Session, list: &[Linkage]) { let mut allocator = None; for (i, linkage) in list.iter().enumerate() { let cnum = (i + 1) as ast::CrateNum; - let data = sess.cstore.get_crate_data(cnum); - if !data.is_allocator() { + if !sess.cstore.is_allocator(cnum) { continue } if let Linkage::NotLinked = *linkage { continue } if let Some(prev_alloc) = allocator { - let prev = sess.cstore.get_crate_data(prev_alloc); + let prev_name = sess.cstore.crate_name(prev_alloc); + let cur_name = sess.cstore.crate_name(cnum); sess.err(&format!("cannot link together two \ allocators: {} and {}", - prev.name(), data.name())); + prev_name, cur_name)); } allocator = Some(cnum); } diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index 1b118520339e..5101e69204d1 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -76,6 +76,7 @@ use front::map as ast_map; use rustc_front::hir; use rustc_front::print::pprust; +use metadata::util::CrateStore; use middle::def; use middle::def_id::DefId; use middle::infer::{self, TypeOrigin}; @@ -498,8 +499,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { // We compare strings because PathMod and PathName can be different // for imported and non-imported crates if exp_path == found_path { - let crate_name = self.tcx.sess.cstore - .get_crate_data(did1.krate).name(); + let crate_name = self.tcx.sess.cstore.crate_name(did1.krate); self.tcx.sess.span_note(sp, &format!("Perhaps two different versions \ of crate `{}` are being used?", crate_name)); diff --git a/src/librustc_trans/back/archive.rs b/src/librustc_trans/back/archive.rs index 1b3242eb97d3..d7f9002a4f45 100644 --- a/src/librustc_trans/back/archive.rs +++ b/src/librustc_trans/back/archive.rs @@ -21,10 +21,11 @@ use std::process::{Command, Output, Stdio}; use std::ptr; use std::str; +use metadata::util::CrateStore; + use libc; use llvm::archive_ro::{ArchiveRO, Child}; use llvm::{self, ArchiveKind}; -use rustc::metadata::loader::METADATA_FILENAME; use rustc::session::Session; use rustc_back::tempdir::TempDir; @@ -169,11 +170,13 @@ impl<'a> ArchiveBuilder<'a> { // Ignoring all bytecode files, no matter of // name let bc_ext = ".bytecode.deflate"; + let metadata_filename = + self.config.sess.cstore.metadata_filename().to_owned(); self.add_archive(rlib, &name[..], move |fname: &str| { let skip_obj = lto && fname.starts_with(&obj_start) && fname.ends_with(".o"); - skip_obj || fname.ends_with(bc_ext) || fname == METADATA_FILENAME + skip_obj || fname.ends_with(bc_ext) || fname == metadata_filename }) } diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index e0cbdbeaef3e..621c99a87171 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -19,9 +19,10 @@ use session::config::NoDebugInfo; use session::config::{OutputFilenames, Input, OutputType}; use session::search_paths::PathKind; use session::Session; -use metadata::common::LinkMeta; -use metadata::loader::METADATA_FILENAME; -use metadata::{encoder, cstore, filesearch, csearch, creader}; +use metadata::{util as mdutil}; +use metadata::filesearch; +use metadata::util::{CrateStore, LinkMeta}; +use metadata::util::{LinkagePreference, NativeLibraryKind}; use middle::dependency_format::Linkage; use middle::ty::{self, Ty}; use rustc::front::map::DefPath; @@ -137,7 +138,7 @@ pub fn find_crate_name(sess: Option<&Session>, attrs: &[ast::Attribute], input: &Input) -> String { let validate = |s: String, span: Option| { - creader::validate_crate_name(sess, &s[..], span); + mdutil::validate_crate_name(sess, &s[..], span); s }; @@ -216,7 +217,7 @@ fn symbol_hash<'tcx>(tcx: &ty::ctxt<'tcx>, symbol_hasher.input_str(&meta[..]); } symbol_hasher.input_str("-"); - symbol_hasher.input(&encoder::encoded_ty(tcx, t)); + symbol_hasher.input(&tcx.sess.cstore.encode_type(tcx, t)); // Prefix with 'h' so that it never blends into adjacent digits let mut hash = String::from("h"); hash.push_str(&truncated_hash_result(symbol_hasher)); @@ -504,7 +505,7 @@ pub fn filename_for_input(sess: &Session, pub fn each_linked_rlib(sess: &Session, f: &mut FnMut(ast::CrateNum, &Path)) { - let crates = sess.cstore.get_used_crates(cstore::RequireStatic).into_iter(); + let crates = sess.cstore.used_crates(LinkagePreference::RequireStatic).into_iter(); let fmts = sess.dependency_formats.borrow(); let fmts = fmts.get(&config::CrateTypeExecutable).or_else(|| { fmts.get(&config::CrateTypeStaticlib) @@ -516,7 +517,7 @@ pub fn each_linked_rlib(sess: &Session, Linkage::NotLinked | Linkage::IncludedFromDylib => continue, _ => {} } - let name = sess.cstore.get_crate_data(cnum).name.clone(); + let name = sess.cstore.crate_name(cnum).clone(); let path = match path { Some(p) => p, None => { @@ -623,8 +624,9 @@ fn link_rlib<'a>(sess: &'a Session, for &(ref l, kind) in sess.cstore.get_used_libraries().borrow().iter() { match kind { - cstore::NativeStatic => ab.add_native_library(&l), - cstore::NativeFramework | cstore::NativeUnknown => {} + NativeLibraryKind::NativeStatic => ab.add_native_library(&l), + NativeLibraryKind::NativeFramework | + NativeLibraryKind::NativeUnknown => {} } } @@ -666,7 +668,7 @@ fn link_rlib<'a>(sess: &'a Session, // contain the metadata in a separate file. We use a temp directory // here so concurrent builds in the same directory don't try to use // the same filename for metadata (stomping over one another) - let metadata = tmpdir.join(METADATA_FILENAME); + let metadata = tmpdir.join(sess.cstore.metadata_filename()); match fs::File::create(&metadata).and_then(|mut f| { f.write_all(&trans.metadata) }) { @@ -805,10 +807,10 @@ fn link_staticlib(sess: &Session, objects: &[PathBuf], out_filename: &Path, let mut all_native_libs = vec![]; each_linked_rlib(sess, &mut |cnum, path| { - let name = sess.cstore.get_crate_data(cnum).name(); + let name = sess.cstore.crate_name(cnum); ab.add_rlib(path, &name, sess.lto()).unwrap(); - let native_libs = csearch::get_native_libraries(&sess.cstore, cnum); + let native_libs = sess.cstore.native_libraries(cnum); all_native_libs.extend(native_libs); }); @@ -824,9 +826,9 @@ fn link_staticlib(sess: &Session, objects: &[PathBuf], out_filename: &Path, for &(kind, ref lib) in &all_native_libs { let name = match kind { - cstore::NativeStatic => "static library", - cstore::NativeUnknown => "library", - cstore::NativeFramework => "framework", + NativeLibraryKind::NativeStatic => "static library", + NativeLibraryKind::NativeUnknown => "library", + NativeLibraryKind::NativeFramework => "framework", }; sess.note(&format!("{}: {}", name, *lib)); } @@ -1049,7 +1051,7 @@ fn link_args(cmd: &mut Linker, path }; let mut rpath_config = RPathConfig { - used_crates: sess.cstore.get_used_crates(cstore::RequireDynamic), + used_crates: sess.cstore.used_crates(LinkagePreference::RequireDynamic), out_filename: out_filename.to_path_buf(), has_rpath: sess.target.target.options.has_rpath, is_like_osx: sess.target.target.options.is_like_osx, @@ -1089,10 +1091,10 @@ fn add_local_native_libraries(cmd: &mut Linker, sess: &Session) { let libs = libs.borrow(); let staticlibs = libs.iter().filter_map(|&(ref l, kind)| { - if kind == cstore::NativeStatic {Some(l)} else {None} + if kind == NativeLibraryKind::NativeStatic {Some(l)} else {None} }); let others = libs.iter().filter(|&&(_, kind)| { - kind != cstore::NativeStatic + kind != NativeLibraryKind::NativeStatic }); // Some platforms take hints about whether a library is static or dynamic. @@ -1116,9 +1118,9 @@ fn add_local_native_libraries(cmd: &mut Linker, sess: &Session) { for &(ref l, kind) in others { match kind { - cstore::NativeUnknown => cmd.link_dylib(l), - cstore::NativeFramework => cmd.link_framework(l), - cstore::NativeStatic => unreachable!(), + NativeLibraryKind::NativeUnknown => cmd.link_dylib(l), + NativeLibraryKind::NativeFramework => cmd.link_framework(l), + NativeLibraryKind::NativeStatic => unreachable!(), } } } @@ -1147,13 +1149,13 @@ fn add_upstream_rust_crates(cmd: &mut Linker, sess: &Session, // Invoke get_used_crates to ensure that we get a topological sorting of // crates. - let deps = sess.cstore.get_used_crates(cstore::RequireDynamic); + let deps = sess.cstore.used_crates(LinkagePreference::RequireDynamic); for &(cnum, _) in &deps { // We may not pass all crates through to the linker. Some crates may // appear statically in an existing dylib, meaning we'll pick up all the // symbols from the dylib. - let src = sess.cstore.get_used_crate_source(cnum).unwrap(); + let src = sess.cstore.used_crate_source(cnum); match data[cnum as usize - 1] { Linkage::NotLinked | Linkage::IncludedFromDylib => {} @@ -1217,7 +1219,7 @@ fn add_upstream_rust_crates(cmd: &mut Linker, sess: &Session, time(sess.time_passes(), &format!("altering {}.rlib", name), || { let cfg = archive_config(sess, &dst, Some(cratepath)); let mut archive = ArchiveBuilder::new(cfg); - archive.remove_file(METADATA_FILENAME); + archive.remove_file(sess.cstore.metadata_filename()); archive.update_symbols(); let mut any_objects = false; @@ -1292,14 +1294,14 @@ fn add_upstream_native_libraries(cmd: &mut Linker, sess: &Session) { // This passes RequireStatic, but the actual requirement doesn't matter, // we're just getting an ordering of crate numbers, we're not worried about // the paths. - let crates = sess.cstore.get_used_crates(cstore::RequireStatic); + let crates = sess.cstore.used_crates(LinkagePreference::RequireStatic); for (cnum, _) in crates { - let libs = csearch::get_native_libraries(&sess.cstore, cnum); + let libs = sess.cstore.native_libraries(cnum); for &(kind, ref lib) in &libs { match kind { - cstore::NativeUnknown => cmd.link_dylib(lib), - cstore::NativeFramework => cmd.link_framework(lib), - cstore::NativeStatic => { + NativeLibraryKind::NativeUnknown => cmd.link_dylib(lib), + NativeLibraryKind::NativeFramework => cmd.link_framework(lib), + NativeLibraryKind::NativeStatic => { sess.bug("statics shouldn't be propagated"); } } diff --git a/src/librustc_trans/back/linker.rs b/src/librustc_trans/back/linker.rs index 79a91e4f4165..8235df581c83 100644 --- a/src/librustc_trans/back/linker.rs +++ b/src/librustc_trans/back/linker.rs @@ -16,7 +16,7 @@ use std::path::{Path, PathBuf}; use std::process::Command; use back::archive; -use metadata::csearch; +use metadata::util::CrateStore; use middle::dependency_format::Linkage; use session::Session; use session::config::CrateTypeDylib; @@ -342,9 +342,9 @@ impl<'a> Linker for MsvcLinker<'a> { None } }).flat_map(|cnum| { - csearch::get_reachable_ids(cstore, cnum) + cstore.reachable_ids(cnum) }).map(|did| { - csearch::get_symbol(cstore, did) + cstore.item_symbol(did) }); for symbol in symbols { try!(writeln!(f, " {}", symbol)); diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index e291482a4aae..4f823b82daad 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -34,8 +34,6 @@ use back::{link, abi}; use lint; use llvm::{BasicBlockRef, Linkage, ValueRef, Vector, get_param}; use llvm; -use metadata::{csearch, encoder, loader}; -use middle::astencode; use middle::cfg; use middle::def_id::DefId; use middle::infer; @@ -44,6 +42,7 @@ use middle::weak_lang_items; use middle::pat_util::simple_name; use middle::subst::Substs; use middle::ty::{self, Ty, HasTypeFlags}; +use metadata::util::CrateStore; use rustc::front::map as hir_map; use rustc_mir::mir_map::MirMap; use session::config::{self, NoDebugInfo, FullDebugInfo}; @@ -199,7 +198,7 @@ fn get_extern_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let f = declare::declare_rust_fn(ccx, name, fn_ty); - let attrs = csearch::get_item_attrs(&ccx.sess().cstore, did); + let attrs = ccx.sess().cstore.item_attrs(did); attributes::from_fn_attrs(ccx, &attrs[..], f); ccx.externs().borrow_mut().insert(name.to_string(), f); @@ -230,7 +229,7 @@ pub fn get_extern_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, did: DefId, t: Ty<'tcx>) -> ValueRef { - let name = csearch::get_symbol(&ccx.sess().cstore, did); + let name = ccx.sess().cstore.item_symbol(did); let ty = type_of(ccx, t); match ccx.externs().borrow_mut().get(&name) { Some(n) => return *n, @@ -874,7 +873,7 @@ pub fn trans_external_path<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, did: DefId, t: Ty<'tcx>) -> ValueRef { - let name = csearch::get_symbol(&ccx.sess().cstore, did); + let name = ccx.sess().cstore.item_symbol(did); match t.sty { ty::TyBareFn(_, ref fn_ty) => { match ccx.sess().target.target.adjust_abi(fn_ty.abi) { @@ -885,7 +884,7 @@ pub fn trans_external_path<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ccx.sess().bug("unexpected intrinsic in trans_external_path") } _ => { - let attrs = csearch::get_item_attrs(&ccx.sess().cstore, did); + let attrs = ccx.sess().cstore.item_attrs(did); foreign::register_foreign_item_fn(ccx, fn_ty.abi, t, &name, &attrs) } } @@ -2513,10 +2512,9 @@ pub fn create_entry_wrapper(ccx: &CrateContext, sp: Span, main_llfn: ValueRef) { .as_local_node_id(start_def_id) { get_item_val(ccx, start_node_id) } else { - let start_fn_type = csearch::get_type(ccx.tcx(), start_def_id).ty; + let start_fn_type = ccx.tcx().lookup_item_type(start_def_id).ty; trans_external_path(ccx, start_def_id, start_fn_type) }; - let args = { let opaque_rust_main = llvm::LLVMBuildPointerCast(bld, @@ -2552,7 +2550,7 @@ fn exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, -> String { match ccx.external_srcs().borrow().get(&id) { Some(&did) => { - let sym = csearch::get_symbol(&ccx.sess().cstore, did); + let sym = ccx.sess().cstore.item_symbol(did); debug!("found item {} in other crate...", sym); return sym; } @@ -2602,7 +2600,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { let v = match i.node { hir::ItemStatic(..) => { // If this static came from an external crate, then - // we need to get the symbol from csearch instead of + // we need to get the symbol from metadata instead of // using the current crate's name/version // information in the hash of the symbol let sym = sym(); @@ -2757,22 +2755,6 @@ fn register_method(ccx: &CrateContext, } } -pub fn crate_ctxt_to_encode_parms<'a, 'tcx>(cx: &'a SharedCrateContext<'a, 'tcx>, - ie: encoder::EncodeInlinedItem<'a>, - reachable: &'a NodeSet) - -> encoder::EncodeParams<'a, 'tcx> { - encoder::EncodeParams { - diag: cx.sess().diagnostic(), - tcx: cx.tcx(), - reexports: cx.export_map(), - item_symbols: cx.item_symbols(), - link_meta: cx.link_meta(), - cstore: &cx.sess().cstore, - encode_inlined_item: ie, - reachable: reachable, - } -} - pub fn write_metadata(cx: &SharedCrateContext, krate: &hir::Crate, reachable: &NodeSet) -> Vec { use flate; @@ -2785,14 +2767,13 @@ pub fn write_metadata(cx: &SharedCrateContext, krate: &hir::Crate, reachable: &N return Vec::new(); } - let encode_inlined_item: encoder::EncodeInlinedItem = Box::new(|ecx, rbml_w, ii| { - astencode::encode_inlined_item(ecx, rbml_w, ii) - }); - - let encode_parms = crate_ctxt_to_encode_parms(cx, encode_inlined_item, reachable); - let metadata = encoder::encode_metadata(encode_parms, krate); - let mut compressed = encoder::metadata_encoding_version.to_vec(); + let cstore = &cx.tcx().sess.cstore; + let metadata = cstore.encode_metadata( + cx.tcx(), cx.export_map(), cx.item_symbols(), cx.link_meta(), reachable, + krate); + let mut compressed = cstore.metadata_encoding_version().to_vec(); compressed.push_all(&flate::deflate_bytes(&metadata)); + let llmeta = C_bytes_in_context(cx.metadata_llcx(), &compressed[..]); let llconst = C_struct_in_context(cx.metadata_llcx(), &[llmeta], false); let name = format!("rust_metadata_{}_{}", @@ -2804,7 +2785,8 @@ pub fn write_metadata(cx: &SharedCrateContext, krate: &hir::Crate, reachable: &N }; unsafe { llvm::LLVMSetInitializer(llglobal, llconst); - let name = loader::meta_section_name(&cx.sess().target.target); + let name = + cx.tcx().sess.cstore.metadata_section_name(&cx.sess().target.target); let name = CString::new(name).unwrap(); llvm::LLVMSetSection(llglobal, name.as_ptr()) } @@ -3106,12 +3088,12 @@ pub fn trans_crate<'tcx>(tcx: &ty::ctxt<'tcx>, // the final product, so LTO needs to preserve them. if sess.lto() { sess.cstore.iter_crate_data(|cnum, _| { - let syms = csearch::get_reachable_ids(&sess.cstore, cnum); + let syms = sess.cstore.reachable_ids(cnum); reachable_symbols.extend(syms.into_iter().filter(|did| { - csearch::is_extern_fn(&sess.cstore, *did, shared_ccx.tcx()) || - csearch::is_static(&sess.cstore, *did) + sess.cstore.is_extern_fn(shared_ccx.tcx(), *did) || + sess.cstore.is_static(*did) }).map(|did| { - csearch::get_symbol(&sess.cstore, did) + sess.cstore.item_symbol(did) })); }); } diff --git a/src/librustc_trans/trans/inline.rs b/src/librustc_trans/trans/inline.rs index 0e837d83686a..6178ffe14d63 100644 --- a/src/librustc_trans/trans/inline.rs +++ b/src/librustc_trans/trans/inline.rs @@ -9,9 +9,7 @@ // except according to those terms. use llvm::{AvailableExternallyLinkage, InternalLinkage, SetLinkage}; -use metadata::csearch; -use metadata::inline::InlinedItem; -use middle::astencode; +use metadata::util::{CrateStore, FoundAst, InlinedItem}; use middle::def_id::DefId; use middle::subst::Substs; use trans::base::{push_ctxt, trans_item, get_item_val, trans_fn}; @@ -41,17 +39,13 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) } } - let csearch_result = - csearch::maybe_get_item_ast( - ccx.tcx(), fn_id, - Box::new(astencode::decode_inlined_item)); - - let inline_id = match csearch_result { - csearch::FoundAst::NotFound => { + let inlined = ccx.tcx().sess.cstore.maybe_get_item_ast(ccx.tcx(), fn_id); + let inline_id = match inlined { + FoundAst::NotFound => { ccx.external().borrow_mut().insert(fn_id, None); return None; } - csearch::FoundAst::Found(&InlinedItem::Item(ref item)) => { + FoundAst::Found(&InlinedItem::Item(ref item)) => { ccx.external().borrow_mut().insert(fn_id, Some(item.id)); ccx.external_srcs().borrow_mut().insert(item.id, fn_id); @@ -94,12 +88,12 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) item.id } - csearch::FoundAst::Found(&InlinedItem::Foreign(ref item)) => { + FoundAst::Found(&InlinedItem::Foreign(ref item)) => { ccx.external().borrow_mut().insert(fn_id, Some(item.id)); ccx.external_srcs().borrow_mut().insert(item.id, fn_id); item.id } - csearch::FoundAst::FoundParent(parent_id, &InlinedItem::Item(ref item)) => { + FoundAst::FoundParent(parent_id, &InlinedItem::Item(ref item)) => { ccx.external().borrow_mut().insert(parent_id, Some(item.id)); ccx.external_srcs().borrow_mut().insert(item.id, parent_id); @@ -129,11 +123,11 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) trans_item(ccx, &**item); my_id } - csearch::FoundAst::FoundParent(_, _) => { + FoundAst::FoundParent(_, _) => { ccx.sess().bug("maybe_get_item_ast returned a FoundParent \ with a non-item parent"); } - csearch::FoundAst::Found(&InlinedItem::TraitItem(_, ref trait_item)) => { + FoundAst::Found(&InlinedItem::TraitItem(_, ref trait_item)) => { ccx.external().borrow_mut().insert(fn_id, Some(trait_item.id)); ccx.external_srcs().borrow_mut().insert(trait_item.id, fn_id); @@ -153,7 +147,7 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) // don't. trait_item.id } - csearch::FoundAst::Found(&InlinedItem::ImplItem(impl_did, ref impl_item)) => { + FoundAst::Found(&InlinedItem::ImplItem(impl_did, ref impl_item)) => { ccx.external().borrow_mut().insert(fn_id, Some(impl_item.id)); ccx.external_srcs().borrow_mut().insert(impl_item.id, fn_id); diff --git a/src/librustc_typeck/coherence/overlap.rs b/src/librustc_typeck/coherence/overlap.rs index e91702e64ba9..6a50ceba2f03 100644 --- a/src/librustc_typeck/coherence/overlap.rs +++ b/src/librustc_typeck/coherence/overlap.rs @@ -12,6 +12,7 @@ //! same type. use metadata::cstore::LOCAL_CRATE; +use metadata::util::CrateStore; use middle::def_id::DefId; use middle::traits; use middle::ty; @@ -156,9 +157,8 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> { span_note!(self.tcx.sess, self.span_of_impl(impl2), "note conflicting implementation here"); } else { - let crate_store = &self.tcx.sess.cstore; - let cdata = crate_store.get_crate_data(impl2.krate); - self.tcx.sess.note(&format!("conflicting implementation in crate `{}`", cdata.name)); + let cname = self.tcx.sess.cstore.crate_name(impl2.krate); + self.tcx.sess.note(&format!("conflicting implementation in crate `{}`", cname)); } } diff --git a/src/test/run-make/execution-engine/test.rs b/src/test/run-make/execution-engine/test.rs index 8ca64e866a04..b722beef2c90 100644 --- a/src/test/run-make/execution-engine/test.rs +++ b/src/test/run-make/execution-engine/test.rs @@ -27,6 +27,7 @@ use std::thread::Builder; use rustc::front::map as ast_map; use rustc::llvm; use rustc::metadata::cstore::RequireDynamic; +use rustc::metadata::util::CrateStore; use rustc::middle::ty; use rustc::session::config::{self, basic_options, build_configuration, Input, Options}; use rustc::session::build_session;