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

rustc_target: Update some old naming around self contained linking

Browse Source 
The "fallback" naming pre-dates introduction of `-Clink-self-contained`
This commit is contained in:
Vadim Petrochenkov 2022-08-04 01:43:17 +03:00
parent 569788e47e
commit 8fa707ab41
8 changed files with 90 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
compiler/rustc_codegen_ssa/src/back/link.rs
View File

@ -20,7 +20,7 @@ use rustc_session::utils::NativeLibKind;
use rustc_session::{filesearch, Session}; use rustc_session::{filesearch, Session};
use rustc_span::symbol::Symbol; use rustc_span::symbol::Symbol;
use rustc_span::DebuggerVisualizerFile; use rustc_span::DebuggerVisualizerFile;
use rustc_target::spec::crt_objects::{CrtObjects, CrtObjectsFallback}; use rustc_target::spec::crt_objects::{CrtObjects, LinkSelfContainedDefault};
use rustc_target::spec::{LinkOutputKind, LinkerFlavor, LldFlavor, SplitDebuginfo}; use rustc_target::spec::{LinkOutputKind, LinkerFlavor, LldFlavor, SplitDebuginfo};
use rustc_target::spec::{PanicStrategy, RelocModel, RelroLevel, SanitizerSet, Target}; use rustc_target::spec::{PanicStrategy, RelocModel, RelroLevel, SanitizerSet, Target};
@ -764,15 +764,15 @@ fn link_natively<'a>(
"Linker does not support -static-pie command line option. Retrying with -static instead." "Linker does not support -static-pie command line option. Retrying with -static instead."
); );
// Mirror `add_(pre,post)_link_objects` to replace CRT objects. // Mirror `add_(pre,post)_link_objects` to replace CRT objects.
let self_contained = crt_objects_fallback(sess, crate_type); let self_contained = self_contained(sess, crate_type);
let opts = &sess.target; let opts = &sess.target;
let pre_objects = if self_contained { let pre_objects = if self_contained {
&opts.pre_link_objects_fallback &opts.pre_link_objects_self_contained
} else { } else {
&opts.pre_link_objects &opts.pre_link_objects
}; };
let post_objects = if self_contained { let post_objects = if self_contained {
&opts.post_link_objects_fallback &opts.post_link_objects_self_contained
} else { } else {
&opts.post_link_objects &opts.post_link_objects
}; };
@ -1556,26 +1556,26 @@ fn detect_self_contained_mingw(sess: &Session) -> bool {
true true
} }
/// Whether we link to our own CRT objects instead of relying on gcc to pull them. /// Various toolchain components used during linking are used from rustc distribution
/// instead of being found somewhere on the host system.
/// We only provide such support for a very limited number of targets. /// We only provide such support for a very limited number of targets.
fn crt_objects_fallback(sess: &Session, crate_type: CrateType) -> bool { fn self_contained(sess: &Session, crate_type: CrateType) -> bool {
if let Some(self_contained) = sess.opts.cg.link_self_contained { if let Some(self_contained) = sess.opts.cg.link_self_contained {
return self_contained; return self_contained;
} }
match sess.target.crt_objects_fallback { match sess.target.link_self_contained {
LinkSelfContainedDefault::False => false,
LinkSelfContainedDefault::True => true,
// FIXME: Find a better heuristic for "native musl toolchain is available", // FIXME: Find a better heuristic for "native musl toolchain is available",
// based on host and linker path, for example. // based on host and linker path, for example.
// (https://github.com/rust-lang/rust/pull/71769#issuecomment-626330237). // (https://github.com/rust-lang/rust/pull/71769#issuecomment-626330237).
Some(CrtObjectsFallback::Musl) => sess.crt_static(Some(crate_type)), LinkSelfContainedDefault::Musl => sess.crt_static(Some(crate_type)),
Some(CrtObjectsFallback::Mingw) => { LinkSelfContainedDefault::Mingw => {
sess.host == sess.target sess.host == sess.target
&& sess.target.vendor != "uwp" && sess.target.vendor != "uwp"
&& detect_self_contained_mingw(&sess) && detect_self_contained_mingw(&sess)
} }
// FIXME: Figure out cases in which WASM needs to link with a native toolchain.
Some(CrtObjectsFallback::Wasm) => true,
None => false,
} }
} }
@ -1592,7 +1592,7 @@ fn add_pre_link_objects(
let opts = &sess.target; let opts = &sess.target;
let empty = Default::default(); let empty = Default::default();
let objects = if self_contained { let objects = if self_contained {
&opts.pre_link_objects_fallback &opts.pre_link_objects_self_contained
} else if !(sess.target.os == "fuchsia" && flavor == LinkerFlavor::Gcc) { } else if !(sess.target.os == "fuchsia" && flavor == LinkerFlavor::Gcc) {
&opts.pre_link_objects &opts.pre_link_objects
} else { } else {
@ -1610,9 +1610,11 @@ fn add_post_link_objects(
link_output_kind: LinkOutputKind, link_output_kind: LinkOutputKind,
self_contained: bool, self_contained: bool,
) { ) {
let opts = &sess.target; let objects = if self_contained {
let objects = &sess.target.post_link_objects_self_contained
if self_contained { &opts.post_link_objects_fallback } else { &opts.post_link_objects }; } else {
&sess.target.post_link_objects
};
for obj in objects.get(&link_output_kind).iter().copied().flatten() { for obj in objects.get(&link_output_kind).iter().copied().flatten() {
cmd.add_object(&get_object_file_path(sess, obj, self_contained)); cmd.add_object(&get_object_file_path(sess, obj, self_contained));
} }
@ -1891,12 +1893,12 @@ fn linker_with_args<'a>(
out_filename: &Path, out_filename: &Path,
codegen_results: &CodegenResults, codegen_results: &CodegenResults,
) -> Result<Command, ErrorGuaranteed> { ) -> Result<Command, ErrorGuaranteed> {
let crt_objects_fallback = crt_objects_fallback(sess, crate_type); let self_contained = self_contained(sess, crate_type);
let cmd = &mut *super::linker::get_linker( let cmd = &mut *super::linker::get_linker(
sess, sess,
path, path,
flavor, flavor,
crt_objects_fallback, self_contained,
&codegen_results.crate_info.target_cpu, &codegen_results.crate_info.target_cpu,
); );
let link_output_kind = link_output_kind(sess, crate_type); let link_output_kind = link_output_kind(sess, crate_type);
@ -1923,7 +1925,7 @@ fn linker_with_args<'a>(
// ------------ Object code and libraries, order-dependent ------------ // ------------ Object code and libraries, order-dependent ------------
// Pre-link CRT objects. // Pre-link CRT objects.
add_pre_link_objects(cmd, sess, flavor, link_output_kind, crt_objects_fallback); add_pre_link_objects(cmd, sess, flavor, link_output_kind, self_contained);
add_linked_symbol_object( add_linked_symbol_object(
cmd, cmd,
@ -2033,7 +2035,7 @@ fn linker_with_args<'a>(
cmd, cmd,
sess, sess,
link_output_kind, link_output_kind,
crt_objects_fallback, self_contained,
flavor, flavor,
crate_type, crate_type,
codegen_results, codegen_results,
@ -2049,7 +2051,7 @@ fn linker_with_args<'a>(
// ------------ Object code and libraries, order-dependent ------------ // ------------ Object code and libraries, order-dependent ------------
// Post-link CRT objects. // Post-link CRT objects.
add_post_link_objects(cmd, sess, link_output_kind, crt_objects_fallback); add_post_link_objects(cmd, sess, link_output_kind, self_contained);
// ------------ Late order-dependent options ------------ // ------------ Late order-dependent options ------------
@ -2066,7 +2068,7 @@ fn add_order_independent_options(
cmd: &mut dyn Linker, cmd: &mut dyn Linker,
sess: &Session, sess: &Session,
link_output_kind: LinkOutputKind, link_output_kind: LinkOutputKind,
crt_objects_fallback: bool, self_contained: bool,
flavor: LinkerFlavor, flavor: LinkerFlavor,
crate_type: CrateType, crate_type: CrateType,
codegen_results: &CodegenResults, codegen_results: &CodegenResults,
@ -2098,7 +2100,7 @@ fn add_order_independent_options(
// Make the binary compatible with data execution prevention schemes. // Make the binary compatible with data execution prevention schemes.
cmd.add_no_exec(); cmd.add_no_exec();
if crt_objects_fallback { if self_contained {
cmd.no_crt_objects(); cmd.no_crt_objects();
} }
@ -2127,7 +2129,7 @@ fn add_order_independent_options(
cmd.linker_plugin_lto(); cmd.linker_plugin_lto();
add_library_search_dirs(cmd, sess, crt_objects_fallback); add_library_search_dirs(cmd, sess, self_contained);
cmd.output_filename(out_filename); cmd.output_filename(out_filename);

40
compiler/rustc_target/src/spec/crt_objects.rs
View File

@ -63,7 +63,7 @@ pub(super) fn all(obj: &'static str) -> CrtObjects {
]) ])
} }
pub(super) fn pre_musl_fallback() -> CrtObjects { pub(super) fn pre_musl_self_contained() -> CrtObjects {
new(&[ new(&[
(LinkOutputKind::DynamicNoPicExe, &["crt1.o", "crti.o", "crtbegin.o"]), (LinkOutputKind::DynamicNoPicExe, &["crt1.o", "crti.o", "crtbegin.o"]),
(LinkOutputKind::DynamicPicExe, &["Scrt1.o", "crti.o", "crtbeginS.o"]), (LinkOutputKind::DynamicPicExe, &["Scrt1.o", "crti.o", "crtbeginS.o"]),
@ -74,7 +74,7 @@ pub(super) fn pre_musl_fallback() -> CrtObjects {
]) ])
} }
pub(super) fn post_musl_fallback() -> CrtObjects { pub(super) fn post_musl_self_contained() -> CrtObjects {
new(&[ new(&[
(LinkOutputKind::DynamicNoPicExe, &["crtend.o", "crtn.o"]), (LinkOutputKind::DynamicNoPicExe, &["crtend.o", "crtn.o"]),
(LinkOutputKind::DynamicPicExe, &["crtendS.o", "crtn.o"]), (LinkOutputKind::DynamicPicExe, &["crtendS.o", "crtn.o"]),
@ -85,7 +85,7 @@ pub(super) fn post_musl_fallback() -> CrtObjects {
]) ])
} }
pub(super) fn pre_mingw_fallback() -> CrtObjects { pub(super) fn pre_mingw_self_contained() -> CrtObjects {
new(&[ new(&[
(LinkOutputKind::DynamicNoPicExe, &["crt2.o", "rsbegin.o"]), (LinkOutputKind::DynamicNoPicExe, &["crt2.o", "rsbegin.o"]),
(LinkOutputKind::DynamicPicExe, &["crt2.o", "rsbegin.o"]), (LinkOutputKind::DynamicPicExe, &["crt2.o", "rsbegin.o"]),
@ -96,7 +96,7 @@ pub(super) fn pre_mingw_fallback() -> CrtObjects {
]) ])
} }
pub(super) fn post_mingw_fallback() -> CrtObjects { pub(super) fn post_mingw_self_contained() -> CrtObjects {
all("rsend.o") all("rsend.o")
} }
@ -108,7 +108,7 @@ pub(super) fn post_mingw() -> CrtObjects {
all("rsend.o") all("rsend.o")
} }
pub(super) fn pre_wasi_fallback() -> CrtObjects { pub(super) fn pre_wasi_self_contained() -> CrtObjects {
// Use crt1-command.o instead of crt1.o to enable support for new-style // Use crt1-command.o instead of crt1.o to enable support for new-style
// commands. See https://reviews.llvm.org/D81689 for more info. // commands. See https://reviews.llvm.org/D81689 for more info.
new(&[ new(&[
@ -120,37 +120,41 @@ pub(super) fn pre_wasi_fallback() -> CrtObjects {
]) ])
} }
pub(super) fn post_wasi_fallback() -> CrtObjects { pub(super) fn post_wasi_self_contained() -> CrtObjects {
new(&[]) new(&[])
} }
/// Which logic to use to determine whether to fall back to the "self-contained" mode or not. /// Which logic to use to determine whether to use self-contained linking mode
/// if `-Clink-self-contained` is not specified explicitly.
#[derive(Clone, Copy, PartialEq, Hash, Debug)] #[derive(Clone, Copy, PartialEq, Hash, Debug)]
pub enum CrtObjectsFallback { pub enum LinkSelfContainedDefault {
False,
True,
Musl, Musl,
Mingw, Mingw,
Wasm,
} }
impl FromStr for CrtObjectsFallback { impl FromStr for LinkSelfContainedDefault {
type Err = (); type Err = ();
fn from_str(s: &str) -> Result<CrtObjectsFallback, ()> { fn from_str(s: &str) -> Result<LinkSelfContainedDefault, ()> {
Ok(match s { Ok(match s {
"musl" => CrtObjectsFallback::Musl, "false" => LinkSelfContainedDefault::False,
"mingw" => CrtObjectsFallback::Mingw, "true" | "wasm" => LinkSelfContainedDefault::True,
"wasm" => CrtObjectsFallback::Wasm, "musl" => LinkSelfContainedDefault::Musl,
"mingw" => LinkSelfContainedDefault::Mingw,
_ => return Err(()), _ => return Err(()),
}) })
} }
} }
impl ToJson for CrtObjectsFallback { impl ToJson for LinkSelfContainedDefault {
fn to_json(&self) -> Json { fn to_json(&self) -> Json {
match *self { match *self {
CrtObjectsFallback::Musl => "musl", LinkSelfContainedDefault::False => "false",
CrtObjectsFallback::Mingw => "mingw", LinkSelfContainedDefault::True => "true",
CrtObjectsFallback::Wasm => "wasm", LinkSelfContainedDefault::Musl => "musl",
LinkSelfContainedDefault::Mingw => "mingw",
} }
.to_json() .to_json()
} }

8
compiler/rustc_target/src/spec/linux_musl_base.rs
View File

@ -1,13 +1,13 @@
use crate::spec::crt_objects::{self, CrtObjectsFallback}; use crate::spec::crt_objects::{self, LinkSelfContainedDefault};
use crate::spec::TargetOptions; use crate::spec::TargetOptions;
pub fn opts() -> TargetOptions { pub fn opts() -> TargetOptions {
let mut base = super::linux_base::opts(); let mut base = super::linux_base::opts();
base.env = "musl".into(); base.env = "musl".into();
base.pre_link_objects_fallback = crt_objects::pre_musl_fallback(); base.pre_link_objects_self_contained = crt_objects::pre_musl_self_contained();
base.post_link_objects_fallback = crt_objects::post_musl_fallback(); base.post_link_objects_self_contained = crt_objects::post_musl_self_contained();
base.crt_objects_fallback = Some(CrtObjectsFallback::Musl); base.link_self_contained = LinkSelfContainedDefault::Musl;
// These targets statically link libc by default // These targets statically link libc by default
base.crt_static_default = true; base.crt_static_default = true;

55
compiler/rustc_target/src/spec/mod.rs
View File

@ -37,7 +37,7 @@
use crate::abi::Endian; use crate::abi::Endian;
use crate::json::{Json, ToJson}; use crate::json::{Json, ToJson};
use crate::spec::abi::{lookup as lookup_abi, Abi}; use crate::spec::abi::{lookup as lookup_abi, Abi};
use crate::spec::crt_objects::{CrtObjects, CrtObjectsFallback}; use crate::spec::crt_objects::{CrtObjects, LinkSelfContainedDefault};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use rustc_span::symbol::{sym, Symbol}; use rustc_span::symbol::{sym, Symbol};
@ -1172,13 +1172,10 @@ pub struct TargetOptions {
/// 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,
/// Same as `(pre|post)_link_objects`, but when we fail to pull the objects with help of the /// Same as `(pre|post)_link_objects`, but when self-contained linking mode is enabled.
/// target's native gcc and fall back to the "self-contained" mode and pull them manually. pub pre_link_objects_self_contained: CrtObjects,
/// See `crt_objects.rs` for some more detailed documentation. pub post_link_objects_self_contained: CrtObjects,
pub pre_link_objects_fallback: CrtObjects, pub link_self_contained: LinkSelfContainedDefault,
pub post_link_objects_fallback: CrtObjects,
/// Which logic to use to determine whether to fall back to the "self-contained" mode or not.
pub crt_objects_fallback: Option<CrtObjectsFallback>,
/// 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
@ -1554,9 +1551,9 @@ impl Default for TargetOptions {
relro_level: RelroLevel::None, relro_level: RelroLevel::None,
pre_link_objects: Default::default(), pre_link_objects: Default::default(),
post_link_objects: Default::default(), post_link_objects: Default::default(),
pre_link_objects_fallback: Default::default(), pre_link_objects_self_contained: Default::default(),
post_link_objects_fallback: Default::default(), post_link_objects_self_contained: Default::default(),
crt_objects_fallback: None, link_self_contained: LinkSelfContainedDefault::False,
late_link_args: LinkArgs::new(), late_link_args: LinkArgs::new(),
late_link_args_dynamic: LinkArgs::new(), late_link_args_dynamic: LinkArgs::new(),
late_link_args_static: LinkArgs::new(), late_link_args_static: LinkArgs::new(),
@ -1977,20 +1974,20 @@ impl Target {
Ok::<(), String>(()) Ok::<(), String>(())
} ); } );
($key_name:ident, crt_objects_fallback) => ( { ($key_name:ident = $json_name:expr, link_self_contained) => ( {
let name = (stringify!($key_name)).replace("_", "-"); let name = $json_name;
obj.remove(&name).and_then(|o| o.as_str().and_then(|s| { obj.remove(name).and_then(|o| o.as_str().and_then(|s| {
match s.parse::<CrtObjectsFallback>() { match s.parse::<LinkSelfContainedDefault>() {
Ok(fallback) => base.$key_name = Some(fallback), Ok(lsc_default) => base.$key_name = lsc_default,
_ => return Some(Err(format!("'{}' is not a valid CRT objects fallback. \ _ => return Some(Err(format!("'{}' is not a valid `-Clink-self-contained` default. \
Use 'musl', 'mingw' or 'wasm'", s))), Use 'false', 'true', 'musl' or 'mingw'", s))),
} }
Some(Ok(())) Some(Ok(()))
})).unwrap_or(Ok(())) })).unwrap_or(Ok(()))
} ); } );
($key_name:ident, link_objects) => ( { ($key_name:ident = $json_name:expr, link_objects) => ( {
let name = (stringify!($key_name)).replace("_", "-"); let name = $json_name;
if let Some(val) = obj.remove(&name) { if let Some(val) = obj.remove(name) {
let obj = val.as_object().ok_or_else(|| format!("{}: expected a \ let obj = val.as_object().ok_or_else(|| format!("{}: expected a \
JSON object with fields per CRT object kind.", name))?; JSON object with fields per CRT object kind.", name))?;
let mut args = CrtObjects::new(); let mut args = CrtObjects::new();
@ -2112,11 +2109,11 @@ impl Target {
key!(linker_flavor, LinkerFlavor)?; key!(linker_flavor, LinkerFlavor)?;
key!(linker, optional); key!(linker, optional);
key!(lld_flavor, LldFlavor)?; key!(lld_flavor, LldFlavor)?;
key!(pre_link_objects, link_objects); key!(pre_link_objects = "pre-link-objects", link_objects);
key!(post_link_objects, link_objects); key!(post_link_objects = "post-link-objects", link_objects);
key!(pre_link_objects_fallback, link_objects); key!(pre_link_objects_self_contained = "pre-link-objects-fallback", link_objects);
key!(post_link_objects_fallback, link_objects); key!(post_link_objects_self_contained = "post-link-objects-fallback", link_objects);
key!(crt_objects_fallback, crt_objects_fallback)?; key!(link_self_contained = "crt-objects-fallback", link_self_contained)?;
key!(pre_link_args, link_args); key!(pre_link_args, link_args);
key!(late_link_args, link_args); key!(late_link_args, link_args);
key!(late_link_args_dynamic, link_args); key!(late_link_args_dynamic, link_args);
@ -2357,9 +2354,9 @@ impl ToJson for Target {
target_option_val!(lld_flavor); target_option_val!(lld_flavor);
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_fallback); target_option_val!(pre_link_objects_self_contained, "pre-link-objects-fallback");
target_option_val!(post_link_objects_fallback); target_option_val!(post_link_objects_self_contained, "post-link-objects-fallback");
target_option_val!(crt_objects_fallback); target_option_val!(link_self_contained, "crt-objects-fallback");
target_option_val!(link_args - pre_link_args); target_option_val!(link_args - pre_link_args);
target_option_val!(link_args - late_link_args); target_option_val!(link_args - late_link_args);
target_option_val!(link_args - late_link_args_dynamic); target_option_val!(link_args - late_link_args_dynamic);

6
compiler/rustc_target/src/spec/tests/tests_impl.rs
View File

@ -110,9 +110,9 @@ impl Target {
} }
assert!( assert!(
(self.pre_link_objects_fallback.is_empty() (self.pre_link_objects_self_contained.is_empty()
&& self.post_link_objects_fallback.is_empty()) && self.post_link_objects_self_contained.is_empty())
|| self.crt_objects_fallback.is_some() || self.link_self_contained != LinkSelfContainedDefault::False
); );
// If your target really needs to deviate from the rules below, // If your target really needs to deviate from the rules below,

4
compiler/rustc_target/src/spec/wasm32_wasi.rs
View File

@ -82,8 +82,8 @@ pub fn target() -> Target {
options.linker_flavor = LinkerFlavor::Lld(LldFlavor::Wasm); options.linker_flavor = LinkerFlavor::Lld(LldFlavor::Wasm);
options.add_pre_link_args(LinkerFlavor::Gcc, &["--target=wasm32-wasi"]); options.add_pre_link_args(LinkerFlavor::Gcc, &["--target=wasm32-wasi"]);
options.pre_link_objects_fallback = crt_objects::pre_wasi_fallback(); options.pre_link_objects_self_contained = crt_objects::pre_wasi_self_contained();
options.post_link_objects_fallback = crt_objects::post_wasi_fallback(); options.post_link_objects_self_contained = crt_objects::post_wasi_self_contained();
// Right now this is a bit of a workaround but we're currently saying that // Right now this is a bit of a workaround but we're currently saying that
// the target by default has a static crt which we're taking as a signal // the target by default has a static crt which we're taking as a signal

5
compiler/rustc_target/src/spec/wasm_base.rs
View File

@ -1,4 +1,4 @@
use super::crt_objects::CrtObjectsFallback; use super::crt_objects::LinkSelfContainedDefault;
use super::{cvs, LinkerFlavor, LldFlavor, PanicStrategy, RelocModel, TargetOptions, TlsModel}; use super::{cvs, LinkerFlavor, LldFlavor, PanicStrategy, RelocModel, TargetOptions, TlsModel};
pub fn options() -> TargetOptions { pub fn options() -> TargetOptions {
@ -96,7 +96,8 @@ pub fn options() -> TargetOptions {
pre_link_args, pre_link_args,
crt_objects_fallback: Some(CrtObjectsFallback::Wasm), // FIXME: Figure out cases in which WASM needs to link with a native toolchain.
link_self_contained: LinkSelfContainedDefault::True,
// This has no effect in LLVM 8 or prior, but in LLVM 9 and later when // This has no effect in LLVM 8 or prior, but in LLVM 9 and later when
// PIC code is implemented this has quite a drastic effect if it stays // PIC code is implemented this has quite a drastic effect if it stays

8
compiler/rustc_target/src/spec/windows_gnu_base.rs
View File

@ -1,4 +1,4 @@
use crate::spec::crt_objects::{self, CrtObjectsFallback}; use crate::spec::crt_objects::{self, LinkSelfContainedDefault};
use crate::spec::{cvs, LinkerFlavor, TargetOptions}; use crate::spec::{cvs, LinkerFlavor, TargetOptions};
pub fn opts() -> TargetOptions { pub fn opts() -> TargetOptions {
@ -76,9 +76,9 @@ pub fn opts() -> TargetOptions {
pre_link_args, pre_link_args,
pre_link_objects: crt_objects::pre_mingw(), pre_link_objects: crt_objects::pre_mingw(),
post_link_objects: crt_objects::post_mingw(), post_link_objects: crt_objects::post_mingw(),
pre_link_objects_fallback: crt_objects::pre_mingw_fallback(), pre_link_objects_self_contained: crt_objects::pre_mingw_self_contained(),
post_link_objects_fallback: crt_objects::post_mingw_fallback(), post_link_objects_self_contained: crt_objects::post_mingw_self_contained(),
crt_objects_fallback: Some(CrtObjectsFallback::Mingw), link_self_contained: LinkSelfContainedDefault::Mingw,
late_link_args, late_link_args,
late_link_args_dynamic, late_link_args_dynamic,
late_link_args_static, late_link_args_static,