OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rustc_target: Refactor away `TargetResult` 

Construction of a built-in target is always infallible now, so `TargetResult` is no longer necessary.
This commit is contained in:
Vadim Petrochenkov 2020-10-05 15:37:55 +03:00
parent f317a93d4d
commit 021fcbd90c
158 changed files with 619 additions and 630 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::apple_base::opts();
base.cpu = "apple-a12".to_string();
base.max_atomic_width = Some(128);
@ -14,7 +14,7 @@ pub fn target() -> TargetResult {
let arch = "aarch64";
let llvm_target = super::apple_base::macos_llvm_target(&arch);
Ok(Target {
Target {
llvm_target,
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -26,5 +26,5 @@ pub fn target() -> TargetResult {
target_vendor: "apple".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "\u{1}mcount".to_string(), ..base },
})
}
}

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

@ -1,9 +1,9 @@
use super::apple_sdk_base::{opts, Arch};
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = opts(Arch::Arm64);
Ok(Target {
Target {
llvm_target: "arm64-apple-ios".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -33,5 +33,5 @@ pub fn target() -> TargetResult {
.to_string(),
..base
},
})
}
}

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

@ -1,9 +1,9 @@
use super::apple_sdk_base::{opts, Arch};
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = opts(Arch::Arm64);
Ok(Target {
Target {
llvm_target: "arm64-apple-tvos".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -22,5 +22,5 @@ pub fn target() -> TargetResult {
forces_embed_bitcode: true,
..base
},
})
}
}

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

