bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Rollup merge of #78875 - petrochenkov:cleantarg, r=Mark-Simulacrum

Browse source 
rustc_target: Further cleanup use of target options

Follow up to https://github.com/rust-lang/rust/pull/77729.

Implements items 2 and 4 from the list in https://github.com/rust-lang/rust/pull/77729#issue-500228243.

The first commit collapses uses of `target.options.foo` into `target.foo`.

The second commit renames some target options to avoid tautology:
`target.target_endian` -> `target.endian`
`target.target_c_int_width` -> `target.c_int_width`
`target.target_os` -> `target.os`
`target.target_env` -> `target.env`
`target.target_vendor` -> `target.vendor`
`target.target_family` -> `target.os_family`
`target.target_mcount` -> `target.mcount`

r? `@Mark-Simulacrum`
This commit is contained in:
Jonas Schievink 2020-11-10 14:45:21 +01:00 • committed by GitHub
commit 105f4b8792
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
153 changed files with 452 additions and 502 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -735,15 +735,15 @@ pub const fn default_lib_output() -> CrateType {
}
pub fn default_configuration(sess: &Session) -> CrateConfig {
let end = &sess.target.target_endian;
let end = &sess.target.endian;
let arch = &sess.target.arch;
let wordsz = sess.target.pointer_width.to_string();
let os = &sess.target.target_os;
let env = &sess.target.target_env;
let vendor = &sess.target.target_vendor;
let os = &sess.target.os;
let env = &sess.target.env;
let vendor = &sess.target.vendor;
let min_atomic_width = sess.target.min_atomic_width();
let max_atomic_width = sess.target.max_atomic_width();
let atomic_cas = sess.target.options.atomic_cas;
let atomic_cas = sess.target.atomic_cas;
let layout = TargetDataLayout::parse(&sess.target).unwrap_or_else(|err| {
sess.fatal(&err);
});
@ -752,7 +752,7 @@ pub fn default_configuration(sess: &Session) -> CrateConfig {
ret.reserve(6); // the minimum number of insertions
// Target bindings.
ret.insert((sym::target_os, Some(Symbol::intern(os))));
if let Some(ref fam) = sess.target.options.target_family {
if let Some(ref fam) = sess.target.os_family {
ret.insert((sym::target_family, Some(Symbol::intern(fam))));
if fam == "windows" {
ret.insert((sym::windows, None));
@ -765,7 +765,7 @@ pub fn default_configuration(sess: &Session) -> CrateConfig {
ret.insert((sym::target_pointer_width, Some(Symbol::intern(&wordsz))));
ret.insert((sym::target_env, Some(Symbol::intern(env))));
ret.insert((sym::target_vendor, Some(Symbol::intern(vendor))));
if sess.target.options.has_elf_tls {
if sess.target.has_elf_tls {
ret.insert((sym::target_thread_local, None));
}
for &(i, align) in &[

18
compiler/rustc_session/src/output.rs
View file

@ -150,17 +150,15 @@ pub fn filename_for_input(
match crate_type {
CrateType::Rlib => outputs.out_directory.join(&format!("lib{}.rlib", libname)),
CrateType::Cdylib | CrateType::ProcMacro | CrateType::Dylib => {
let (prefix, suffix) =
(&sess.target.options.dll_prefix, &sess.target.options.dll_suffix);
let (prefix, suffix) = (&sess.target.dll_prefix, &sess.target.dll_suffix);
outputs.out_directory.join(&format!("{}{}{}", prefix, libname, suffix))
}
CrateType::Staticlib => {
let (prefix, suffix) =
(&sess.target.options.staticlib_prefix, &sess.target.options.staticlib_suffix);
let (prefix, suffix) = (&sess.target.staticlib_prefix, &sess.target.staticlib_suffix);
outputs.out_directory.join(&format!("{}{}{}", prefix, libname, suffix))
}
CrateType::Executable => {
let suffix = &sess.target.options.exe_suffix;
let suffix = &sess.target.exe_suffix;
let out_filename = outputs.path(OutputType::Exe);
if suffix.is_empty() { out_filename } else { out_filename.with_extension(&suffix[1..]) }
}
@ -177,29 +175,29 @@ pub fn filename_for_input(
/// interaction with Rust code through static library is the only
/// option for now
pub fn default_output_for_target(sess: &Session) -> CrateType {
if !sess.target.options.executables { CrateType::Staticlib } else { CrateType::Executable }
if !sess.target.executables { CrateType::Staticlib } else { CrateType::Executable }
}
/// Checks if target supports crate_type as output
pub fn invalid_output_for_target(sess: &Session, crate_type: CrateType) -> bool {
match crate_type {
CrateType::Cdylib | CrateType::Dylib | CrateType::ProcMacro => {
if !sess.target.options.dynamic_linking {
if !sess.target.dynamic_linking {
return true;
}
if sess.crt_static(Some(crate_type)) && !sess.target.options.crt_static_allows_dylibs {
if sess.crt_static(Some(crate_type)) && !sess.target.crt_static_allows_dylibs {
return true;
}
}
_ => {}
}
if sess.target.options.only_cdylib {
if sess.target.only_cdylib {
match crate_type {
CrateType::ProcMacro | CrateType::Dylib => return true,
_ => {}
}
}
if !sess.target.options.executables && crate_type == CrateType::Executable {
if !sess.target.executables && crate_type == CrateType::Executable {
return true;
}

43
compiler/rustc_session/src/session.rs
View file

@ -663,7 +663,7 @@ impl Session {
/// Calculates the flavor of LTO to use for this compilation.
pub fn lto(&self) -> config::Lto {
// If our target has codegen requirements ignore the command line
if self.target.options.requires_lto {
if self.target.requires_lto {
return config::Lto::Fat;
}
@ -731,7 +731,7 @@ impl Session {
/// Returns the panic strategy for this compile session. If the user explicitly selected one
/// using '-C panic', use that, otherwise use the panic strategy defined by the target.
pub fn panic_strategy(&self) -> PanicStrategy {
self.opts.cg.panic.unwrap_or(self.target.options.panic_strategy)
self.opts.cg.panic.unwrap_or(self.target.panic_strategy)
}
pub fn fewer_names(&self) -> bool {
let more_names = self.opts.output_types.contains_key(&OutputType::LlvmAssembly)
@ -755,9 +755,9 @@ impl Session {
/// Check whether this compile session and crate type use static crt.
pub fn crt_static(&self, crate_type: Option<CrateType>) -> bool {
if !self.target.options.crt_static_respected {
if !self.target.crt_static_respected {
// If the target does not opt in to crt-static support, use its default.
return self.target.options.crt_static_default;
return self.target.crt_static_default;
}
let requested_features = self.opts.cg.target_feature.split(',');
@ -774,20 +774,20 @@ impl Session {
// We can't check `#![crate_type = "proc-macro"]` here.
false
} else {
self.target.options.crt_static_default
self.target.crt_static_default
}
}
pub fn relocation_model(&self) -> RelocModel {
self.opts.cg.relocation_model.unwrap_or(self.target.options.relocation_model)
self.opts.cg.relocation_model.unwrap_or(self.target.relocation_model)
}
pub fn code_model(&self) -> Option<CodeModel> {
self.opts.cg.code_model.or(self.target.options.code_model)
self.opts.cg.code_model.or(self.target.code_model)
}
pub fn tls_model(&self) -> TlsModel {
self.opts.debugging_opts.tls_model.unwrap_or(self.target.options.tls_model)
self.opts.debugging_opts.tls_model.unwrap_or(self.target.tls_model)
}
pub fn must_not_eliminate_frame_pointers(&self) -> bool {
@ -798,7 +798,7 @@ impl Session {
} else if let Some(x) = self.opts.cg.force_frame_pointers {
x
} else {
!self.target.options.eliminate_frame_pointer
!self.target.eliminate_frame_pointer
}
}
@ -822,7 +822,7 @@ impl Session {
// value, if it is provided, or disable them, if not.
if self.panic_strategy() == PanicStrategy::Unwind {
true
} else if self.target.options.requires_uwtable {
} else if self.target.requires_uwtable {
true
} else {
self.opts.cg.force_unwind_tables.unwrap_or(false)
@ -993,7 +993,7 @@ impl Session {
if let Some(n) = self.opts.cli_forced_codegen_units {
return n;
}
if let Some(n) = self.target.options.default_codegen_units {
if let Some(n) = self.target.default_codegen_units {
return n as usize;
}
@ -1078,11 +1078,11 @@ impl Session {
pub fn needs_plt(&self) -> bool {
// Check if the current target usually needs PLT to be enabled.
// The user can use the command line flag to override it.
let needs_plt = self.target.options.needs_plt;
let needs_plt = self.target.needs_plt;
let dbg_opts = &self.opts.debugging_opts;
let relro_level = dbg_opts.relro_level.unwrap_or(self.target.options.relro_level);
let relro_level = dbg_opts.relro_level.unwrap_or(self.target.relro_level);
// Only enable this optimization by default if full relro is also enabled.
// In this case, lazy binding was already unavailable, so nothing is lost.
@ -1106,7 +1106,7 @@ impl Session {
match self.opts.cg.link_dead_code {
Some(explicitly_set) => explicitly_set,
None => {
self.opts.debugging_opts.instrument_coverage && !self.target.options.is_like_msvc
self.opts.debugging_opts.instrument_coverage && !self.target.is_like_msvc
// Issue #76038: (rustc `-Clink-dead-code` causes MSVC linker to produce invalid
// binaries when LLVM InstrProf counters are enabled). As described by this issue,
// the "link dead code" option produces incorrect binaries when compiled and linked
@ -1307,7 +1307,7 @@ pub fn build_session(
let loader = file_loader.unwrap_or(Box::new(RealFileLoader));
let hash_kind = sopts.debugging_opts.src_hash_algorithm.unwrap_or_else(|| {
if target_cfg.options.is_like_msvc {
if target_cfg.is_like_msvc {
SourceFileHashAlgorithm::Sha1
} else {
SourceFileHashAlgorithm::Md5
@ -1417,11 +1417,8 @@ pub fn build_session(
if candidate.join("library/std/src/lib.rs").is_file() { Some(candidate) } else { None }
};
let asm_arch = if target_cfg.options.allow_asm {
InlineAsmArch::from_str(&target_cfg.arch).ok()
} else {
None
};
let asm_arch =
if target_cfg.allow_asm { InlineAsmArch::from_str(&target_cfg.arch).ok() } else { None };
let sess = Session {
target: target_cfg,
@ -1487,7 +1484,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
// the `dllimport` attributes and `__imp_` symbols in that case.
if sess.opts.cg.linker_plugin_lto.enabled()
&& sess.opts.cg.prefer_dynamic
&& sess.target.options.is_like_windows
&& sess.target.is_like_windows
{
sess.err(
"Linker plugin based LTO is not supported together with \
@ -1515,7 +1512,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
);
}
if sess.target.options.requires_uwtable && !include_uwtables {
if sess.target.requires_uwtable && !include_uwtables {
sess.err(
"target requires unwind tables, they cannot be disabled with \
`-C force-unwind-tables=no`.",
@ -1530,7 +1527,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
// We should only display this error if we're actually going to run PGO.
// If we're just supposed to print out some data, don't show the error (#61002).
if sess.opts.cg.profile_generate.enabled()
&& sess.target.options.is_like_msvc
&& sess.target.is_like_msvc
&& sess.panic_strategy() == PanicStrategy::Unwind
&& sess.opts.prints.iter().all(|&p| p == PrintRequest::NativeStaticLibs)
{