bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Store individual output file name with every PrintRequest

Browse source
This commit is contained in:
David Tolnay 2023-07-16 17:20:28 -07:00
parent 11dcd1d3d7
commit c0dc0c6875
No known key found for this signature in database
GPG key ID: F9BA143B95FF6D82
6 changed files with 61 additions and 56 deletions
Download patch file Download diff file Expand all files Collapse all files

16
compiler/rustc_codegen_llvm/src/lib.rs
View file

@ -40,7 +40,7 @@ use rustc_metadata::EncodedMetadata;
use rustc_middle::dep_graph::{WorkProduct, WorkProductId}; use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
use rustc_middle::query::Providers; use rustc_middle::query::Providers;
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
use rustc_session::config::{OptLevel, OutputFilenames, PrintRequest}; use rustc_session::config::{OptLevel, OutputFilenames, PrintKind, PrintRequest};
use rustc_session::Session; use rustc_session::Session;
use rustc_span::symbol::Symbol; use rustc_span::symbol::Symbol;
@ -262,9 +262,9 @@ impl CodegenBackend for LlvmCodegenBackend {
|tcx, ()| llvm_util::global_llvm_features(tcx.sess, true) |tcx, ()| llvm_util::global_llvm_features(tcx.sess, true)
} }
fn print(&self, req: PrintRequest, sess: &Session) { fn print(&self, req: &PrintRequest, sess: &Session) {
match req { match req.kind {
PrintRequest::RelocationModels => { PrintKind::RelocationModels => {
println!("Available relocation models:"); println!("Available relocation models:");
for name in &[ for name in &[
"static", "static",
@ -280,21 +280,21 @@ impl CodegenBackend for LlvmCodegenBackend {
} }
println!(); println!();
} }
PrintRequest::CodeModels => { PrintKind::CodeModels => {
println!("Available code models:"); println!("Available code models:");
for name in &["tiny", "small", "kernel", "medium", "large"] { for name in &["tiny", "small", "kernel", "medium", "large"] {
println!(" {}", name); println!(" {}", name);
} }
println!(); println!();
} }
PrintRequest::TlsModels => { PrintKind::TlsModels => {
println!("Available TLS models:"); println!("Available TLS models:");
for name in &["global-dynamic", "local-dynamic", "initial-exec", "local-exec"] { for name in &["global-dynamic", "local-dynamic", "initial-exec", "local-exec"] {
println!(" {}", name); println!(" {}", name);
} }
println!(); println!();
} }
PrintRequest::StackProtectorStrategies => { PrintKind::StackProtectorStrategies => {
println!( println!(
r#"Available stack protector strategies: r#"Available stack protector strategies:
all all
@ -319,7 +319,7 @@ impl CodegenBackend for LlvmCodegenBackend {
"# "#
); );
} }
req => llvm_util::print(req, sess), _other => llvm_util::print(req, sess),
} }
} }

10
compiler/rustc_codegen_llvm/src/llvm_util.rs
View file

@ -12,7 +12,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::small_c_str::SmallCStr; use rustc_data_structures::small_c_str::SmallCStr;
use rustc_fs_util::path_to_c_string; use rustc_fs_util::path_to_c_string;
use rustc_middle::bug; use rustc_middle::bug;
use rustc_session::config::PrintRequest; use rustc_session::config::{PrintKind, PrintRequest};
use rustc_session::Session; use rustc_session::Session;
use rustc_span::symbol::Symbol; use rustc_span::symbol::Symbol;
use rustc_target::spec::{MergeFunctions, PanicStrategy}; use rustc_target::spec::{MergeFunctions, PanicStrategy};
@ -400,11 +400,11 @@ fn print_target_features(sess: &Session, tm: &llvm::TargetMachine) {
println!("and may be renamed or removed in a future version of LLVM or rustc.\n"); println!("and may be renamed or removed in a future version of LLVM or rustc.\n");
} }
pub(crate) fn print(req: PrintRequest, sess: &Session) { pub(crate) fn print(req: &PrintRequest, sess: &Session) {
require_inited(); require_inited();
let tm = create_informational_target_machine(sess); let tm = create_informational_target_machine(sess);
match req { match req.kind {
PrintRequest::TargetCPUs => { PrintKind::TargetCPUs => {
// SAFETY generate a C compatible string from a byte slice to pass // SAFETY generate a C compatible string from a byte slice to pass
// the target CPU name into LLVM, the lifetime of the reference is // the target CPU name into LLVM, the lifetime of the reference is
// at least as long as the C function // at least as long as the C function
@ -412,7 +412,7 @@ pub(crate) fn print(req: PrintRequest, sess: &Session) {
.unwrap_or_else(|e| bug!("failed to convert to cstring: {}", e)); .unwrap_or_else(|e| bug!("failed to convert to cstring: {}", e));
unsafe { llvm::LLVMRustPrintTargetCPUs(tm, cpu_cstring.as_ptr()) }; unsafe { llvm::LLVMRustPrintTargetCPUs(tm, cpu_cstring.as_ptr()) };
} }
PrintRequest::TargetFeatures => print_target_features(sess, tm), PrintKind::TargetFeatures => print_target_features(sess, tm),
_ => bug!("rustc_codegen_llvm can't handle print request: {:?}", req), _ => bug!("rustc_codegen_llvm can't handle print request: {:?}", req),
} }
} }

6
compiler/rustc_codegen_ssa/src/back/link.rs
View file

@ -13,7 +13,7 @@ use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
use rustc_middle::middle::dependency_format::Linkage; use rustc_middle::middle::dependency_format::Linkage;
use rustc_middle::middle::exported_symbols::SymbolExportKind; use rustc_middle::middle::exported_symbols::SymbolExportKind;
use rustc_session::config::{self, CFGuard, CrateType, DebugInfo, Strip}; use rustc_session::config::{self, CFGuard, CrateType, DebugInfo, Strip};
use rustc_session::config::{OutputFilenames, OutputType, PrintRequest, SplitDwarfKind}; use rustc_session::config::{OutputFilenames, OutputType, PrintKind, SplitDwarfKind};
use rustc_session::cstore::DllImport; use rustc_session::cstore::DllImport;
use rustc_session::output::{check_file_is_writeable, invalid_output_for_target, out_filename}; use rustc_session::output::{check_file_is_writeable, invalid_output_for_target, out_filename};
use rustc_session::search_paths::PathKind; use rustc_session::search_paths::PathKind;
@ -596,7 +596,7 @@ fn link_staticlib<'a>(
all_native_libs.extend_from_slice(&codegen_results.crate_info.used_libraries); all_native_libs.extend_from_slice(&codegen_results.crate_info.used_libraries);
if sess.opts.prints.contains(&PrintRequest::NativeStaticLibs) { if sess.opts.prints.iter().any(|print| print.kind == PrintKind::NativeStaticLibs) {
print_native_static_libs(sess, &all_native_libs, &all_rust_dylibs); print_native_static_libs(sess, &all_native_libs, &all_rust_dylibs);
} }
@ -744,7 +744,7 @@ fn link_natively<'a>(
cmd.env_remove(k.as_ref()); cmd.env_remove(k.as_ref());
} }
if sess.opts.prints.contains(&PrintRequest::LinkArgs) { if sess.opts.prints.iter().any(|print| print.kind == PrintKind::LinkArgs) {
println!("{:?}", &cmd); println!("{:?}", &cmd);
} }