@ -1,10 +1,10 @@
use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::fuchsia_base::opts();
base.max_atomic_width = Some(128);
Ok(Target {
Target {
llvm_target: "aarch64-fuchsia".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -16,5 +16,5 @@ pub fn target() -> TargetResult {
target_vendor: String::new(),
linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
}

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

@ -1,15 +1,15 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
// See https://developer.android.com/ndk/guides/abis.html#arm64-v8a
// for target ABI requirements.
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::android_base::opts();
base.max_atomic_width = Some(128);
// As documented in http://developer.android.com/ndk/guides/cpu-features.html
// the neon (ASIMD) and FP must exist on all android aarch64 targets.
base.features = "+neon,+fp-armv8".to_string();
Ok(Target {
Target {
llvm_target: "aarch64-linux-android".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::windows_msvc_base::opts();
base.max_atomic_width = Some(64);
base.has_elf_tls = true;
base.features = "+neon,+fp-armv8".to_string();
Ok(Target {
Target {
llvm_target: "aarch64-pc-windows-msvc".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "pc".to_string(),
linker_flavor: LinkerFlavor::Msvc,
options: base,
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::cloudabi_base::opts();
base.max_atomic_width = Some(128);
base.unsupported_abis = super::arm_base::unsupported_abis();
base.linker = Some("aarch64-unknown-cloudabi-cc".to_string());
Ok(Target {
Target {
llvm_target: "aarch64-unknown-cloudabi".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,10 +1,10 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::freebsd_base::opts();
base.max_atomic_width = Some(128);
Ok(Target {
Target {
llvm_target: "aarch64-unknown-freebsd".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -16,5 +16,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
}

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

@ -1,10 +1,10 @@
use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, LldFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::hermit_base::opts();
base.max_atomic_width = Some(128);
Ok(Target {
Target {
llvm_target: "aarch64-unknown-hermit".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -16,5 +16,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
options: base,
})
}
}

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

@ -1,10 +1,10 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_base::opts();
base.max_atomic_width = Some(128);
Ok(Target {
Target {
llvm_target: "aarch64-unknown-linux-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -20,5 +20,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}_mcount".to_string(),
..base
},
})
}
}

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

@ -1,10 +1,10 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
base.max_atomic_width = Some(128);
Ok(Target {
Target {
llvm_target: "aarch64-unknown-linux-musl".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -20,5 +20,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}_mcount".to_string(),
..base
},
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::netbsd_base::opts();
base.max_atomic_width = Some(128);
base.unsupported_abis = super::arm_base::unsupported_abis();
Ok(Target {
Target {
llvm_target: "aarch64-unknown-netbsd".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -17,5 +17,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "__mcount".to_string(), ..base },
})
}
}

6
compiler/rustc_target/src/spec/aarch64_unknown_none.rs
View File

@ -8,7 +8,7 @@
use super::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel, Target, TargetOptions};
pub fn target() -> Result<Target, String> {
pub fn target() -> Target {
let opts = TargetOptions {
linker: Some("rust-lld".to_owned()),
features: "+strict-align,+neon,+fp-armv8".to_string(),
@ -21,7 +21,7 @@ pub fn target() -> Result<Target, String> {
unsupported_abis: super::arm_base::unsupported_abis(),
..Default::default()
};
Ok(Target {
Target {
llvm_target: "aarch64-unknown-none".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -33,5 +33,5 @@ pub fn target() -> Result<Target, String> {
arch: "aarch64".to_string(),
linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
options: opts,
})
}
}

6
compiler/rustc_target/src/spec/aarch64_unknown_none_softfloat.rs
View File

@ -8,7 +8,7 @@
use super::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel, Target, TargetOptions};
pub fn target() -> Result<Target, String> {
pub fn target() -> Target {
let opts = TargetOptions {
linker: Some("rust-lld".to_owned()),
features: "+strict-align,-neon,-fp-armv8".to_string(),
@ -21,7 +21,7 @@ pub fn target() -> Result<Target, String> {
unsupported_abis: super::arm_base::unsupported_abis(),
..Default::default()
};
Ok(Target {
Target {
llvm_target: "aarch64-unknown-none".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -33,5 +33,5 @@ pub fn target() -> Result<Target, String> {
arch: "aarch64".to_string(),
linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
options: opts,
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::openbsd_base::opts();
base.max_atomic_width = Some(128);
base.unsupported_abis = super::arm_base::unsupported_abis();
Ok(Target {
Target {
llvm_target: "aarch64-unknown-openbsd".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -17,5 +17,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,10 +1,10 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::redox_base::opts();
base.max_atomic_width = Some(128);
Ok(Target {
Target {
llvm_target: "aarch64-unknown-redox".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -16,5 +16,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::windows_uwp_msvc_base::opts();
base.max_atomic_width = Some(64);
base.has_elf_tls = true;
Ok(Target {
Target {
llvm_target: "aarch64-pc-windows-msvc".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -17,5 +17,5 @@ pub fn target() -> TargetResult {
target_vendor: "uwp".to_string(),
linker_flavor: LinkerFlavor::Msvc,
options: base,
})
}
}

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

@ -1,10 +1,10 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::vxworks_base::opts();
base.max_atomic_width = Some(128);
Ok(Target {
Target {
llvm_target: "aarch64-unknown-linux-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -16,5 +16,5 @@ pub fn target() -> TargetResult {
target_vendor: "wrs".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::android_base::opts();
// https://developer.android.com/ndk/guides/abis.html#armeabi
base.features = "+strict-align,+v5te".to_string();
base.max_atomic_width = Some(32);
Ok(Target {
Target {
llvm_target: "arm-linux-androideabi".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
}

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

@ -1,9 +1,9 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_base::opts();
base.max_atomic_width = Some(64);
Ok(Target {
Target {
llvm_target: "arm-unknown-linux-gnueabi".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
})
}
}

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

@ -1,9 +1,9 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_base::opts();
base.max_atomic_width = Some(64);
Ok(Target {
Target {
llvm_target: "arm-unknown-linux-gnueabihf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
})
}
}

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

@ -1,13 +1,13 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
// Most of these settings are copied from the arm_unknown_linux_gnueabi
// target.
base.features = "+strict-align,+v6".to_string();
base.max_atomic_width = Some(64);
Ok(Target {
Target {
// It's important we use "gnueabi" and not "musleabi" here. LLVM uses it
// to determine the calling convention and float ABI, and it doesn't
// support the "musleabi" value.
@ -26,5 +26,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}mcount".to_string(),
..base
},
})
}
}

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

@ -1,13 +1,13 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
// Most of these settings are copied from the arm_unknown_linux_gnueabihf
// target.
base.features = "+strict-align,+v6,+vfp2,-d32".to_string();
base.max_atomic_width = Some(64);
Ok(Target {
Target {
// It's important we use "gnueabihf" and not "musleabihf" here. LLVM
// uses it to determine the calling convention and float ABI, and it
// doesn't support the "musleabihf" value.
@ -26,5 +26,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}mcount".to_string(),
..base
},
})
}
}

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

@ -1,10 +1,10 @@
// Targets the Big endian Cortex-R4/R5 processor (ARMv7-R)
use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel};
use crate::spec::{Target, TargetOptions, TargetResult};
use crate::spec::{Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "armebv7r-unknown-none-eabi".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -26,5 +26,5 @@ pub fn target() -> TargetResult {
emit_debug_gdb_scripts: false,
..Default::default()
},
})
}
}

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

@ -1,10 +1,10 @@
// Targets the Cortex-R4F/R5F processor (ARMv7-R)
use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel};
use crate::spec::{Target, TargetOptions, TargetResult};
use crate::spec::{Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "armebv7r-unknown-none-eabihf".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -27,5 +27,5 @@ pub fn target() -> TargetResult {
emit_debug_gdb_scripts: false,
..Default::default()
},
})
}
}

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

@ -1,8 +1,8 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::linux_base::opts();
Ok(Target {
Target {
llvm_target: "armv4t-unknown-linux-gnueabi".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -22,5 +22,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
})
}
}

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

@ -1,8 +1,8 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::linux_base::opts();
Ok(Target {
Target {
llvm_target: "armv5te-unknown-linux-gnueabi".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -22,5 +22,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
})
}
}

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

@ -1,8 +1,8 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::linux_musl_base::opts();
Ok(Target {
Target {
// It's important we use "gnueabihf" and not "musleabihf" here. LLVM
// uses it to determine the calling convention and float ABI, and LLVM
// doesn't support the "musleabihf" value.
@ -25,5 +25,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}mcount".to_string(),
..base
},
})
}
}

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

@ -1,8 +1,8 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::freebsd_base::opts();
Ok(Target {
Target {
llvm_target: "armv6-unknown-freebsd-gnueabihf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
})
}
}

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

@ -1,9 +1,9 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::netbsd_base::opts();
base.max_atomic_width = Some(64);
Ok(Target {
Target {
llvm_target: "armv6-unknown-netbsdelf-eabihf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
target_mcount: "__mcount".to_string(),
..base
},
})
}
}

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

@ -1,9 +1,9 @@
use super::apple_sdk_base::{opts, Arch};
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = opts(Arch::Armv7);
Ok(Target {
Target {
llvm_target: "armv7-apple-ios".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -20,5 +20,5 @@ pub fn target() -> TargetResult {
unsupported_abis: super::arm_base::unsupported_abis(),
..base
},
})
}
}

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

@ -1,4 +1,4 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
// This target if is for the baseline of the Android v7a ABI
// in thumb mode. It's named armv7-* instead of thumbv7-*
@ -8,13 +8,13 @@ use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
// See https://developer.android.com/ndk/guides/abis.html#v7a
// for target ABI requirements.
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::android_base::opts();
base.features = "+v7,+thumb-mode,+thumb2,+vfp3,-d32,-neon".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-march=armv7-a".to_string());
Ok(Target {
Target {
llvm_target: "armv7-none-linux-android".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -26,5 +26,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::cloudabi_base::opts();
base.cpu = "cortex-a8".to_string();
base.max_atomic_width = Some(64);
@ -8,7 +8,7 @@ pub fn target() -> TargetResult {
base.unsupported_abis = super::arm_base::unsupported_abis();
base.linker = Some("armv7-unknown-cloudabi-eabihf-cc".to_string());
Ok(Target {
Target {
llvm_target: "armv7-unknown-cloudabi-eabihf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -20,5 +20,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "\u{1}mcount".to_string(), ..base },
})
}
}

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

@ -1,8 +1,8 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::freebsd_base::opts();
Ok(Target {
Target {
llvm_target: "armv7-unknown-freebsd-gnueabihf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
// This target is for glibc Linux on ARMv7 without thumb-mode, NEON or
// hardfloat.
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::linux_base::opts();
Ok(Target {
Target {
llvm_target: "armv7-unknown-linux-gnueabi".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -25,5 +25,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
// This target is for glibc Linux on ARMv7 without NEON or
// thumb-mode. See the thumbv7neon variant for enabling both.
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::linux_base::opts();
Ok(Target {
Target {
llvm_target: "armv7-unknown-linux-gnueabihf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -26,5 +26,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
})
}
}

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

@ -1,13 +1,13 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
// This target is for musl Linux on ARMv7 without thumb-mode, NEON or
// hardfloat.
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::linux_musl_base::opts();
// Most of these settings are copied from the armv7_unknown_linux_gnueabi
// target.
Ok(Target {
Target {
// It's important we use "gnueabi" and not "musleabi" here. LLVM uses it
// to determine the calling convention and float ABI, and it doesn't
// support the "musleabi" value.
@ -30,5 +30,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}mcount".to_string(),
..base
},
})
}
}

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

@ -1,10 +1,10 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
// This target is for musl Linux on ARMv7 without thumb-mode or NEON.
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::linux_musl_base::opts();
Ok(Target {
Target {
// It's important we use "gnueabihf" and not "musleabihf" here. LLVM
// uses it to determine the calling convention and float ABI, and LLVM
// doesn't support the "musleabihf" value.
@ -29,5 +29,5 @@ pub fn target() -> TargetResult {
target_mcount: "\u{1}mcount".to_string(),
..base
},
})
}
}

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

@ -1,8 +1,8 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::netbsd_base::opts();
Ok(Target {
Target {
llvm_target: "armv7-unknown-netbsdelf-eabihf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -22,5 +22,5 @@ pub fn target() -> TargetResult {
target_mcount: "__mcount".to_string(),
..base
},
})
}
}

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

@ -1,8 +1,8 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = super::vxworks_base::opts();
Ok(Target {
Target {
llvm_target: "armv7-unknown-linux-gnueabihf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
unsupported_abis: super::arm_base::unsupported_abis(),
..base
},
})
}
}

6
compiler/rustc_target/src/spec/armv7a_none_eabi.rs
View File

@ -19,7 +19,7 @@
use super::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel, Target, TargetOptions};
pub fn target() -> Result<Target, String> {
pub fn target() -> Target {
let opts = TargetOptions {
linker: Some("rust-lld".to_owned()),
features: "+v7,+thumb2,+soft-float,-neon,+strict-align".to_string(),
@ -32,7 +32,7 @@ pub fn target() -> Result<Target, String> {
emit_debug_gdb_scripts: false,
..Default::default()
};
Ok(Target {
Target {
llvm_target: "armv7a-none-eabi".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -44,5 +44,5 @@ pub fn target() -> Result<Target, String> {
arch: "arm".to_string(),
linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
options: opts,
})
}
}

6
compiler/rustc_target/src/spec/armv7a_none_eabihf.rs
View File

@ -7,7 +7,7 @@
use super::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel, Target, TargetOptions};
pub fn target() -> Result<Target, String> {
pub fn target() -> Target {
let opts = TargetOptions {
linker: Some("rust-lld".to_owned()),
features: "+v7,+vfp3,-d32,+thumb2,-neon,+strict-align".to_string(),
@ -20,7 +20,7 @@ pub fn target() -> Result<Target, String> {
emit_debug_gdb_scripts: false,
..Default::default()
};
Ok(Target {
Target {
llvm_target: "armv7a-none-eabihf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -32,5 +32,5 @@ pub fn target() -> Result<Target, String> {
arch: "arm".to_string(),
linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
options: opts,
})
}
}

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

@ -1,10 +1,10 @@
// Targets the Little-endian Cortex-R4/R5 processor (ARMv7-R)
use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel};
use crate::spec::{Target, TargetOptions, TargetResult};
use crate::spec::{Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "armv7r-unknown-none-eabi".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -26,5 +26,5 @@ pub fn target() -> TargetResult {
emit_debug_gdb_scripts: false,
..Default::default()
},
})
}
}

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

@ -1,10 +1,10 @@
// Targets the Little-endian Cortex-R4F/R5F processor (ARMv7-R)
use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel};
use crate::spec::{Target, TargetOptions, TargetResult};
use crate::spec::{Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "armv7r-unknown-none-eabihf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -27,5 +27,5 @@ pub fn target() -> TargetResult {
emit_debug_gdb_scripts: false,
..Default::default()
},
})
}
}

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

