mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

async-llvm(18): Instantiate OngoingCrateTranslation before starting translation.

Browse Source
This commit is contained in:
Michael Woerister 2017-07-26 15:02:53 +02:00 committed by Michael Woerister
parent e7d0fa340f
commit 7e09d1e170
6 changed files with 84 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/librustc/middle/cstore.rs
View File

@ -50,7 +50,7 @@ pub use self::NativeLibraryKind::*;
// lonely orphan structs and enums looking for a better home
#[derive(Clone, Debug)]
#[derive(Clone, Debug, Copy)]
pub struct LinkMeta {
pub crate_hash: Svh,
}
@ -161,15 +161,13 @@ pub struct ExternCrate {
}
pub struct EncodedMetadata {
pub raw_data: Vec<u8>,
pub hashes: EncodedMetadataHashes,
pub raw_data: Vec<u8>
}
impl EncodedMetadata {
pub fn new() -> EncodedMetadata {
EncodedMetadata {
raw_data: Vec::new(),
hashes: EncodedMetadataHashes::new(),
}
}
}
@ -294,7 +292,7 @@ pub trait CrateStore {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
link_meta: &LinkMeta,
reachable: &NodeSet)
-> EncodedMetadata;
-> (EncodedMetadata, EncodedMetadataHashes);
fn metadata_encoding_version(&self) -> &[u8];
}
@ -424,7 +422,7 @@ impl CrateStore for DummyCrateStore {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
link_meta: &LinkMeta,
reachable: &NodeSet)
-> EncodedMetadata {
-> (EncodedMetadata, EncodedMetadataHashes) {
bug!("encode_metadata")
}
fn metadata_encoding_version(&self) -> &[u8] { bug!("metadata_encoding_version") }

6
src/librustc_driver/driver.rs
View File

@ -206,7 +206,7 @@ pub fn compile_input(sess: &Session,
println!("Pre-trans");
tcx.print_debug_stats();
}
let trans = phase_4_translate_to_llvm(tcx, analysis, &incremental_hashes_map,
let trans = phase_4_translate_to_llvm(tcx, analysis, incremental_hashes_map,
&outputs);
if log_enabled!(::log::LogLevel::Info) {
@ -1051,7 +1051,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
/// be discarded.
pub fn phase_4_translate_to_llvm<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
analysis: ty::CrateAnalysis,
incremental_hashes_map: &IncrementalHashesMap,
incremental_hashes_map: IncrementalHashesMap,
output_filenames: &OutputFilenames)
-> write::OngoingCrateTranslation {
let time_passes = tcx.sess.time_passes();
@ -1063,7 +1063,7 @@ 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, analysis, &incremental_hashes_map, output_filenames));
move || trans::trans_crate(tcx, analysis, incremental_hashes_map, output_filenames));
translation
}

4
src/librustc_incremental/persist/save.rs
View File

@ -34,7 +34,7 @@ use super::file_format;
use super::work_product;
pub fn save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
incremental_hashes_map: &IncrementalHashesMap,
incremental_hashes_map: IncrementalHashesMap,
metadata_hashes: &EncodedMetadataHashes,
svh: Svh) {
debug!("save_dep_graph()");
@ -51,7 +51,7 @@ pub fn save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
eprintln!("incremental: {} edges in dep-graph", query.graph.len_edges());
}
let mut hcx = HashContext::new(tcx, incremental_hashes_map);
let mut hcx = HashContext::new(tcx, &incremental_hashes_map);
let preds = Predecessors::new(&query, &mut hcx);
let mut current_metadata_hashes = FxHashMap();

5
src/librustc_metadata/cstore_impl.rs
View File

@ -15,7 +15,8 @@ use schema;
use rustc::ty::maps::QueryConfig;
use rustc::middle::cstore::{CrateStore, CrateSource, LibSource, DepKind,
NativeLibrary, MetadataLoader, LinkMeta,
LinkagePreference, LoadedMacro, EncodedMetadata};
LinkagePreference, LoadedMacro, EncodedMetadata,
EncodedMetadataHashes};
use rustc::hir::def;
use rustc::middle::lang_items;
use rustc::session::Session;
@ -443,7 +444,7 @@ impl CrateStore for cstore::CStore {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
link_meta: &LinkMeta,
reachable: &NodeSet)
-> EncodedMetadata
-> (EncodedMetadata, EncodedMetadataHashes)
{
encoder::encode_metadata(tcx, link_meta, reachable)
}

