bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

rustc_target: Refactor internal linker flavors slightly

Browse source 
Remove one unstable user-facing linker flavor (l4-bender)
This commit is contained in:
Vadim Petrochenkov 2022-08-15 00:31:31 +03:00
parent 7dc186ff7e
commit a0e21ff105
11 changed files with 93 additions and 121 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1173,13 +1173,6 @@ pub fn linker_and_flavor(sess: &Session) -> (PathBuf, LinkerFlavor) {
// only the linker flavor is known; use the default linker for the selected flavor // only the linker flavor is known; use the default linker for the selected flavor
(None, Some(flavor)) => Some(( (None, Some(flavor)) => Some((
PathBuf::from(match flavor { PathBuf::from(match flavor {
LinkerFlavor::Em => {
if cfg!(windows) {
"emcc.bat"
} else {
"emcc"
}
}
LinkerFlavor::Gcc => { LinkerFlavor::Gcc => {
if cfg!(any(target_os = "solaris", target_os = "illumos")) { if cfg!(any(target_os = "solaris", target_os = "illumos")) {
// On historical Solaris systems, "cc" may have // On historical Solaris systems, "cc" may have
@ -1194,11 +1187,17 @@ pub fn linker_and_flavor(sess: &Session) -> (PathBuf, LinkerFlavor) {
} }
} }
LinkerFlavor::Ld => "ld", LinkerFlavor::Ld => "ld",
LinkerFlavor::Msvc => "link.exe",
LinkerFlavor::Lld(_) => "lld", LinkerFlavor::Lld(_) => "lld",
LinkerFlavor::PtxLinker => "rust-ptx-linker", LinkerFlavor::Msvc => "link.exe",
LinkerFlavor::BpfLinker => "bpf-linker", LinkerFlavor::EmCc => {
LinkerFlavor::L4Bender => "l4-bender", if cfg!(windows) {
"emcc.bat"
} else {
"emcc"
}
}
LinkerFlavor::Bpf => "bpf-linker",
LinkerFlavor::Ptx => "rust-ptx-linker",
}), }),
flavor, flavor,
)), )),
@ -1208,7 +1207,7 @@ pub fn linker_and_flavor(sess: &Session) -> (PathBuf, LinkerFlavor) {
}); });
let flavor = if stem == "emcc" { let flavor = if stem == "emcc" {
LinkerFlavor::Em LinkerFlavor::EmCc
} else if stem == "gcc" } else if stem == "gcc"
|| stem.ends_with("-gcc") || stem.ends_with("-gcc")
|| stem == "clang" || stem == "clang"
@ -2114,11 +2113,11 @@ fn add_order_independent_options(
}); });
} }
if flavor == LinkerFlavor::PtxLinker { if flavor == LinkerFlavor::Ptx {
// Provide the linker with fallback to internal `target-cpu`. // Provide the linker with fallback to internal `target-cpu`.
cmd.arg("--fallback-arch"); cmd.arg("--fallback-arch");
cmd.arg(&codegen_results.crate_info.target_cpu); cmd.arg(&codegen_results.crate_info.target_cpu);
} else if flavor == LinkerFlavor::BpfLinker { } else if flavor == LinkerFlavor::Bpf {
cmd.arg("--cpu"); cmd.arg("--cpu");
cmd.arg(&codegen_results.crate_info.target_cpu); cmd.arg(&codegen_results.crate_info.target_cpu);
cmd.arg("--cpu-features"); cmd.arg("--cpu-features");

21
compiler/rustc_codegen_ssa/src/back/linker.rs
View file

@ -126,29 +126,26 @@ pub fn get_linker<'a>(
// to the linker args construction. // to the linker args construction.
assert!(cmd.get_args().is_empty() || sess.target.vendor == "uwp"); assert!(cmd.get_args().is_empty() || sess.target.vendor == "uwp");
match flavor { match flavor {
LinkerFlavor::Lld(LldFlavor::Link) | LinkerFlavor::Msvc => {
Box::new(MsvcLinker { cmd, sess }) as Box<dyn Linker>
}
LinkerFlavor::Em => Box::new(EmLinker { cmd, sess }) as Box<dyn Linker>,
LinkerFlavor::Gcc => { LinkerFlavor::Gcc => {
Box::new(GccLinker { cmd, sess, target_cpu, hinted_static: false, is_ld: false }) Box::new(GccLinker { cmd, sess, target_cpu, hinted_static: false, is_ld: false })
as Box<dyn Linker> as Box<dyn Linker>
} }
LinkerFlavor::Ld if sess.target.os == "l4re" => {
Box::new(L4Bender::new(cmd, sess)) as Box<dyn Linker>
}
LinkerFlavor::Lld(LldFlavor::Ld) LinkerFlavor::Lld(LldFlavor::Ld)
| LinkerFlavor::Lld(LldFlavor::Ld64) | LinkerFlavor::Lld(LldFlavor::Ld64)
| LinkerFlavor::Ld => { | LinkerFlavor::Ld => {
Box::new(GccLinker { cmd, sess, target_cpu, hinted_static: false, is_ld: true }) Box::new(GccLinker { cmd, sess, target_cpu, hinted_static: false, is_ld: true })
as Box<dyn Linker> as Box<dyn Linker>
} }
LinkerFlavor::Lld(LldFlavor::Link) | LinkerFlavor::Msvc => {
Box::new(MsvcLinker { cmd, sess }) as Box<dyn Linker>
}
LinkerFlavor::Lld(LldFlavor::Wasm) => Box::new(WasmLd::new(cmd, sess)) as Box<dyn Linker>, LinkerFlavor::Lld(LldFlavor::Wasm) => Box::new(WasmLd::new(cmd, sess)) as Box<dyn Linker>,
LinkerFlavor::EmCc => Box::new(EmLinker { cmd, sess }) as Box<dyn Linker>,
LinkerFlavor::PtxLinker => Box::new(PtxLinker { cmd, sess }) as Box<dyn Linker>, LinkerFlavor::Bpf => Box::new(BpfLinker { cmd, sess }) as Box<dyn Linker>,
LinkerFlavor::Ptx => Box::new(PtxLinker { cmd, sess }) as Box<dyn Linker>,
LinkerFlavor::BpfLinker => Box::new(BpfLinker { cmd, sess }) as Box<dyn Linker>,
LinkerFlavor::L4Bender => Box::new(L4Bender::new(cmd, sess)) as Box<dyn Linker>,
} }
} }