@ -1,9 +1,9 @@
use super::apple_sdk_base::{opts, Arch};
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = opts(Arch::Armv7s);
Ok(Target {
Target {
llvm_target: "armv7s-apple-ios".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -20,5 +20,5 @@ pub fn target() -> TargetResult {
unsupported_abis: super::arm_base::unsupported_abis(),
..base
},
})
}
}

6
compiler/rustc_target/src/spec/asmjs_unknown_emscripten.rs
View File

@ -1,12 +1,12 @@
use super::{wasm32_unknown_emscripten, LinkerFlavor, Target};
pub fn target() -> Result<Target, String> {
let mut target = wasm32_unknown_emscripten::target()?;
pub fn target() -> Target {
let mut target = wasm32_unknown_emscripten::target();
target
.options
.post_link_args
.entry(LinkerFlavor::Em)
.or_default()
.extend(vec!["-s".to_string(), "WASM=0".to_string()]);
Ok(target)
target
}

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

@ -1,10 +1,10 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
/// A base target for AVR devices using the GNU toolchain.
///
/// Requires GNU avr-gcc and avr-binutils on the host system.
pub fn target(target_cpu: String) -> TargetResult {
Ok(Target {
pub fn target(target_cpu: String) -> Target {
Target {
arch: "avr".to_string(),
data_layout: "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8".to_string(),
llvm_target: "avr-unknown-unknown".to_string(),
@ -49,5 +49,5 @@ pub fn target(target_cpu: String) -> TargetResult {
atomic_cas: false,
..TargetOptions::default()
},
})
}
}

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

@ -1,5 +1,5 @@
use crate::spec::TargetResult;
use crate::spec::Target;
pub fn target() -> TargetResult {
pub fn target() -> Target {
super::avr_gnu_base::target("atmega328".to_owned())
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkArgs, LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkArgs, LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
base.cpu = "hexagonv60".to_string();
base.max_atomic_width = Some(32);
@ -17,7 +17,7 @@ pub fn target() -> TargetResult {
base.pre_link_args = LinkArgs::new();
base.post_link_args = LinkArgs::new();
Ok(Target {
Target {
llvm_target: "hexagon-unknown-linux-musl".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -35,5 +35,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,9 +1,9 @@
use super::apple_sdk_base::{opts, Arch};
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let base = opts(Arch::I386);
Ok(Target {
Target {
llvm_target: "i386-apple-ios".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -17,5 +17,5 @@ pub fn target() -> TargetResult {
target_vendor: "apple".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { max_atomic_width: Some(64), stack_probes: true, ..base },
})
}
}

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

@ -1,8 +1,8 @@
use crate::spec::TargetResult;
use crate::spec::Target;
pub fn target() -> TargetResult {
let mut base = super::i686_pc_windows_msvc::target()?;
pub fn target() -> Target {
let mut base = super::i686_pc_windows_msvc::target();
base.options.cpu = "pentium".to_string();
base.llvm_target = "i586-pc-windows-msvc".to_string();
Ok(base)
base
}

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

@ -1,8 +1,8 @@
use crate::spec::TargetResult;
use crate::spec::Target;
pub fn target() -> TargetResult {
let mut base = super::i686_unknown_linux_gnu::target()?;
pub fn target() -> Target {
let mut base = super::i686_unknown_linux_gnu::target();
base.options.cpu = "pentium".to_string();
base.llvm_target = "i586-unknown-linux-gnu".to_string();
Ok(base)
base
}

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

@ -1,8 +1,8 @@
use crate::spec::TargetResult;
use crate::spec::Target;
pub fn target() -> TargetResult {
let mut base = super::i686_unknown_linux_musl::target()?;
pub fn target() -> Target {
let mut base = super::i686_unknown_linux_musl::target();
base.options.cpu = "pentium".to_string();
base.llvm_target = "i586-unknown-linux-musl".to_string();
Ok(base)
base
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::apple_base::opts();
base.cpu = "yonah".to_string();
base.max_atomic_width = Some(64);
@ -15,7 +15,7 @@ pub fn target() -> TargetResult {
let arch = "i686";
let llvm_target = super::apple_base::macos_llvm_target(&arch);
Ok(Target {
Target {
llvm_target,
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -29,5 +29,5 @@ pub fn target() -> TargetResult {
target_vendor: "apple".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "\u{1}mcount".to_string(), ..base },
})
}
}

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

@ -1,9 +1,9 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
// See https://developer.android.com/ndk/guides/abis.html#x86
// for target ABI requirements.
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::android_base::opts();
base.max_atomic_width = Some(64);
@ -13,7 +13,7 @@ pub fn target() -> TargetResult {
base.features = "+mmx,+sse,+sse2,+sse3,+ssse3".to_string();
base.stack_probes = true;
Ok(Target {
Target {
llvm_target: "i686-linux-android".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -27,5 +27,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, LldFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::windows_gnu_base::opts();
base.cpu = "pentium4".to_string();
base.pre_link_args
@ -16,7 +16,7 @@ pub fn target() -> TargetResult {
.unwrap()
.push("-Wl,--large-address-aware".to_string());
Ok(Target {
Target {
llvm_target: "i686-pc-windows-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -30,5 +30,5 @@ pub fn target() -> TargetResult {
target_vendor: "pc".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, LldFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::windows_msvc_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
@ -20,7 +20,7 @@ pub fn target() -> TargetResult {
.unwrap()
.extend(pre_link_args_msvc);
Ok(Target {
Target {
llvm_target: "i686-pc-windows-msvc".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -34,5 +34,5 @@ pub fn target() -> TargetResult {
target_vendor: "pc".to_string(),
linker_flavor: LinkerFlavor::Msvc,
options: base,
})
}
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::cloudabi_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
@ -8,7 +8,7 @@ pub fn target() -> TargetResult {
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.stack_probes = true;
Ok(Target {
Target {
llvm_target: "i686-unknown-cloudabi".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -22,5 +22,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::freebsd_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
@ -9,7 +9,7 @@ pub fn target() -> TargetResult {
pre_link_args.push("-Wl,-znotext".to_string());
base.stack_probes = true;
Ok(Target {
Target {
llvm_target: "i686-unknown-freebsd".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -23,5 +23,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,13 +1,13 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::haiku_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-m32".to_string()]);
base.stack_probes = true;
Ok(Target {
Target {
llvm_target: "i686-unknown-haiku".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,13 +1,13 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.stack_probes = true;
Ok(Target {
Target {
llvm_target: "i686-unknown-linux-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
@ -22,7 +22,7 @@ pub fn target() -> TargetResult {
// https://llvm.org/bugs/show_bug.cgi?id=30879
base.eliminate_frame_pointer = false;
Ok(Target {
Target {
llvm_target: "i686-unknown-linux-musl".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -36,5 +36,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,13 +1,13 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::netbsd_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.stack_probes = true;
Ok(Target {
Target {
llvm_target: "i686-unknown-netbsdelf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "__mcount".to_string(), ..base },
})
}
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::openbsd_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
@ -8,7 +8,7 @@ pub fn target() -> TargetResult {
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-fuse-ld=lld".to_string());
base.stack_probes = true;
Ok(Target {
Target {
llvm_target: "i686-unknown-openbsd".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -22,5 +22,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -5,9 +5,9 @@
// The cdecl ABI is used. It differs from the stdcall or fastcall ABI.
// "i686-unknown-windows" is used to get the minimal subset of windows-specific features.
use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, LldFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::uefi_msvc_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
@ -76,7 +76,7 @@ pub fn target() -> TargetResult {
// As a result, we choose -gnu for i686 version before those intrisics are implemented in
// compiler-builtins. After compiler-builtins implements all required intrinsics, we may
// remove -gnu and use the default one.
Ok(Target {
Target {
llvm_target: "i686-unknown-windows-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -91,5 +91,5 @@ pub fn target() -> TargetResult {
linker_flavor: LinkerFlavor::Lld(LldFlavor::Link),
options: base,
})
}
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, LldFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::windows_uwp_gnu_base::opts();
base.cpu = "pentium4".to_string();
base.pre_link_args
@ -15,7 +15,7 @@ pub fn target() -> TargetResult {
.unwrap()
.push("-Wl,--large-address-aware".to_string());
Ok(Target {
Target {
llvm_target: "i686-pc-windows-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -29,5 +29,5 @@ pub fn target() -> TargetResult {
target_vendor: "uwp".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::windows_uwp_msvc_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.has_elf_tls = true;
Ok(Target {
Target {
llvm_target: "i686-pc-windows-msvc".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -20,5 +20,5 @@ pub fn target() -> TargetResult {
target_vendor: "uwp".to_string(),
linker_flavor: LinkerFlavor::Msvc,
options: base,
})
}
}

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

@ -1,13 +1,13 @@
use crate::spec::{LinkerFlavor, Target, TargetResult};
use crate::spec::{LinkerFlavor, Target};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::vxworks_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.stack_probes = true;
Ok(Target {
Target {
llvm_target: "i686-unknown-linux-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
target_vendor: "wrs".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: base,
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "mips64-unknown-linux-gnuabi64".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "64".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
..super::linux_base::opts()
},
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
base.cpu = "mips64r2".to_string();
base.features = "+mips64r2".to_string();
base.max_atomic_width = Some(64);
Ok(Target {
Target {
// LLVM doesn't recognize "muslabi64" yet.
llvm_target: "mips64-unknown-linux-musl".to_string(),
target_endian: "big".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "mips64el-unknown-linux-gnuabi64".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
..super::linux_base::opts()
},
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
base.cpu = "mips64r2".to_string();
base.features = "+mips64r2".to_string();
base.max_atomic_width = Some(64);
Ok(Target {
Target {
// LLVM doesn't recognize "muslabi64" yet.
llvm_target: "mips64el-unknown-linux-musl".to_string(),
target_endian: "little".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "mips-unknown-linux-gnu".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -20,5 +20,5 @@ pub fn target() -> TargetResult {
..super::linux_base::opts()
},
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
base.cpu = "mips32r2".to_string();
base.features = "+mips32r2,+soft-float".to_string();
base.max_atomic_width = Some(32);
base.crt_static_default = false;
Ok(Target {
Target {
llvm_target: "mips-unknown-linux-musl".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "mips-unknown-linux-uclibc".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -20,5 +20,5 @@ pub fn target() -> TargetResult {
..super::linux_base::opts()
},
})
}
}

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

@ -1,14 +1,14 @@
use crate::spec::{LinkArgs, LinkerFlavor, LldFlavor, RelocModel};
use crate::spec::{Target, TargetOptions, TargetResult};
use crate::spec::{Target, TargetOptions};
// The PSP has custom linker requirements.
const LINKER_SCRIPT: &str = include_str!("./mipsel_sony_psp_linker_script.ld");
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut pre_link_args = LinkArgs::new();
pre_link_args.insert(LinkerFlavor::Lld(LldFlavor::Ld), vec!["--emit-relocs".to_string()]);
Ok(Target {
Target {
llvm_target: "mipsel-sony-psp".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -36,5 +36,5 @@ pub fn target() -> TargetResult {
link_script: Some(LINKER_SCRIPT.to_string()),
..Default::default()
},
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "mipsel-unknown-linux-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
..super::linux_base::opts()
},
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
base.cpu = "mips32r2".to_string();
base.features = "+mips32r2,+soft-float".to_string();
base.max_atomic_width = Some(32);
base.crt_static_default = false;
Ok(Target {
Target {
llvm_target: "mipsel-unknown-linux-musl".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "mipsel-unknown-linux-uclibc".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
..super::linux_base::opts()
},
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "mipsisa32r6-unknown-linux-gnu".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -20,5 +20,5 @@ pub fn target() -> TargetResult {
..super::linux_base::opts()
},
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "mipsisa32r6el-unknown-linux-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
..super::linux_base::opts()
},
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "mipsisa64r6-unknown-linux-gnuabi64".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "64".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
..super::linux_base::opts()
},
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "mipsisa64r6el-unknown-linux-gnuabi64".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
..super::linux_base::opts()
},
})
}
}

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

@ -436,7 +436,6 @@ pub enum LoadTargetError {
}
pub type LinkArgs = BTreeMap<LinkerFlavor, Vec<String>>;
pub type TargetResult = Result<Target, String>;
macro_rules! supported_targets {
( $(($( $triple:literal, )+ $module:ident ),)+ ) => {
@ -449,8 +448,7 @@ macro_rules! supported_targets {
match target {
$(
$($triple)|+ => {
let mut t = $module::target()
.map_err(LoadTargetError::Other)?;
let mut t = $module::target();
t.options.is_builtin = true;
// round-trip through the JSON parser to ensure at
@ -1135,7 +1133,7 @@ impl Target {
}
/// Loads a target descriptor from a JSON object.
pub fn from_json(obj: Json) -> TargetResult {
pub fn from_json(obj: Json) -> Result<Target, String> {
// While ugly, this code must remain this way to retain
// compatibility with existing JSON fields and the internal
// expected naming of the Target and TargetOptions structs.

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

@ -1,7 +1,7 @@
use crate::spec::{LinkerFlavor, PanicStrategy, RelocModel, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, PanicStrategy, RelocModel, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "msp430-none-elf".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "16".to_string(),
@ -60,5 +60,5 @@ pub fn target() -> TargetResult {
..Default::default()
},
})
}
}

10
compiler/rustc_target/src/spec/nvptx64_nvidia_cuda.rs
View File

@ -1,10 +1,8 @@
use crate::spec::abi::Abi;
use crate::spec::{
LinkerFlavor, MergeFunctions, PanicStrategy, Target, TargetOptions, TargetResult,
};
use crate::spec::{LinkerFlavor, MergeFunctions, PanicStrategy, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
arch: "nvptx64".to_string(),
data_layout: "e-i64:64-i128:128-v16:16-v32:32-n16:32:64".to_string(),
llvm_target: "nvptx64-nvidia-cuda".to_string(),
@ -71,5 +69,5 @@ pub fn target() -> TargetResult {
..Default::default()
},
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::freebsd_base::opts();
base.cpu = "ppc64".to_string();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
base.max_atomic_width = Some(64);
Ok(Target {
Target {
llvm_target: "powerpc64-unknown-freebsd".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "64".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,6 +1,6 @@
use crate::spec::{LinkerFlavor, RelroLevel, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, RelroLevel, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_base::opts();
base.cpu = "ppc64".to_string();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
@ -10,7 +10,7 @@ pub fn target() -> TargetResult {
// for now. https://github.com/rust-lang/rust/pull/43170#issuecomment-315411474
base.relro_level = RelroLevel::Partial;
Ok(Target {
Target {
llvm_target: "powerpc64-unknown-linux-gnu".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "64".to_string(),
@ -22,5 +22,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
base.cpu = "ppc64".to_string();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
base.max_atomic_width = Some(64);
Ok(Target {
Target {
llvm_target: "powerpc64-unknown-linux-musl".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "64".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::vxworks_base::opts();
base.cpu = "ppc64".to_string();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
base.max_atomic_width = Some(64);
Ok(Target {
Target {
llvm_target: "powerpc64-unknown-linux-gnu".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "64".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "wrs".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { ..base },
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_base::opts();
base.cpu = "ppc64le".to_string();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
base.max_atomic_width = Some(64);
Ok(Target {
Target {
llvm_target: "powerpc64le-unknown-linux-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
base.cpu = "ppc64le".to_string();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
base.max_atomic_width = Some(64);
Ok(Target {
Target {
llvm_target: "powerpc64le-unknown-linux-musl".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "64".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_base::opts();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.max_atomic_width = Some(32);
Ok(Target {
Target {
llvm_target: "powerpc-unknown-linux-gnu".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -17,5 +17,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_base::opts();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-mspe".to_string());
base.max_atomic_width = Some(32);
Ok(Target {
Target {
llvm_target: "powerpc-unknown-linux-gnuspe".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -17,5 +17,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::linux_musl_base::opts();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.max_atomic_width = Some(32);
Ok(Target {
Target {
llvm_target: "powerpc-unknown-linux-musl".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -17,5 +17,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "_mcount".to_string(), ..base },
})
}
}

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

@ -1,11 +1,11 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::netbsd_base::opts();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.max_atomic_width = Some(32);
Ok(Target {
Target {
llvm_target: "powerpc-unknown-netbsd".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -17,5 +17,5 @@ pub fn target() -> TargetResult {
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { target_mcount: "__mcount".to_string(), ..base },
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::vxworks_base::opts();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("--secure-plt".to_string());
base.max_atomic_width = Some(32);
Ok(Target {
Target {
llvm_target: "powerpc-unknown-linux-gnu".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -18,5 +18,5 @@ pub fn target() -> TargetResult {
target_vendor: "wrs".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions { features: "+secure-plt".to_string(), ..base },
})
}
}

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

@ -1,12 +1,12 @@
use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
pub fn target() -> Target {
let mut base = super::vxworks_base::opts();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-mspe".to_string());
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("--secure-plt".to_string());
base.max_atomic_width = Some(32);
Ok(Target {
Target {
llvm_target: "powerpc-unknown-linux-gnuspe".to_string(),
target_endian: "big".to_string(),
target_pointer_width: "32".to_string(),
@ -22,5 +22,5 @@ pub fn target() -> TargetResult {
features: "+secure-plt,+msync".to_string(),
..base
},
})
}
}

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

@ -1,7 +1,7 @@
use crate::spec::{CodeModel, LinkerFlavor, Target, TargetOptions, TargetResult};
use crate::spec::{CodeModel, LinkerFlavor, Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
llvm_target: "riscv32-unknown-linux-gnu".to_string(),
target_endian: "little".to_string(),
target_pointer_width: "32".to_string(),
@ -21,5 +21,5 @@ pub fn target() -> TargetResult {
max_atomic_width: Some(32),
..super::linux_base::opts()
},
})
}
}

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

@ -1,8 +1,8 @@
use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel};
use crate::spec::{Target, TargetOptions, TargetResult};
use crate::spec::{Target, TargetOptions};
pub fn target() -> TargetResult {
Ok(Target {
pub fn target() -> Target {
Target {
data_layout: "e-m:e-p:32:32-i64:64-n32-S128".to_string(),
llvm_target: "riscv32".to_string(),
target_endian: "little".to_string(),
@ -28,5 +28,5 @@ pub fn target() -> TargetResult {
eh_frame_header: false,
..Default::default()
},
})
}
}

Some files were not shown because too many files have changed in this diff Show More