2
compiler/rustc_codegen_ssa/src/traits/backend.rs
View file

@ -61,7 +61,7 @@ pub trait CodegenBackend {
fn locale_resource(&self) -> &'static str; fn locale_resource(&self) -> &'static str;
fn init(&self, _sess: &Session) {} fn init(&self, _sess: &Session) {}
fn print(&self, _req: PrintRequest, _sess: &Session) {} fn print(&self, _req: &PrintRequest, _sess: &Session) {}
fn target_features(&self, _sess: &Session, _allow_unstable: bool) -> Vec<Symbol> { fn target_features(&self, _sess: &Session, _allow_unstable: bool) -> Vec<Symbol> {
vec![] vec![]
} }

14
compiler/rustc_driver_impl/src/lib.rs
View file

@ -35,9 +35,7 @@ use rustc_interface::{interface, Queries};
use rustc_lint::LintStore; use rustc_lint::LintStore;
use rustc_metadata::locator; use rustc_metadata::locator;
use rustc_session::config::{nightly_options, CG_OPTIONS, Z_OPTIONS}; use rustc_session::config::{nightly_options, CG_OPTIONS, Z_OPTIONS};
use rustc_session::config::{ use rustc_session::config::{ErrorOutputType, Input, OutFileName, OutputType, TrimmedDefPaths};
ErrorOutputType, Input, OutFileName, OutputType, PrintRequest, TrimmedDefPaths,
};
use rustc_session::cstore::MetadataLoader; use rustc_session::cstore::MetadataLoader;
use rustc_session::getopts::{self, Matches}; use rustc_session::getopts::{self, Matches};
use rustc_session::lint::{Lint, LintId}; use rustc_session::lint::{Lint, LintId};
@ -714,10 +712,10 @@ fn print_crate_info(
sess: &Session, sess: &Session,
parse_attrs: bool, parse_attrs: bool,
) -> Compilation { ) -> Compilation {
use rustc_session::config::PrintRequest::*; use rustc_session::config::PrintKind::*;
// NativeStaticLibs and LinkArgs are special - printed during linking // NativeStaticLibs and LinkArgs are special - printed during linking
// (empty iterator returns true) // (empty iterator returns true)
if sess.opts.prints.iter().all(|&p| p == NativeStaticLibs || p == LinkArgs) { if sess.opts.prints.iter().all(|p| p.kind == NativeStaticLibs || p.kind == LinkArgs) {
return Compilation::Continue; return Compilation::Continue;
} }
@ -734,7 +732,7 @@ fn print_crate_info(
None None
}; };
for req in &sess.opts.prints { for req in &sess.opts.prints {
match *req { match req.kind {
TargetList => { TargetList => {
let mut targets = rustc_target::spec::TARGETS.to_vec(); let mut targets = rustc_target::spec::TARGETS.to_vec();
targets.sort_unstable(); targets.sort_unstable();
@ -761,7 +759,7 @@ fn print_crate_info(
}; };
let t_outputs = rustc_interface::util::build_output_filenames(attrs, sess); let t_outputs = rustc_interface::util::build_output_filenames(attrs, sess);
let id = rustc_session::output::find_crate_name(sess, attrs); let id = rustc_session::output::find_crate_name(sess, attrs);
if *req == PrintRequest::CrateName { if req.kind == CrateName {
safe_println!("{id}"); safe_println!("{id}");
continue; continue;
} }
@ -817,7 +815,7 @@ fn print_crate_info(
| TargetCPUs | TargetCPUs
| StackProtectorStrategies | StackProtectorStrategies
| TargetFeatures => { | TargetFeatures => {
codegen_backend.print(*req, sess); codegen_backend.print(req, sess);
} }
// Any output here interferes with Cargo's parsing of other printed output // Any output here interferes with Cargo's parsing of other printed output
NativeStaticLibs => {} NativeStaticLibs => {}

69
compiler/rustc_session/src/config.rs
View file

@ -710,8 +710,14 @@ impl ExternEntry {
} }
} }
#[derive(Clone, PartialEq, Debug)]
pub struct PrintRequest {
pub kind: PrintKind,
pub out: OutFileName,
}
#[derive(Copy, Clone, PartialEq, Eq, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum PrintRequest { pub enum PrintKind {
FileNames, FileNames,
Sysroot, Sysroot,
TargetLibdir, TargetLibdir,
@ -2091,41 +2097,41 @@ fn collect_print_requests(
) -> Vec<PrintRequest> { ) -> Vec<PrintRequest> {
let mut prints = Vec::<PrintRequest>::new(); let mut prints = Vec::<PrintRequest>::new();
if cg.target_cpu.as_ref().is_some_and(|s| s == "help") { if cg.target_cpu.as_ref().is_some_and(|s| s == "help") {
prints.push(PrintRequest::TargetCPUs); prints.push(PrintRequest { kind: PrintKind::TargetCPUs, out: OutFileName::Stdout });
cg.target_cpu = None; cg.target_cpu = None;
}; };
if cg.target_feature == "help" { if cg.target_feature == "help" {
prints.push(PrintRequest::TargetFeatures); prints.push(PrintRequest { kind: PrintKind::TargetFeatures, out: OutFileName::Stdout });
cg.target_feature = String::new(); cg.target_feature = String::new();
} }
const PRINT_REQUESTS: &[(&str, PrintRequest)] = &[ const PRINT_KINDS: &[(&str, PrintKind)] = &[
("crate-name", PrintRequest::CrateName), ("crate-name", PrintKind::CrateName),
("file-names", PrintRequest::FileNames), ("file-names", PrintKind::FileNames),
("sysroot", PrintRequest::Sysroot), ("sysroot", PrintKind::Sysroot),
("target-libdir", PrintRequest::TargetLibdir), ("target-libdir", PrintKind::TargetLibdir),
("cfg", PrintRequest::Cfg), ("cfg", PrintKind::Cfg),
("calling-conventions", PrintRequest::CallingConventions), ("calling-conventions", PrintKind::CallingConventions),
("target-list", PrintRequest::TargetList), ("target-list", PrintKind::TargetList),
("target-cpus", PrintRequest::TargetCPUs), ("target-cpus", PrintKind::TargetCPUs),
("target-features", PrintRequest::TargetFeatures), ("target-features", PrintKind::TargetFeatures),
("relocation-models", PrintRequest::RelocationModels), ("relocation-models", PrintKind::RelocationModels),
("code-models", PrintRequest::CodeModels), ("code-models", PrintKind::CodeModels),
("tls-models", PrintRequest::TlsModels), ("tls-models", PrintKind::TlsModels),
("native-static-libs", PrintRequest::NativeStaticLibs), ("native-static-libs", PrintKind::NativeStaticLibs),
("stack-protector-strategies", PrintRequest::StackProtectorStrategies), ("stack-protector-strategies", PrintKind::StackProtectorStrategies),
("target-spec-json", PrintRequest::TargetSpec), ("target-spec-json", PrintKind::TargetSpec),
("all-target-specs-json", PrintRequest::AllTargetSpecs), ("all-target-specs-json", PrintKind::AllTargetSpecs),
("link-args", PrintRequest::LinkArgs), ("link-args", PrintKind::LinkArgs),
("split-debuginfo", PrintRequest::SplitDebuginfo), ("split-debuginfo", PrintKind::SplitDebuginfo),
("deployment-target", PrintRequest::DeploymentTarget), ("deployment-target", PrintKind::DeploymentTarget),
]; ];
prints.extend(matches.opt_strs("print").into_iter().map(|req| { prints.extend(matches.opt_strs("print").into_iter().map(|req| {
match PRINT_REQUESTS.iter().find(|&&(name, _)| name == req) { let kind = match PRINT_KINDS.iter().find(|&&(name, _)| name == req) {
Some((_, PrintRequest::TargetSpec)) => { Some((_, PrintKind::TargetSpec)) => {
if unstable_opts.unstable_options { if unstable_opts.unstable_options {
PrintRequest::TargetSpec PrintKind::TargetSpec
} else { } else {
handler.early_error( handler.early_error(
"the `-Z unstable-options` flag must also be passed to \ "the `-Z unstable-options` flag must also be passed to \
@ -2133,9 +2139,9 @@ fn collect_print_requests(
); );
} }
} }
Some((_, PrintRequest::AllTargetSpecs)) => { Some((_, PrintKind::AllTargetSpecs)) => {
if unstable_opts.unstable_options { if unstable_opts.unstable_options {
PrintRequest::AllTargetSpecs PrintKind::AllTargetSpecs
} else { } else {
handler.early_error( handler.early_error(
"the `-Z unstable-options` flag must also be passed to \ "the `-Z unstable-options` flag must also be passed to \
@ -2143,16 +2149,17 @@ fn collect_print_requests(
); );
} }
} }
Some(&(_, print_request)) => print_request, Some(&(_, print_kind)) => print_kind,
None => { None => {
let prints = let prints =
PRINT_REQUESTS.iter().map(|(name, _)| format!("`{name}`")).collect::<Vec<_>>(); PRINT_KINDS.iter().map(|(name, _)| format!("`{name}`")).collect::<Vec<_>>();
let prints = prints.join(", "); let prints = prints.join(", ");
handler.early_error(format!( handler.early_error(format!(
"unknown print request `{req}`. Valid print requests are: {prints}" "unknown print request `{req}`. Valid print requests are: {prints}"
)); ));
} }
} };
PrintRequest { kind, out: OutFileName::Stdout }
})); }));
prints prints