8
compiler/rustc_interface/src/tests.rs
View file

@ -21,10 +21,8 @@ use rustc_session::{build_session, getopts, DiagnosticOutput, Session};
use rustc_span::edition::{Edition, DEFAULT_EDITION}; use rustc_span::edition::{Edition, DEFAULT_EDITION};
use rustc_span::symbol::sym; use rustc_span::symbol::sym;
use rustc_span::SourceFileHashAlgorithm; use rustc_span::SourceFileHashAlgorithm;
use rustc_target::spec::{CodeModel, LinkerFlavor, MergeFunctions, PanicStrategy}; use rustc_target::spec::{CodeModel, LinkerFlavorCli, MergeFunctions, PanicStrategy, RelocModel};
use rustc_target::spec::{ use rustc_target::spec::{RelroLevel, SanitizerSet, SplitDebuginfo, StackProtector, TlsModel};
RelocModel, RelroLevel, SanitizerSet, SplitDebuginfo, StackProtector, TlsModel,
};
use std::collections::{BTreeMap, BTreeSet}; use std::collections::{BTreeMap, BTreeSet};
use std::iter::FromIterator; use std::iter::FromIterator;
@ -552,7 +550,7 @@ fn test_codegen_options_tracking_hash() {
untracked!(link_args, vec![String::from("abc"), String::from("def")]); untracked!(link_args, vec![String::from("abc"), String::from("def")]);
untracked!(link_self_contained, Some(true)); untracked!(link_self_contained, Some(true));
untracked!(linker, Some(PathBuf::from("linker"))); untracked!(linker, Some(PathBuf::from("linker")));
untracked!(linker_flavor, Some(LinkerFlavor::Gcc)); untracked!(linker_flavor, Some(LinkerFlavorCli::Gcc));
untracked!(no_stack_check, true); untracked!(no_stack_check, true);
untracked!(remark, Passes::Some(vec![String::from("pass1"), String::from("pass2")])); untracked!(remark, Passes::Some(vec![String::from("pass1"), String::from("pass2")]));
untracked!(rpath, true); untracked!(rpath, true);

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

@ -12,8 +12,8 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::stable_hasher::ToStableHashKey; use rustc_data_structures::stable_hasher::ToStableHashKey;
use rustc_target::abi::{Align, TargetDataLayout}; use rustc_target::abi::{Align, TargetDataLayout};
use rustc_target::spec::{LinkerFlavorCli, SplitDebuginfo, Target, TargetTriple, TargetWarnings}; use rustc_target::spec::{PanicStrategy, SanitizerSet, SplitDebuginfo};
use rustc_target::spec::{PanicStrategy, SanitizerSet, TARGETS}; use rustc_target::spec::{Target, TargetTriple, TargetWarnings, TARGETS};
use crate::parse::{CrateCheckConfig, CrateConfig}; use crate::parse::{CrateCheckConfig, CrateConfig};
use rustc_feature::UnstableFeatures; use rustc_feature::UnstableFeatures;
@ -2379,16 +2379,6 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
} }
} }
if cg.linker_flavor == Some(LinkerFlavorCli::L4Bender)
&& !nightly_options::is_unstable_enabled(matches)
{
early_error(
error_format,
"`l4-bender` linker flavor is unstable, `-Z unstable-options` \
flag must also be passed to explicitly use it",
);
}
let prints = collect_print_requests(&mut cg, &mut unstable_opts, matches, error_format); let prints = collect_print_requests(&mut cg, &mut unstable_opts, matches, error_format);
let cg = cg; let cg = cg;