7
src/librustc_metadata/encoder.rs
View File

@ -1638,7 +1638,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ImplVisitor<'a, 'tcx> {
pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
link_meta: &LinkMeta,
exported_symbols: &NodeSet)
-> EncodedMetadata
-> (EncodedMetadata, EncodedMetadataHashes)
{
let mut cursor = Cursor::new(vec![]);
cursor.write_all(METADATA_HEADER).unwrap();
@ -1681,10 +1681,7 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
result[header + 2] = (pos >> 8) as u8;
result[header + 3] = (pos >> 0) as u8;
EncodedMetadata {
raw_data: result,
hashes: metadata_hashes,
}
(EncodedMetadata { raw_data: result }, metadata_hashes)
}
pub fn get_repr_options<'a, 'tcx, 'gcx>(tcx: &TyCtxt<'a, 'tcx, 'gcx>, did: DefId) -> ReprOptions {

127
src/librustc_trans/base.rs
View File

@ -38,7 +38,7 @@ use llvm;
use metadata;
use rustc::hir::def_id::LOCAL_CRATE;
use rustc::middle::lang_items::StartFnLangItem;
use rustc::middle::cstore::EncodedMetadata;
use rustc::middle::cstore::{EncodedMetadata, EncodedMetadataHashes};
use rustc::ty::{self, Ty, TyCtxt};
use rustc::dep_graph::AssertDepGraphSafe;
use rustc::middle::cstore::LinkMeta;
@ -729,7 +729,8 @@ fn contains_null(s: &str) -> bool {
fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>,
link_meta: &LinkMeta,
exported_symbols: &NodeSet)
-> (ContextRef, ModuleRef, EncodedMetadata) {
-> (ContextRef, ModuleRef,
EncodedMetadata, EncodedMetadataHashes) {
use std::io::Write;
use flate2::Compression;
use flate2::write::DeflateEncoder;
@ -759,15 +760,18 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>,
}).max().unwrap();
if kind == MetadataKind::None {
return (metadata_llcx, metadata_llmod, EncodedMetadata::new());
return (metadata_llcx,
metadata_llmod,
EncodedMetadata::new(),
EncodedMetadataHashes::new());
}
let cstore = &tcx.sess.cstore;
let metadata = cstore.encode_metadata(tcx,
&link_meta,
exported_symbols);
let (metadata, hashes) = cstore.encode_metadata(tcx,
&link_meta,
exported_symbols);
if kind == MetadataKind::Uncompressed {
return (metadata_llcx, metadata_llmod, metadata);
return (metadata_llcx, metadata_llmod, metadata, hashes);
}
assert!(kind == MetadataKind::Compressed);
@ -795,7 +799,7 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>,
let directive = CString::new(directive).unwrap();
llvm::LLVMSetModuleInlineAsm(metadata_llmod, directive.as_ptr())
}
return (metadata_llcx, metadata_llmod, metadata);
return (metadata_llcx, metadata_llmod, metadata, hashes);
}
// Create a `__imp_<symbol> = &symbol` global for every public static `symbol`.
@ -919,7 +923,7 @@ pub fn find_exported_symbols(tcx: TyCtxt, reachable: &NodeSet) -> NodeSet {
pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
analysis: ty::CrateAnalysis,
incremental_hashes_map: &IncrementalHashesMap,
incremental_hashes_map: IncrementalHashesMap,
output_filenames: &OutputFilenames)
-> OngoingCrateTranslation {
// Be careful with this krate: obviously it gives access to the
@ -927,19 +931,16 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
// `TransCrate`, you need to be careful to register "reads" of the
// particular items that will be processed.
let krate = tcx.hir.krate();
let ty::CrateAnalysis { reachable, .. } = analysis;
let check_overflow = tcx.sess.overflow_checks();
let link_meta = link::build_link_meta(incremental_hashes_map);
let link_meta = link::build_link_meta(&incremental_hashes_map);
let exported_symbol_node_ids = find_exported_symbols(tcx, &reachable);
let shared_ccx = SharedCrateContext::new(tcx,
check_overflow,
output_filenames);
// Translate the metadata.
let (metadata_llcx, metadata_llmod, metadata) =
let (metadata_llcx, metadata_llmod, metadata, metadata_incr_hashes) =
time(tcx.sess.time_passes(), "write metadata", || {
write_metadata(tcx, &link_meta, &exported_symbol_node_ids)
});
@ -976,6 +977,11 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
ongoing_translation.submit_translated_module_to_llvm(tcx.sess, metadata_module);
ongoing_translation.signal_translation_done();
assert_and_save_dep_graph(tcx,
incremental_hashes_map,
metadata_incr_hashes,
link_meta);
return ongoing_translation;
}
@ -989,6 +995,35 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
assert!(codegen_units.len() <= 1 || !tcx.sess.lto());
let linker_info = LinkerInfo::new(&shared_ccx, &exported_symbols);
let subsystem = attr::first_attr_value_str_by_name(&krate.attrs,
"windows_subsystem");
let windows_subsystem = subsystem.map(|subsystem| {
if subsystem != "windows" && subsystem != "console" {
tcx.sess.fatal(&format!("invalid windows subsystem `{}`, only \
`windows` and `console` are allowed",
subsystem));
}
subsystem.to_string()
});
let no_integrated_as = tcx.sess.opts.cg.no_integrated_as ||
(tcx.sess.target.target.options.no_integrated_as &&
(output_filenames.outputs.contains_key(&OutputType::Object) ||
output_filenames.outputs.contains_key(&OutputType::Exe)));
let ongoing_translation = write::run_passes(
tcx.sess,
output_filenames,
tcx.crate_name(LOCAL_CRATE),
link_meta,
metadata,
exported_symbols.clone(),
no_builtins,
windows_subsystem,
linker_info,
no_integrated_as);
let translation_items = Arc::new(translation_items);
let mut all_stats = Stats::default();
@ -1209,48 +1244,10 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
None
};
let linker_info = LinkerInfo::new(&shared_ccx, &exported_symbols);
let subsystem = attr::first_attr_value_str_by_name(&krate.attrs,
"windows_subsystem");
let windows_subsystem = subsystem.map(|subsystem| {
if subsystem != "windows" && subsystem != "console" {
tcx.sess.fatal(&format!("invalid windows subsystem `{}`, only \
`windows` and `console` are allowed",
subsystem));
}
subsystem.to_string()
});
let outputs = output_filenames;
let no_integrated_as = sess.opts.cg.no_integrated_as ||
(sess.target.target.options.no_integrated_as &&
(outputs.outputs.contains_key(&OutputType::Object) ||
outputs.outputs.contains_key(&OutputType::Exe)));
time(sess.time_passes(),
"assert dep graph",
|| rustc_incremental::assert_dep_graph(tcx));
time(sess.time_passes(),
"serialize dep graph",
|| rustc_incremental::save_dep_graph(tcx,
incremental_hashes_map,
&metadata.hashes,
link_meta.crate_hash));
// ---
let ongoing_translation = write::run_passes(
sess,
outputs,
tcx.crate_name(LOCAL_CRATE),
link_meta,
metadata,
exported_symbols,
no_builtins,
windows_subsystem,
linker_info,
no_integrated_as);
assert_and_save_dep_graph(tcx,
incremental_hashes_map,
metadata_incr_hashes,
link_meta);
ongoing_translation.submit_translated_module_to_llvm(sess, metadata_module);
@ -1267,6 +1264,22 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
ongoing_translation
}
fn assert_and_save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
incremental_hashes_map: IncrementalHashesMap,
metadata_incr_hashes: EncodedMetadataHashes,
link_meta: LinkMeta) {
time(tcx.sess.time_passes(),
"assert dep graph",
|| rustc_incremental::assert_dep_graph(tcx));
time(tcx.sess.time_passes(),
"serialize dep graph",
|| rustc_incremental::save_dep_graph(tcx,
incremental_hashes_map,
&metadata_incr_hashes,
link_meta.crate_hash));
}
#[inline(never)] // give this a place in the profiler
fn assert_symbols_are_distinct<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>, trans_items: I)
where I: Iterator<Item=&'a TransItem<'tcx>>