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

Rollup merge of #138949 - madsmtm:rename-to-darwin, r=WaffleLapkin

Browse source 
Rename `is_like_osx` to `is_like_darwin`

Replace `is_like_osx` with `is_like_darwin`, which more closely describes reality (OS X is the pre-2016 name for macOS, and is by now quite outdated; Darwin is the overall name for the OS underlying Apple's macOS, iOS, etc.).

``@rustbot`` label O-apple
r? compiler
This commit is contained in:
Matthias Krüger 2025-04-04 08:02:05 +02:00 • committed by GitHub
commit 66e61c78e7
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
24 changed files with 54 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_codegen_cranelift/src/abi/mod.rs
View file

@ -641,7 +641,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
.flat_map(|arg_abi| arg_abi.get_abi_param(fx.tcx).into_iter()),
);
if fx.tcx.sess.target.is_like_osx && fx.tcx.sess.target.arch == "aarch64" {
if fx.tcx.sess.target.is_like_darwin && fx.tcx.sess.target.arch == "aarch64" {
// Add any padding arguments needed for Apple AArch64.
// There's no need to pad the argument list unless variadic arguments are actually being
// passed.

2
compiler/rustc_codegen_cranelift/src/constant.rs
View file

@ -391,7 +391,7 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
data.set_align(alloc.align.bytes());
if let Some(section_name) = section_name {
let (segment_name, section_name) = if tcx.sess.target.is_like_osx {
let (segment_name, section_name) = if tcx.sess.target.is_like_darwin {
// See https://github.com/llvm/llvm-project/blob/main/llvm/lib/MC/MCSectionMachO.cpp
let mut parts = section_name.as_str().split(',');
let Some(segment_name) = parts.next() else {

2
compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs
View file

@ -58,7 +58,7 @@ impl DebugContext {
// FIXME this should be configurable
// macOS doesn't seem to support DWARF > 3
// 5 version is required for md5 file hash
version: if tcx.sess.target.is_like_osx {
version: if tcx.sess.target.is_like_darwin {
3
} else {
// FIXME change to version 5 once the gdb and lldb shipping with the latest debian

2
compiler/rustc_codegen_gcc/src/consts.rs
View file

@ -131,7 +131,7 @@ impl<'gcc, 'tcx> StaticCodegenMethods for CodegenCx<'gcc, 'tcx> {
// will use load-unaligned instructions instead, and thus avoiding the crash.
//
// We could remove this hack whenever we decide to drop macOS 10.10 support.
if self.tcx.sess.target.options.is_like_osx {
if self.tcx.sess.target.options.is_like_darwin {
// The `inspect` method is okay here because we checked for provenance, and
// because we are doing this access to inspect the final interpreter state
// (not as part of the interpreter execution).

6
compiler/rustc_codegen_llvm/src/back/write.rs
View file

@ -1024,7 +1024,7 @@ fn create_section_with_flags_asm(section_name: &str, section_flags: &str, data:
}
pub(crate) fn bitcode_section_name(cgcx: &CodegenContext<LlvmCodegenBackend>) -> &'static CStr {
if cgcx.target_is_like_osx {
if cgcx.target_is_like_darwin {
c"__LLVM,__bitcode"
} else if cgcx.target_is_like_aix {
c".ipa"
@ -1077,7 +1077,7 @@ unsafe fn embed_bitcode(
// and COFF we emit the sections using module level inline assembly for that
// reason (see issue #90326 for historical background).
unsafe {
if cgcx.target_is_like_osx
if cgcx.target_is_like_darwin
|| cgcx.target_is_like_aix
|| cgcx.target_arch == "wasm32"
|| cgcx.target_arch == "wasm64"
@ -1096,7 +1096,7 @@ unsafe fn embed_bitcode(
let llglobal =
llvm::add_global(llmod, common::val_ty(llconst), c"rustc.embedded.cmdline");
llvm::set_initializer(llglobal, llconst);
let section = if cgcx.target_is_like_osx {
let section = if cgcx.target_is_like_darwin {
c"__LLVM,__cmdline"
} else if cgcx.target_is_like_aix {
c".info"

2
compiler/rustc_codegen_llvm/src/mono_item.rs
View file

@ -120,7 +120,7 @@ impl CodegenCx<'_, '_> {
}
// Match clang by only supporting COFF and ELF for now.
if self.tcx.sess.target.is_like_osx {
if self.tcx.sess.target.is_like_darwin {
return false;
}

2
compiler/rustc_codegen_llvm/src/va_arg.rs
View file

@ -399,7 +399,7 @@ pub(super) fn emit_va_arg<'ll, 'tcx>(
emit_ptr_va_arg(bx, addr, target_ty, false, Align::from_bytes(8).unwrap(), false)
}
// macOS / iOS AArch64
"aarch64" if target.is_like_osx => {
"aarch64" if target.is_like_darwin => {
emit_ptr_va_arg(bx, addr, target_ty, false, Align::from_bytes(8).unwrap(), true)
}
"aarch64" => emit_aapcs_va_arg(bx, addr, target_ty),

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

@ -1012,7 +1012,7 @@ fn link_natively(
// On macOS the external `dsymutil` tool is used to create the packed
// debug information. Note that this will read debug information from
// the objects on the filesystem which we'll clean up later.
SplitDebuginfo::Packed if sess.target.is_like_osx => {
SplitDebuginfo::Packed if sess.target.is_like_darwin => {
let prog = Command::new("dsymutil").arg(out_filename).output();
match prog {
Ok(prog) => {
@ -1043,7 +1043,7 @@ fn link_natively(
let strip = sess.opts.cg.strip;
if sess.target.is_like_osx {
if sess.target.is_like_darwin {
let stripcmd = "rust-objcopy";
match (strip, crate_type) {
(Strip::Debuginfo, _) => {
@ -1241,7 +1241,7 @@ fn add_sanitizer_libraries(
// Everywhere else the runtimes are currently distributed as static
// libraries which should be linked to executables only.
if matches!(crate_type, CrateType::Dylib | CrateType::Cdylib | CrateType::ProcMacro)
&& !(sess.target.is_like_osx || sess.target.is_like_msvc)
&& !(sess.target.is_like_darwin || sess.target.is_like_msvc)
{
return;
}
@ -1294,7 +1294,7 @@ fn link_sanitizer_runtime(
let channel =
option_env!("CFG_RELEASE_CHANNEL").map(|channel| format!("-{channel}")).unwrap_or_default();
if sess.target.is_like_osx {
if sess.target.is_like_darwin {
// On Apple platforms, the sanitizer is always built as a dylib, and
// LLVM will link to `@rpath/*.dylib`, so we need to specify an
// rpath to the library as well (the rpath should be absolute, see
@ -2182,7 +2182,7 @@ fn add_rpath_args(
let rpath_config = RPathConfig {
libs: &*libs,
out_filename: out_filename.to_path_buf(),
is_like_osx: sess.target.is_like_osx,
is_like_darwin: sess.target.is_like_darwin,
linker_is_gnu: sess.target.linker_flavor.is_gnu(),
};
cmd.link_args(&rpath::get_rpath_linker_args(&rpath_config));
@ -3044,7 +3044,7 @@ pub(crate) fn are_upstream_rust_objects_already_included(sess: &Session) -> bool
/// - The deployment target.
/// - The SDK version.
fn add_apple_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor) {
if !sess.target.is_like_osx {
if !sess.target.is_like_darwin {
return;
}
let LinkerFlavor::Darwin(cc, _) = flavor else {

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

@ -373,7 +373,7 @@ impl<'a> GccLinker<'a> {
// * On OSX they have their own linker, not binutils'
// * For WebAssembly the only functional linker is LLD, which doesn't
// support hint flags
!self.sess.target.is_like_osx && !self.sess.target.is_like_wasm
!self.sess.target.is_like_darwin && !self.sess.target.is_like_wasm
}
// Some platforms take hints about whether a library is static or dynamic.
@ -425,7 +425,7 @@ impl<'a> GccLinker<'a> {
fn build_dylib(&mut self, crate_type: CrateType, out_filename: &Path) {
// On mac we need to tell the linker to let this library be rpathed
if self.sess.target.is_like_osx {
if self.sess.target.is_like_darwin {
if self.is_cc() {
// `-dynamiclib` makes `cc` pass `-dylib` to the linker.
self.cc_arg("-dynamiclib");
@ -471,7 +471,7 @@ impl<'a> GccLinker<'a> {
fn with_as_needed(&mut self, as_needed: bool, f: impl FnOnce(&mut Self)) {
if !as_needed {
if self.sess.target.is_like_osx {
if self.sess.target.is_like_darwin {
// FIXME(81490): ld64 doesn't support these flags but macOS 11
// has -needed-l{} / -needed_library {}
// but we have no way to detect that here.
@ -486,7 +486,7 @@ impl<'a> GccLinker<'a> {
f(self);
if !as_needed {
if self.sess.target.is_like_osx {
if self.sess.target.is_like_darwin {
// See above FIXME comment
} else if self.is_gnu && !self.sess.target.is_like_windows {
self.link_arg("--as-needed");
@ -619,7 +619,7 @@ impl<'a> Linker for GccLinker<'a> {
let colon = if verbatim && self.is_gnu { ":" } else { "" };
if !whole_archive {
self.link_or_cc_arg(format!("-l{colon}{name}"));
} else if self.sess.target.is_like_osx {
} else if self.sess.target.is_like_darwin {
// -force_load is the macOS equivalent of --whole-archive, but it
// involves passing the full path to the library to link.
self.link_arg("-force_load");
@ -635,7 +635,7 @@ impl<'a> Linker for GccLinker<'a> {
self.hint_static();
if !whole_archive {
self.link_or_cc_arg(path);
} else if self.sess.target.is_like_osx {
} else if self.sess.target.is_like_darwin {
self.link_arg("-force_load").link_arg(path);
} else {
self.link_arg("--whole-archive").link_arg(path).link_arg("--no-whole-archive");
@ -670,7 +670,7 @@ impl<'a> Linker for GccLinker<'a> {
// -dead_strip can't be part of the pre_link_args because it's also used
// for partial linking when using multiple codegen units (-r). So we
// insert it here.
if self.sess.target.is_like_osx {
if self.sess.target.is_like_darwin {
self.link_arg("-dead_strip");
// If we're building a dylib, we don't use --gc-sections because LLVM
@ -728,7 +728,7 @@ impl<'a> Linker for GccLinker<'a> {
fn debuginfo(&mut self, strip: Strip, _: &[PathBuf]) {
// MacOS linker doesn't support stripping symbols directly anymore.
if self.sess.target.is_like_osx {
if self.sess.target.is_like_darwin {
return;
}
@ -795,7 +795,7 @@ impl<'a> Linker for GccLinker<'a> {
debug!("EXPORTED SYMBOLS:");
if self.sess.target.is_like_osx {
if self.sess.target.is_like_darwin {
// Write a plain, newline-separated list of symbols
let res: io::Result<()> = try {
let mut f = File::create_buffered(&path)?;
@ -841,7 +841,7 @@ impl<'a> Linker for GccLinker<'a> {
}
}
if self.sess.target.is_like_osx {
if self.sess.target.is_like_darwin {
self.link_arg("-exported_symbols_list").link_arg(path);
} else if self.sess.target.is_like_solaris {
self.link_arg("-M").link_arg(path);

2
compiler/rustc_codegen_ssa/src/back/metadata.rs
View file

@ -214,7 +214,7 @@ pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static
let mut file = write::Object::new(binary_format, architecture, endianness);
file.set_sub_architecture(sub_architecture);
if sess.target.is_like_osx {
if sess.target.is_like_darwin {
if macho_is_arm64e(&sess.target) {
file.set_macho_cpu_subtype(object::macho::CPU_SUBTYPE_ARM64E);
}

2
compiler/rustc_codegen_ssa/src/back/mod.rs
View file

@ -19,7 +19,7 @@ pub mod write;
///
/// Certain optimizations also depend on the deployment target.
pub fn versioned_llvm_target(sess: &Session) -> Cow<'_, str> {
if sess.target.is_like_osx {
if sess.target.is_like_darwin {
apple::add_version_to_llvm_target(&sess.target.llvm_target, apple::deployment_target(sess))
.into()
} else {

4
compiler/rustc_codegen_ssa/src/back/rpath.rs
View file

@ -9,7 +9,7 @@ use tracing::debug;
pub(super) struct RPathConfig<'a> {
pub libs: &'a [&'a Path],
pub out_filename: PathBuf,
pub is_like_osx: bool,
pub is_like_darwin: bool,
pub linker_is_gnu: bool,
}
@ -63,7 +63,7 @@ fn get_rpaths_relative_to_output(config: &RPathConfig<'_>) -> Vec<OsString> {
fn get_rpath_relative_to_output(config: &RPathConfig<'_>, lib: &Path) -> OsString {
// Mac doesn't appear to support $ORIGIN
let prefix = if config.is_like_osx { "@loader_path" } else { "$ORIGIN" };
let prefix = if config.is_like_darwin { "@loader_path" } else { "$ORIGIN" };
// Strip filenames
let lib = lib.parent().unwrap();

6
compiler/rustc_codegen_ssa/src/back/rpath/tests.rs
View file

@ -28,7 +28,7 @@ fn test_rpath_relative() {
if cfg!(target_os = "macos") {
let config = &mut RPathConfig {
libs: &[],
is_like_osx: true,
is_like_darwin: true,
linker_is_gnu: false,
out_filename: PathBuf::from("bin/rustc"),
};
@ -38,7 +38,7 @@ fn test_rpath_relative() {
let config = &mut RPathConfig {
libs: &[],
out_filename: PathBuf::from("bin/rustc"),
is_like_osx: false,
is_like_darwin: false,
linker_is_gnu: true,
};
let res = get_rpath_relative_to_output(config, Path::new("lib/libstd.so"));
@ -51,7 +51,7 @@ fn test_rpath_relative_issue_119571() {
let config = &mut RPathConfig {
libs: &[],
out_filename: PathBuf::from("rustc"),
is_like_osx: false,
is_like_darwin: false,
linker_is_gnu: true,
};
// Should not panic when out_filename only contains filename.

4
compiler/rustc_codegen_ssa/src/back/write.rs
View file

@ -352,7 +352,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
pub is_pe_coff: bool,
pub target_can_use_split_dwarf: bool,
pub target_arch: String,
pub target_is_like_osx: bool,
pub target_is_like_darwin: bool,
pub target_is_like_aix: bool,
pub split_debuginfo: rustc_target::spec::SplitDebuginfo,
pub split_dwarf_kind: rustc_session::config::SplitDwarfKind,
@ -1216,7 +1216,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
is_pe_coff: tcx.sess.target.is_like_windows,
target_can_use_split_dwarf: tcx.sess.target_can_use_split_dwarf(),
target_arch: tcx.sess.target.arch.to_string(),
target_is_like_osx: tcx.sess.target.is_like_osx,
target_is_like_darwin: tcx.sess.target.is_like_darwin,
target_is_like_aix: tcx.sess.target.is_like_aix,
split_debuginfo: tcx.sess.split_debuginfo(),
split_dwarf_kind: tcx.sess.opts.unstable_opts.split_dwarf_kind,

2
compiler/rustc_codegen_ssa/src/codegen_attrs.rs
View file

@ -213,7 +213,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
// somewhat, and is subject to change in the future (which
// is a good thing, because this would ideally be a bit
// more firmed up).
let is_like_elf = !(tcx.sess.target.is_like_osx
let is_like_elf = !(tcx.sess.target.is_like_darwin
|| tcx.sess.target.is_like_windows
|| tcx.sess.target.is_like_wasm);
codegen_fn_attrs.flags |= if is_like_elf {

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

@ -807,7 +807,7 @@ fn print_crate_info(
}
}
DeploymentTarget => {
if sess.target.is_like_osx {
if sess.target.is_like_darwin {
println_info!(
"{}={}",
apple::deployment_target_env_var(&sess.target.os),

6
compiler/rustc_metadata/src/native_libs.rs
View file

@ -73,7 +73,7 @@ pub fn walk_native_lib_search_dirs<R>(
|| sess.target.os == "linux"
|| sess.target.os == "fuchsia"
|| sess.target.is_like_aix
|| sess.target.is_like_osx && !sess.opts.unstable_opts.sanitizer.is_empty()
|| sess.target.is_like_darwin && !sess.opts.unstable_opts.sanitizer.is_empty()
{
f(&sess.target_tlib_path.dir, false)?;
}
@ -257,7 +257,7 @@ impl<'tcx> Collector<'tcx> {
"static" => NativeLibKind::Static { bundle: None, whole_archive: None },
"dylib" => NativeLibKind::Dylib { as_needed: None },
"framework" => {
if !sess.target.is_like_osx {
if !sess.target.is_like_darwin {
sess.dcx().emit_err(errors::LinkFrameworkApple { span });
}
NativeLibKind::Framework { as_needed: None }
@ -531,7 +531,7 @@ impl<'tcx> Collector<'tcx> {
let mut renames = FxHashSet::default();
for lib in &self.tcx.sess.opts.libs {
if let NativeLibKind::Framework { .. } = lib.kind
&& !self.tcx.sess.target.is_like_osx
&& !self.tcx.sess.target.is_like_darwin
{
// Cannot check this when parsing options because the target is not yet available.
self.tcx.dcx().emit_err(errors::LibFrameworkApple);

2
compiler/rustc_target/src/asm/aarch64.rs
View file

@ -78,7 +78,7 @@ pub(crate) fn target_reserves_x18(target: &Target, target_features: &FxIndexSet<
target.os == "android"
|| target.os == "fuchsia"
|| target.env == "ohos"
|| target.is_like_osx
|| target.is_like_darwin
|| target.is_like_windows
|| target_features.contains(&sym::reserve_x18)
}

2
compiler/rustc_target/src/asm/arm.rs
View file

@ -68,7 +68,7 @@ impl ArmInlineAsmRegClass {
// This uses the same logic as useR7AsFramePointer in LLVM
fn frame_pointer_is_r7(target_features: &FxIndexSet<Symbol>, target: &Target) -> bool {
target.is_like_osx || (!target.is_like_windows && target_features.contains(&sym::thumb_mode))
target.is_like_darwin || (!target.is_like_windows && target_features.contains(&sym::thumb_mode))
}
fn frame_pointer_r11(

2
compiler/rustc_target/src/callconv/mod.rs
View file

@ -670,7 +670,7 @@ impl<'a, Ty> FnAbi<'a, Ty> {
}
},
"aarch64" | "arm64ec" => {
let kind = if cx.target_spec().is_like_osx {
let kind = if cx.target_spec().is_like_darwin {
aarch64::AbiKind::DarwinPCS
} else if cx.target_spec().is_like_windows {
aarch64::AbiKind::Win64

2
compiler/rustc_target/src/callconv/x86.rs
View file

@ -104,7 +104,7 @@ where
let byval_align = if arg.layout.align.abi < align_4 {
// (1.)
align_4
} else if t.is_like_osx && contains_vector(cx, arg.layout) {
} else if t.is_like_darwin && contains_vector(cx, arg.layout) {
// (3.)
align_16
} else {

2
compiler/rustc_target/src/spec/base/apple/mod.rs
View file

@ -115,7 +115,7 @@ pub(crate) fn base(
function_sections: false,
dynamic_linking: true,
families: cvs!["unix"],
is_like_osx: true,
is_like_darwin: true,
binary_format: BinaryFormat::MachO,
// LLVM notes that macOS 10.11+ and iOS 9+ default
// to v4, so we do the same.

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

@ -598,7 +598,7 @@ impl Target {
key!(families, target_families);
key!(abi_return_struct_as_int, bool);
key!(is_like_aix, bool);
key!(is_like_osx, bool);
key!(is_like_darwin, bool);
key!(is_like_solaris, bool);
key!(is_like_windows, bool);
key!(is_like_msvc, bool);
@ -777,7 +777,7 @@ impl ToJson for Target {
target_option_val!(families, "target-family");
target_option_val!(abi_return_struct_as_int);
target_option_val!(is_like_aix);
target_option_val!(is_like_osx);
target_option_val!(is_like_darwin);
target_option_val!(is_like_solaris);
target_option_val!(is_like_windows);
target_option_val!(is_like_msvc);

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

@ -81,7 +81,7 @@ pub enum Lld {
/// of classes that we call "linker flavors".
///
/// Technically, it's not even necessary, we can nearly always infer the flavor from linker name
/// and target properties like `is_like_windows`/`is_like_osx`/etc. However, the PRs originally
/// and target properties like `is_like_windows`/`is_like_darwin`/etc. However, the PRs originally
/// introducing `-Clinker-flavor` (#40018 and friends) were aiming to reduce this kind of inference
/// and provide something certain and explicitly specified instead, and that design goal is still
/// relevant now.
@ -2406,7 +2406,7 @@ pub struct TargetOptions {
/// in particular running dsymutil and some other stuff like `-dead_strip`. Defaults to false.
/// Also indicates whether to use Apple-specific ABI changes, such as extending function
/// parameters to 32-bits.
pub is_like_osx: bool,
pub is_like_darwin: bool,
/// Whether the target toolchain is like Solaris's.
/// Only useful for compiling against Illumos/Solaris,
/// as they have a different set of linker flags. Defaults to false.
@ -2700,7 +2700,7 @@ fn add_link_args(link_args: &mut LinkArgs, flavor: LinkerFlavor, args: &[&'stati
impl TargetOptions {
pub fn supports_comdat(&self) -> bool {
// XCOFF and MachO don't support COMDAT.
!self.is_like_aix && !self.is_like_osx
!self.is_like_aix && !self.is_like_darwin
}
}
@ -2804,7 +2804,7 @@ impl Default for TargetOptions {
families: cvs![],
abi_return_struct_as_int: false,
is_like_aix: false,
is_like_osx: false,
is_like_darwin: false,
is_like_solaris: false,
is_like_windows: false,
is_like_msvc: false,
@ -3070,9 +3070,9 @@ impl Target {
}
check_eq!(
self.is_like_osx,
self.is_like_darwin,
self.vendor == "apple",
"`is_like_osx` must be set if and only if `vendor` is `apple`"
"`is_like_darwin` must be set if and only if `vendor` is `apple`"
);
check_eq!(
self.is_like_solaris,
@ -3098,9 +3098,9 @@ impl Target {
// Check that default linker flavor is compatible with some other key properties.
check_eq!(
self.is_like_osx,
self.is_like_darwin,
matches!(self.linker_flavor, LinkerFlavor::Darwin(..)),
"`linker_flavor` must be `darwin` if and only if `is_like_osx` is set"
"`linker_flavor` must be `darwin` if and only if `is_like_darwin` is set"
);
check_eq!(
self.is_like_msvc,