2
compiler/rustc_target/src/spec/asmjs_unknown_emscripten.rs
View file

@ -2,6 +2,6 @@ use super::{wasm32_unknown_emscripten, LinkerFlavor, Target};
pub fn target() -> Target { pub fn target() -> Target {
let mut target = wasm32_unknown_emscripten::target(); let mut target = wasm32_unknown_emscripten::target();
target.add_post_link_args(LinkerFlavor::Em, &["-sWASM=0", "--memory-init-file", "0"]); target.add_post_link_args(LinkerFlavor::EmCc, &["-sWASM=0", "--memory-init-file", "0"]);
target target
} }

2
compiler/rustc_target/src/spec/bpf_base.rs
View file

@ -5,7 +5,7 @@ pub fn opts(endian: Endian) -> TargetOptions {
TargetOptions { TargetOptions {
allow_asm: true, allow_asm: true,
endian, endian,
linker_flavor: LinkerFlavor::BpfLinker, linker_flavor: LinkerFlavor::Bpf,
atomic_cas: false, atomic_cas: false,
dynamic_linking: true, dynamic_linking: true,
no_builtins: true, no_builtins: true,

2
compiler/rustc_target/src/spec/l4re_base.rs
View file

@ -4,7 +4,7 @@ pub fn opts() -> TargetOptions {
TargetOptions { TargetOptions {
os: "l4re".into(), os: "l4re".into(),
env: "uclibc".into(), env: "uclibc".into(),
linker_flavor: LinkerFlavor::L4Bender, linker_flavor: LinkerFlavor::Ld,
panic_strategy: PanicStrategy::Abort, panic_strategy: PanicStrategy::Abort,
linker: Some("l4-bender".into()), linker: Some("l4-bender".into()),
linker_is_gnu: false, linker_is_gnu: false,

110
compiler/rustc_target/src/spec/mod.rs
View file

@ -92,26 +92,24 @@ mod windows_uwp_msvc_base;
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)] #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum LinkerFlavor { pub enum LinkerFlavor {
Em,
Gcc, Gcc,
L4Bender,
Ld, Ld,
Msvc,
Lld(LldFlavor), Lld(LldFlavor),
PtxLinker, Msvc,
BpfLinker, EmCc,
Bpf,
Ptx,
} }
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)] #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum LinkerFlavorCli { pub enum LinkerFlavorCli {
Em,
Gcc, Gcc,
L4Bender,
Ld, Ld,
Msvc,
Lld(LldFlavor), Lld(LldFlavor),
PtxLinker, Msvc,
Em,
BpfLinker, BpfLinker,
PtxLinker,
} }
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)] #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
@ -152,39 +150,37 @@ impl ToJson for LldFlavor {
impl LinkerFlavor { impl LinkerFlavor {
pub fn from_cli(cli: LinkerFlavorCli) -> LinkerFlavor { pub fn from_cli(cli: LinkerFlavorCli) -> LinkerFlavor {
match cli { match cli {
LinkerFlavorCli::Em => LinkerFlavor::Em,
LinkerFlavorCli::Gcc => LinkerFlavor::Gcc, LinkerFlavorCli::Gcc => LinkerFlavor::Gcc,
LinkerFlavorCli::L4Bender => LinkerFlavor::L4Bender,
LinkerFlavorCli::Ld => LinkerFlavor::Ld, LinkerFlavorCli::Ld => LinkerFlavor::Ld,
LinkerFlavorCli::Msvc => LinkerFlavor::Msvc,
LinkerFlavorCli::Lld(lld_flavor) => LinkerFlavor::Lld(lld_flavor), LinkerFlavorCli::Lld(lld_flavor) => LinkerFlavor::Lld(lld_flavor),
LinkerFlavorCli::PtxLinker => LinkerFlavor::PtxLinker, LinkerFlavorCli::Msvc => LinkerFlavor::Msvc,
LinkerFlavorCli::BpfLinker => LinkerFlavor::BpfLinker, LinkerFlavorCli::Em => LinkerFlavor::EmCc,
LinkerFlavorCli::BpfLinker => LinkerFlavor::Bpf,
LinkerFlavorCli::PtxLinker => LinkerFlavor::Ptx,
} }
} }
fn to_cli(self) -> LinkerFlavorCli { fn to_cli(self) -> LinkerFlavorCli {
match self { match self {
LinkerFlavor::Em => LinkerFlavorCli::Em,
LinkerFlavor::Gcc => LinkerFlavorCli::Gcc, LinkerFlavor::Gcc => LinkerFlavorCli::Gcc,
LinkerFlavor::L4Bender => LinkerFlavorCli::L4Bender,
LinkerFlavor::Ld => LinkerFlavorCli::Ld, LinkerFlavor::Ld => LinkerFlavorCli::Ld,
LinkerFlavor::Msvc => LinkerFlavorCli::Msvc,
LinkerFlavor::Lld(lld_flavor) => LinkerFlavorCli::Lld(lld_flavor), LinkerFlavor::Lld(lld_flavor) => LinkerFlavorCli::Lld(lld_flavor),
LinkerFlavor::PtxLinker => LinkerFlavorCli::PtxLinker, LinkerFlavor::Msvc => LinkerFlavorCli::Msvc,
LinkerFlavor::BpfLinker => LinkerFlavorCli::BpfLinker, LinkerFlavor::EmCc => LinkerFlavorCli::Em,
LinkerFlavor::Bpf => LinkerFlavorCli::BpfLinker,
LinkerFlavor::Ptx => LinkerFlavorCli::PtxLinker,
} }
} }
} }
macro_rules! flavor_mappings { macro_rules! linker_flavor_cli_impls {
($((($($flavor:tt)*), $string:expr),)*) => ( ($(($($flavor:tt)*) $string:literal)*) => (
impl LinkerFlavorCli { impl LinkerFlavorCli {
pub const fn one_of() -> &'static str { pub const fn one_of() -> &'static str {
concat!("one of: ", $($string, " ",)*) concat!("one of: ", $($string, " ",)*)
} }
pub fn from_str(s: &str) -> Option<Self> { pub fn from_str(s: &str) -> Option<LinkerFlavorCli> {
Some(match s { Some(match s {
$($string => $($flavor)*,)* $($string => $($flavor)*,)*
_ => return None, _ => return None,
@ -200,18 +196,17 @@ macro_rules! flavor_mappings {
) )
} }
flavor_mappings! { linker_flavor_cli_impls! {
((LinkerFlavorCli::Em), "em"), (LinkerFlavorCli::Gcc) "gcc"
((LinkerFlavorCli::Gcc), "gcc"), (LinkerFlavorCli::Ld) "ld"
((LinkerFlavorCli::L4Bender), "l4-bender"), (LinkerFlavorCli::Lld(LldFlavor::Ld)) "ld.lld"
((LinkerFlavorCli::Ld), "ld"), (LinkerFlavorCli::Lld(LldFlavor::Ld64)) "ld64.lld"
((LinkerFlavorCli::Msvc), "msvc"), (LinkerFlavorCli::Lld(LldFlavor::Link)) "lld-link"
((LinkerFlavorCli::PtxLinker), "ptx-linker"), (LinkerFlavorCli::Lld(LldFlavor::Wasm)) "wasm-ld"
((LinkerFlavorCli::BpfLinker), "bpf-linker"), (LinkerFlavorCli::Msvc) "msvc"
((LinkerFlavorCli::Lld(LldFlavor::Wasm)), "wasm-ld"), (LinkerFlavorCli::Em) "em"
((LinkerFlavorCli::Lld(LldFlavor::Ld64)), "ld64.lld"), (LinkerFlavorCli::BpfLinker) "bpf-linker"
((LinkerFlavorCli::Lld(LldFlavor::Ld)), "ld.lld"), (LinkerFlavorCli::PtxLinker) "ptx-linker"
((LinkerFlavorCli::Lld(LldFlavor::Link)), "lld-link"),
} }
impl ToJson for LinkerFlavorCli { impl ToJson for LinkerFlavorCli {
@ -1252,21 +1247,21 @@ pub struct TargetOptions {
pub abi: StaticCow<str>, pub abi: StaticCow<str>,
/// Vendor name to use for conditional compilation (`target_vendor`). Defaults to "unknown". /// Vendor name to use for conditional compilation (`target_vendor`). Defaults to "unknown".
pub vendor: StaticCow<str>, pub vendor: StaticCow<str>,
/// Linker to invoke
pub linker: Option<StaticCow<str>>,
/// Default linker flavor used if `-C linker-flavor` or `-C linker` are not passed /// Default linker flavor used if `-C linker-flavor` or `-C linker` are not passed
/// on the command line. Defaults to `LinkerFlavor::Gcc`. /// on the command line. Defaults to `LinkerFlavor::Gcc`.
pub linker_flavor: LinkerFlavor, pub linker_flavor: LinkerFlavor,
linker_flavor_json: LinkerFlavorCli, linker_flavor_json: LinkerFlavorCli,
/// Linker to invoke
pub linker: Option<StaticCow<str>>,
/// LLD flavor used if `lld` (or `rust-lld`) is specified as a linker /// LLD flavor used if `lld` (or `rust-lld`) is specified as a linker
/// without clarifying its flavor in any way. /// without clarifying its flavor in any way.
/// FIXME: Merge this into `LinkerFlavor`.
pub lld_flavor: LldFlavor, pub lld_flavor: LldFlavor,
/// Whether the linker support GNU-like arguments such as -O. Defaults to true.
/// FIXME: Merge this into `LinkerFlavor`.
pub linker_is_gnu: bool,
/// Linker arguments that are passed *before* any user-defined libraries.
pub pre_link_args: LinkArgs,
pre_link_args_json: LinkArgsCli,
/// Objects to link before and after all other object code. /// Objects to link before and after all other object code.
pub pre_link_objects: CrtObjects, pub pre_link_objects: CrtObjects,
pub post_link_objects: CrtObjects, pub post_link_objects: CrtObjects,
@ -1275,6 +1270,9 @@ pub struct TargetOptions {
pub post_link_objects_self_contained: CrtObjects, pub post_link_objects_self_contained: CrtObjects,
pub link_self_contained: LinkSelfContainedDefault, pub link_self_contained: LinkSelfContainedDefault,
/// Linker arguments that are passed *before* any user-defined libraries.
pub pre_link_args: LinkArgs,
pre_link_args_json: LinkArgsCli,
/// Linker arguments that are unconditionally passed after any /// Linker arguments that are unconditionally passed after any
/// user-defined but before post-link objects. Standard platform /// user-defined but before post-link objects. Standard platform
/// libraries that should be always be linked to, usually go here. /// libraries that should be always be linked to, usually go here.
@ -1292,11 +1290,11 @@ pub struct TargetOptions {
/// user-defined libraries. /// user-defined libraries.
pub post_link_args: LinkArgs, pub post_link_args: LinkArgs,
post_link_args_json: LinkArgsCli, post_link_args_json: LinkArgsCli,
/// Optional link script applied to `dylib` and `executable` crate types. /// Optional link script applied to `dylib` and `executable` crate types.
/// This is a string containing the script, not a path. Can only be applied /// This is a string containing the script, not a path. Can only be applied
/// to linkers where `linker_is_gnu` is true. /// to linkers where `linker_is_gnu` is true.
pub link_script: Option<StaticCow<str>>, pub link_script: Option<StaticCow<str>>,
/// Environment variables to be set for the linker invocation. /// Environment variables to be set for the linker invocation.
pub link_env: StaticCow<[(StaticCow<str>, StaticCow<str>)]>, pub link_env: StaticCow<[(StaticCow<str>, StaticCow<str>)]>,
/// Environment variables to be removed for the linker invocation. /// Environment variables to be removed for the linker invocation.
@ -1381,8 +1379,6 @@ pub struct TargetOptions {
/// Default supported version of DWARF on this platform. /// Default supported version of DWARF on this platform.
/// Useful because some platforms (osx, bsd) only want up to DWARF2. /// Useful because some platforms (osx, bsd) only want up to DWARF2.
pub default_dwarf_version: u32, pub default_dwarf_version: u32,
/// Whether the linker support GNU-like arguments such as -O. Defaults to true.
pub linker_is_gnu: bool,
/// The MinGW toolchain has a known issue that prevents it from correctly /// The MinGW toolchain has a known issue that prevents it from correctly
/// handling COFF object files with more than 2<sup>15</sup> sections. Since each weak /// handling COFF object files with more than 2<sup>15</sup> sections. Since each weak
/// symbol needs its own COMDAT section, weak linkage implies a large /// symbol needs its own COMDAT section, weak linkage implies a large
@ -1580,11 +1576,7 @@ fn add_link_args(link_args: &mut LinkArgs, flavor: LinkerFlavor, args: &[&'stati
LinkerFlavor::Lld(lld_flavor) => { LinkerFlavor::Lld(lld_flavor) => {
panic!("add_link_args: use non-LLD flavor for {:?}", lld_flavor) panic!("add_link_args: use non-LLD flavor for {:?}", lld_flavor)
} }
LinkerFlavor::Gcc LinkerFlavor::Gcc | LinkerFlavor::EmCc | LinkerFlavor::Bpf | LinkerFlavor::Ptx => {}
| LinkerFlavor::Em
| LinkerFlavor::L4Bender
| LinkerFlavor::BpfLinker
| LinkerFlavor::PtxLinker => {}
} }
} }
@ -1646,14 +1638,11 @@ impl Default for TargetOptions {
env: "".into(), env: "".into(),
abi: "".into(), abi: "".into(),
vendor: "unknown".into(), vendor: "unknown".into(),
linker: option_env!("CFG_DEFAULT_LINKER").map(|s| s.into()),
linker_flavor: LinkerFlavor::Gcc, linker_flavor: LinkerFlavor::Gcc,
linker_flavor_json: LinkerFlavorCli::Gcc, linker_flavor_json: LinkerFlavorCli::Gcc,
linker: option_env!("CFG_DEFAULT_LINKER").map(|s| s.into()),
lld_flavor: LldFlavor::Ld, lld_flavor: LldFlavor::Ld,
pre_link_args: LinkArgs::new(), linker_is_gnu: true,
pre_link_args_json: LinkArgsCli::new(),
post_link_args: LinkArgs::new(),
post_link_args_json: LinkArgsCli::new(),
link_script: None, link_script: None,
asm_args: cvs![], asm_args: cvs![],
cpu: "generic".into(), cpu: "generic".into(),
@ -1680,7 +1669,6 @@ impl Default for TargetOptions {
is_like_msvc: false, is_like_msvc: false,
is_like_wasm: false, is_like_wasm: false,
default_dwarf_version: 4, default_dwarf_version: 4,
linker_is_gnu: true,
allows_weak_linkage: true, allows_weak_linkage: true,
has_rpath: false, has_rpath: false,
no_default_libraries: true, no_default_libraries: true,
@ -1693,12 +1681,16 @@ impl Default for TargetOptions {
pre_link_objects_self_contained: Default::default(), pre_link_objects_self_contained: Default::default(),
post_link_objects_self_contained: Default::default(), post_link_objects_self_contained: Default::default(),
link_self_contained: LinkSelfContainedDefault::False, link_self_contained: LinkSelfContainedDefault::False,
pre_link_args: LinkArgs::new(),
pre_link_args_json: LinkArgsCli::new(),
late_link_args: LinkArgs::new(), late_link_args: LinkArgs::new(),
late_link_args_json: LinkArgsCli::new(), late_link_args_json: LinkArgsCli::new(),
late_link_args_dynamic: LinkArgs::new(), late_link_args_dynamic: LinkArgs::new(),
late_link_args_dynamic_json: LinkArgsCli::new(), late_link_args_dynamic_json: LinkArgsCli::new(),
late_link_args_static: LinkArgs::new(), late_link_args_static: LinkArgs::new(),
late_link_args_static_json: LinkArgsCli::new(), late_link_args_static_json: LinkArgsCli::new(),
post_link_args: LinkArgs::new(),
post_link_args_json: LinkArgsCli::new(),
link_env: cvs![], link_env: cvs![],
link_env_remove: cvs![], link_env_remove: cvs![],
archive_format: "gnu".into(), archive_format: "gnu".into(),
@ -2283,9 +2275,10 @@ impl Target {
key!(env); key!(env);
key!(abi); key!(abi);
key!(vendor); key!(vendor);
key!(linker_flavor_json = "linker-flavor", LinkerFlavor)?;
key!(linker, optional); key!(linker, optional);
key!(linker_flavor_json = "linker-flavor", LinkerFlavor)?;
key!(lld_flavor, LldFlavor)?; key!(lld_flavor, LldFlavor)?;
key!(linker_is_gnu, bool);
key!(pre_link_objects = "pre-link-objects", link_objects); key!(pre_link_objects = "pre-link-objects", link_objects);
key!(post_link_objects = "post-link-objects", link_objects); key!(post_link_objects = "post-link-objects", link_objects);
key!(pre_link_objects_self_contained = "pre-link-objects-fallback", link_objects); key!(pre_link_objects_self_contained = "pre-link-objects-fallback", link_objects);
@ -2323,7 +2316,6 @@ impl Target {
key!(is_like_msvc, bool); key!(is_like_msvc, bool);
key!(is_like_wasm, bool); key!(is_like_wasm, bool);
key!(default_dwarf_version, u32); key!(default_dwarf_version, u32);
key!(linker_is_gnu, bool);
key!(allows_weak_linkage, bool); key!(allows_weak_linkage, bool);
key!(has_rpath, bool); key!(has_rpath, bool);
key!(no_default_libraries, bool); key!(no_default_libraries, bool);
@ -2532,9 +2524,10 @@ impl ToJson for Target {
target_option_val!(env); target_option_val!(env);
target_option_val!(abi); target_option_val!(abi);
target_option_val!(vendor); target_option_val!(vendor);
target_option_val!(linker_flavor_json, "linker-flavor");
target_option_val!(linker); target_option_val!(linker);
target_option_val!(linker_flavor_json, "linker-flavor");
target_option_val!(lld_flavor); target_option_val!(lld_flavor);
target_option_val!(linker_is_gnu);
target_option_val!(pre_link_objects); target_option_val!(pre_link_objects);
target_option_val!(post_link_objects); target_option_val!(post_link_objects);
target_option_val!(pre_link_objects_self_contained, "pre-link-objects-fallback"); target_option_val!(pre_link_objects_self_contained, "pre-link-objects-fallback");
@ -2573,7 +2566,6 @@ impl ToJson for Target {
target_option_val!(is_like_msvc); target_option_val!(is_like_msvc);
target_option_val!(is_like_wasm); target_option_val!(is_like_wasm);
target_option_val!(default_dwarf_version); target_option_val!(default_dwarf_version);
target_option_val!(linker_is_gnu);
target_option_val!(allows_weak_linkage); target_option_val!(allows_weak_linkage);
target_option_val!(has_rpath); target_option_val!(has_rpath);
target_option_val!(no_default_libraries); target_option_val!(no_default_libraries);

2
compiler/rustc_target/src/spec/nvptx64_nvidia_cuda.rs
View file

@ -10,7 +10,7 @@ pub fn target() -> Target {
options: TargetOptions { options: TargetOptions {
os: "cuda".into(), os: "cuda".into(),
vendor: "nvidia".into(), vendor: "nvidia".into(),
linker_flavor: LinkerFlavor::PtxLinker, linker_flavor: LinkerFlavor::Ptx,
// The linker can be installed from `crates.io`. // The linker can be installed from `crates.io`.
linker: Some("rust-ptx-linker".into()), linker: Some("rust-ptx-linker".into()),
linker_is_gnu: false, linker_is_gnu: false,

22
compiler/rustc_target/src/spec/tests/tests_impl.rs
View file

@ -24,10 +24,9 @@ impl Target {
assert_eq!(self.is_like_osx, matches!(self.lld_flavor, LldFlavor::Ld64)); assert_eq!(self.is_like_osx, matches!(self.lld_flavor, LldFlavor::Ld64));
assert_eq!(self.is_like_msvc, matches!(self.lld_flavor, LldFlavor::Link)); assert_eq!(self.is_like_msvc, matches!(self.lld_flavor, LldFlavor::Link));
assert_eq!(self.is_like_wasm, matches!(self.lld_flavor, LldFlavor::Wasm)); assert_eq!(self.is_like_wasm, matches!(self.lld_flavor, LldFlavor::Wasm));
assert_eq!(self.os == "l4re", matches!(self.linker_flavor, LinkerFlavor::L4Bender)); assert_eq!(self.os == "emscripten", matches!(self.linker_flavor, LinkerFlavor::EmCc));
assert_eq!(self.os == "emscripten", matches!(self.linker_flavor, LinkerFlavor::Em)); assert_eq!(self.arch == "bpf", matches!(self.linker_flavor, LinkerFlavor::Bpf));
assert_eq!(self.arch == "bpf", matches!(self.linker_flavor, LinkerFlavor::BpfLinker)); assert_eq!(self.arch == "nvptx64", matches!(self.linker_flavor, LinkerFlavor::Ptx));
assert_eq!(self.arch == "nvptx64", matches!(self.linker_flavor, LinkerFlavor::PtxLinker));
for args in [ for args in [
&self.pre_link_args, &self.pre_link_args,
@ -67,17 +66,14 @@ impl Target {
LinkerFlavor::Lld(LldFlavor::Wasm) | LinkerFlavor::Gcc LinkerFlavor::Lld(LldFlavor::Wasm) | LinkerFlavor::Gcc
) )
} }
(LinkerFlavor::L4Bender, LldFlavor::Ld) => { (LinkerFlavor::EmCc, LldFlavor::Wasm) => {
assert_matches!(flavor, LinkerFlavor::L4Bender) assert_matches!(flavor, LinkerFlavor::EmCc)
} }
(LinkerFlavor::Em, LldFlavor::Wasm) => { (LinkerFlavor::Bpf, LldFlavor::Ld) => {
assert_matches!(flavor, LinkerFlavor::Em) assert_matches!(flavor, LinkerFlavor::Bpf)
} }
(LinkerFlavor::BpfLinker, LldFlavor::Ld) => { (LinkerFlavor::Ptx, LldFlavor::Ld) => {
assert_matches!(flavor, LinkerFlavor::BpfLinker) assert_matches!(flavor, LinkerFlavor::Ptx)
}
(LinkerFlavor::PtxLinker, LldFlavor::Ld) => {
assert_matches!(flavor, LinkerFlavor::PtxLinker)
} }
flavors => unreachable!("unexpected flavor combination: {:?}", flavors), flavors => unreachable!("unexpected flavor combination: {:?}", flavors),
} }

4
compiler/rustc_target/src/spec/wasm32_unknown_emscripten.rs
View file

@ -5,13 +5,13 @@ pub fn target() -> Target {
// Reset flags for non-Em flavors back to empty to satisfy sanity checking tests. // Reset flags for non-Em flavors back to empty to satisfy sanity checking tests.
let pre_link_args = LinkArgs::new(); let pre_link_args = LinkArgs::new();
let post_link_args = TargetOptions::link_args( let post_link_args = TargetOptions::link_args(
LinkerFlavor::Em, LinkerFlavor::EmCc,
&["-sABORTING_MALLOC=0", "-Wl,--fatal-warnings"], &["-sABORTING_MALLOC=0", "-Wl,--fatal-warnings"],
); );
let opts = TargetOptions { let opts = TargetOptions {
os: "emscripten".into(), os: "emscripten".into(),
linker_flavor: LinkerFlavor::Em, linker_flavor: LinkerFlavor::EmCc,
// emcc emits two files - a .js file to instantiate the wasm and supply platform // emcc emits two files - a .js file to instantiate the wasm and supply platform
// functionality, and a .wasm file. // functionality, and a .wasm file.
exe_suffix: ".js".into(), exe_suffix: ".js".into(),