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

Auto merge of #117993 - nnethercote:streamline-Linker, r=bjorn3

Browse Source 
Streamline `Linker`

r? `@bjorn3`
This commit is contained in:
bors 2023-11-17 16:49:58 +00:00
commit e886137e18
4 changed files with 42 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
compiler/rustc_driver_impl/src/lib.rs
View File

@ -361,7 +361,7 @@ fn run_compiler(
} }
let should_stop = print_crate_info( let should_stop = print_crate_info(
&handler, &handler,
&**compiler.codegen_backend(), compiler.codegen_backend(),
compiler.session(), compiler.session(),
false, false,
); );
@ -385,12 +385,11 @@ fn run_compiler(
interface::run_compiler(config, |compiler| { interface::run_compiler(config, |compiler| {
let sess = compiler.session(); let sess = compiler.session();
let codegen_backend = compiler.codegen_backend();
let handler = EarlyErrorHandler::new(sess.opts.error_format); let handler = EarlyErrorHandler::new(sess.opts.error_format);
let should_stop = print_crate_info(&handler, &**compiler.codegen_backend(), sess, true) let should_stop = print_crate_info(&handler, codegen_backend, sess, true)
.and_then(|| { .and_then(|| list_metadata(&handler, sess, &*codegen_backend.metadata_loader()))
list_metadata(&handler, sess, &*compiler.codegen_backend().metadata_loader())
})
.and_then(|| try_process_rlink(sess, compiler)); .and_then(|| try_process_rlink(sess, compiler));
if should_stop == Compilation::Stop { if should_stop == Compilation::Stop {
@ -482,7 +481,7 @@ fn run_compiler(
if let Some(linker) = linker { if let Some(linker) = linker {
let _timer = sess.timer("link"); let _timer = sess.timer("link");
linker.link()? linker.link(sess, codegen_backend)?
} }
if sess.opts.unstable_opts.print_fuel.is_some() { if sess.opts.unstable_opts.print_fuel.is_some() {

17
compiler/rustc_interface/src/interface.rs
View File

@ -38,17 +38,17 @@
/// Can be used to run `rustc_interface` queries. /// Can be used to run `rustc_interface` queries.
/// Created by passing [`Config`] to [`run_compiler`]. /// Created by passing [`Config`] to [`run_compiler`].
pub struct Compiler { pub struct Compiler {
pub(crate) sess: Lrc<Session>, sess: Session,
codegen_backend: Lrc<dyn CodegenBackend>, codegen_backend: Box<dyn CodegenBackend>,
pub(crate) override_queries: Option<fn(&Session, &mut Providers)>, pub(crate) override_queries: Option<fn(&Session, &mut Providers)>,
} }
impl Compiler { impl Compiler {
pub fn session(&self) -> &Lrc<Session> { pub fn session(&self) -> &Session {
&self.sess &self.sess
} }
pub fn codegen_backend(&self) -> &Lrc<dyn CodegenBackend> { pub fn codegen_backend(&self) -> &dyn CodegenBackend {
&self.codegen_backend &*self.codegen_backend
} }
pub fn build_output_filenames( pub fn build_output_filenames(
&self, &self,
@ -491,11 +491,8 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
} }
sess.lint_store = Some(Lrc::new(lint_store)); sess.lint_store = Some(Lrc::new(lint_store));
let compiler = Compiler { let compiler =
sess: Lrc::new(sess), Compiler { sess, codegen_backend, override_queries: config.override_queries };
codegen_backend: Lrc::from(codegen_backend),
override_queries: config.override_queries,
};
rustc_span::set_source_map(compiler.sess.parse_sess.clone_source_map(), move || { rustc_span::set_source_map(compiler.sess.parse_sess.clone_source_map(), move || {
let r = { let r = {

72
compiler/rustc_interface/src/queries.rs
View File

@ -7,7 +7,7 @@
use rustc_codegen_ssa::CodegenResults; use rustc_codegen_ssa::CodegenResults;
use rustc_data_structures::steal::Steal; use rustc_data_structures::steal::Steal;
use rustc_data_structures::svh::Svh; use rustc_data_structures::svh::Svh;
use rustc_data_structures::sync::{AppendOnlyIndexVec, FreezeLock, Lrc, OnceLock, WorkerLocal}; use rustc_data_structures::sync::{AppendOnlyIndexVec, FreezeLock, OnceLock, WorkerLocal};
use rustc_hir::def_id::{StableCrateId, CRATE_DEF_ID, LOCAL_CRATE}; use rustc_hir::def_id::{StableCrateId, CRATE_DEF_ID, LOCAL_CRATE};
use rustc_hir::definitions::Definitions; use rustc_hir::definitions::Definitions;
use rustc_incremental::setup_dep_graph; use rustc_incremental::setup_dep_graph;
@ -101,10 +101,11 @@ pub fn new(compiler: &'tcx Compiler) -> Queries<'tcx> {
} }
} }
fn session(&self) -> &Lrc<Session> { fn session(&self) -> &Session {
&self.compiler.sess &self.compiler.session()
} }
fn codegen_backend(&self) -> &Lrc<dyn CodegenBackend> {
fn codegen_backend(&self) -> &dyn CodegenBackend {
self.compiler.codegen_backend() self.compiler.codegen_backend()
} }
@ -197,7 +198,7 @@ pub fn ongoing_codegen(&'tcx self) -> Result<Box<dyn Any>> {
// Hook for UI tests. // Hook for UI tests.
Self::check_for_rustc_errors_attr(tcx); Self::check_for_rustc_errors_attr(tcx);
Ok(passes::start_codegen(&**self.codegen_backend(), tcx)) Ok(passes::start_codegen(self.codegen_backend(), tcx))
}) })
} }
@ -236,67 +237,48 @@ fn check_for_rustc_errors_attr(tcx: TyCtxt<'_>) {
} }
pub fn linker(&'tcx self, ongoing_codegen: Box<dyn Any>) -> Result<Linker> { pub fn linker(&'tcx self, ongoing_codegen: Box<dyn Any>) -> Result<Linker> {
let sess = self.session().clone(); self.global_ctxt()?.enter(|tcx| {
let codegen_backend = self.codegen_backend().clone();
let (crate_hash, prepare_outputs, dep_graph) = self.global_ctxt()?.enter(|tcx| {
(
if tcx.needs_crate_hash() { Some(tcx.crate_hash(LOCAL_CRATE)) } else { None },
tcx.output_filenames(()).clone(),
tcx.dep_graph.clone(),
)
});
Ok(Linker { Ok(Linker {
sess, dep_graph: tcx.dep_graph.clone(),
codegen_backend, output_filenames: tcx.output_filenames(()).clone(),
crate_hash: if tcx.needs_crate_hash() {
dep_graph, Some(tcx.crate_hash(LOCAL_CRATE))
prepare_outputs, } else {
crate_hash, None
},
ongoing_codegen, ongoing_codegen,
}) })
})
} }
} }
pub struct Linker { pub struct Linker {
// compilation inputs
sess: Lrc<Session>,
codegen_backend: Lrc<dyn CodegenBackend>,
// compilation outputs
dep_graph: DepGraph, dep_graph: DepGraph,
prepare_outputs: Arc<OutputFilenames>, output_filenames: Arc<OutputFilenames>,
// Only present when incr. comp. is enabled. // Only present when incr. comp. is enabled.
crate_hash: Option<Svh>, crate_hash: Option<Svh>,
ongoing_codegen: Box<dyn Any>, ongoing_codegen: Box<dyn Any>,
} }
impl Linker { impl Linker {
pub fn link(self) -> Result<()> { pub fn link(self, sess: &Session, codegen_backend: &dyn CodegenBackend) -> Result<()> {
let (codegen_results, work_products) = self.codegen_backend.join_codegen( let (codegen_results, work_products) =
self.ongoing_codegen, codegen_backend.join_codegen(self.ongoing_codegen, sess, &self.output_filenames)?;
&self.sess,
&self.prepare_outputs,
)?;
self.sess.compile_status()?; sess.compile_status()?;
let sess = &self.sess;
let dep_graph = self.dep_graph;
sess.time("serialize_work_products", || { sess.time("serialize_work_products", || {
rustc_incremental::save_work_product_index(sess, &dep_graph, work_products) rustc_incremental::save_work_product_index(sess, &self.dep_graph, work_products)
}); });
let prof = self.sess.prof.clone(); let prof = sess.prof.clone();
prof.generic_activity("drop_dep_graph").run(move || drop(dep_graph)); prof.generic_activity("drop_dep_graph").run(move || drop(self.dep_graph));
// Now that we won't touch anything in the incremental compilation directory // Now that we won't touch anything in the incremental compilation directory
// any more, we can finalize it (which involves renaming it) // any more, we can finalize it (which involves renaming it)
rustc_incremental::finalize_session_directory(&self.sess, self.crate_hash); rustc_incremental::finalize_session_directory(sess, self.crate_hash);
if !self if !sess
.sess
.opts .opts
.output_types .output_types
.keys() .keys()
@ -306,14 +288,14 @@ pub fn link(self) -> Result<()> {
} }
if sess.opts.unstable_opts.no_link { if sess.opts.unstable_opts.no_link {
let rlink_file = self.prepare_outputs.with_extension(config::RLINK_EXT); let rlink_file = self.output_filenames.with_extension(config::RLINK_EXT);
CodegenResults::serialize_rlink(sess, &rlink_file, &codegen_results) CodegenResults::serialize_rlink(sess, &rlink_file, &codegen_results)
.map_err(|error| sess.emit_fatal(FailedWritingFile { path: &rlink_file, error }))?; .map_err(|error| sess.emit_fatal(FailedWritingFile { path: &rlink_file, error }))?;
return Ok(()); return Ok(());
} }
let _timer = sess.prof.verbose_generic_activity("link_crate"); let _timer = sess.prof.verbose_generic_activity("link_crate");
self.codegen_backend.link(&self.sess, codegen_results, &self.prepare_outputs) codegen_backend.link(sess, codegen_results, &self.output_filenames)
} }
} }

2
tests/run-make-fulldeps/issue-19371/foo.rs
View File

@ -72,6 +72,6 @@ fn compile(code: String, output: PathBuf, sysroot: PathBuf) {
let ongoing_codegen = queries.ongoing_codegen()?; let ongoing_codegen = queries.ongoing_codegen()?;
queries.linker(ongoing_codegen) queries.linker(ongoing_codegen)
}); });
linker.unwrap().link().unwrap(); linker.unwrap().link(compiler.session(), compiler.codegen_backend()).unwrap();
}); });
} }