From bacd57a583338b5667046abe474e728a5e881cd0 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 16 Mar 2025 14:45:08 +0100
Subject: [PATCH 01/33] Add integer to string formatting tests
---
library/alloctests/tests/lib.rs | 1 +
library/alloctests/tests/num.rs | 69 +++++++++++++++++++++++++++++++++
2 files changed, 70 insertions(+)
create mode 100644 library/alloctests/tests/num.rs
diff --git a/library/alloctests/tests/lib.rs b/library/alloctests/tests/lib.rs
index 46c11ea150bf8..f1f4cc6f93bbd 100644
--- a/library/alloctests/tests/lib.rs
+++ b/library/alloctests/tests/lib.rs
@@ -63,6 +63,7 @@ mod fmt;
mod heap;
mod linked_list;
mod misc_tests;
+mod num;
mod rc;
mod slice;
mod sort;
diff --git a/library/alloctests/tests/num.rs b/library/alloctests/tests/num.rs
new file mode 100644
index 0000000000000..c9c0cd09ff6ab
--- /dev/null
+++ b/library/alloctests/tests/num.rs
@@ -0,0 +1,69 @@
+use std::fmt::{Debug, Display};
+use std::str::FromStr;
+
+fn assert_nb<Int: ToString + FromStr + Debug + Display + Eq>(value: Int) {
+ let s = value.to_string();
+ let s2 = format!("{}", value);
+
+ assert_eq!(s, s2);
+ let Ok(ret) = Int::from_str(&s) else {
+ panic!("failed to convert into to string");
+ };
+ assert_eq!(ret, value);
+}
+
+macro_rules! uint_to_s {
+ ($($fn_name:ident, $int:ident,)+) => {
+ $(
+ #[test]
+ fn $fn_name() {
+ assert_nb::<$int>($int::MIN);
+ assert_nb::<$int>($int::MAX);
+ assert_nb::<$int>(1);
+ assert_nb::<$int>($int::MIN / 2);
+ assert_nb::<$int>($int::MAX / 2);
+ }
+ )+
+ }
+}
+macro_rules! int_to_s {
+ ($($fn_name:ident, $int:ident,)+) => {
+ $(
+ #[test]
+ fn $fn_name() {
+ assert_nb::<$int>($int::MIN);
+ assert_nb::<$int>($int::MAX);
+ assert_nb::<$int>(1);
+ assert_nb::<$int>(0);
+ assert_nb::<$int>(-1);
+ assert_nb::<$int>($int::MIN / 2);
+ assert_nb::<$int>($int::MAX / 2);
+ }
+ )+
+ }
+}
+
+int_to_s!(
+ test_i8_to_string,
+ i8,
+ test_i16_to_string,
+ i16,
+ test_i32_to_string,
+ i32,
+ test_i64_to_string,
+ i64,
+ test_i128_to_string,
+ i128,
+);
+uint_to_s!(
+ test_u8_to_string,
+ u8,
+ test_u16_to_string,
+ u16,
+ test_u32_to_string,
+ u32,
+ test_u64_to_string,
+ u64,
+ test_u128_to_string,
+ u128,
+);
From 25900c2768b0b3e3d55a531c9aeb27edaccb92d1 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 23 Mar 2025 22:21:41 +0100
Subject: [PATCH 02/33] Tweak integer to string conversion test a bit to be
future-proof
---
library/alloctests/tests/num.rs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/library/alloctests/tests/num.rs b/library/alloctests/tests/num.rs
index c9c0cd09ff6ab..3c76e68c60640 100644
--- a/library/alloctests/tests/num.rs
+++ b/library/alloctests/tests/num.rs
@@ -3,9 +3,9 @@ use std::str::FromStr;
fn assert_nb<Int: ToString + FromStr + Debug + Display + Eq>(value: Int) {
let s = value.to_string();
- let s2 = format!("{}", value);
+ let s2 = format!("s: {}.", value);
- assert_eq!(s, s2);
+ assert_eq!(format!("s: {s}."), s2);
let Ok(ret) = Int::from_str(&s) else {
panic!("failed to convert into to string");
};
From ec63690c2ff20ca81a736a5a7e031b3d79530695 Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Tue, 11 Feb 2025 10:43:25 +0100
Subject: [PATCH 03/33] refactor: Move Apple OSVersion (back) to rustc_target
Also convert OSVersion into a proper struct for better type-safety.
---
compiler/rustc_codegen_ssa/src/back/apple.rs | 91 ++---------------
.../rustc_codegen_ssa/src/back/apple/tests.rs | 12 +--
compiler/rustc_codegen_ssa/src/back/link.rs | 7 +-
.../rustc_codegen_ssa/src/back/metadata.rs | 2 +-
compiler/rustc_codegen_ssa/src/lib.rs | 1 -
compiler/rustc_driver_impl/src/lib.rs | 2 +-
compiler/rustc_target/src/lib.rs | 1 +
.../rustc_target/src/spec/base/apple/mod.rs | 97 ++++++++++++++++++-
.../rustc_target/src/spec/base/apple/tests.rs | 9 ++
compiler/rustc_target/src/spec/base/mod.rs | 2 +-
compiler/rustc_target/src/spec/mod.rs | 1 +
11 files changed, 125 insertions(+), 100 deletions(-)
diff --git a/compiler/rustc_codegen_ssa/src/back/apple.rs b/compiler/rustc_codegen_ssa/src/back/apple.rs
index 2c8b0ec418dd8..8954ec0fcdd2f 100644
--- a/compiler/rustc_codegen_ssa/src/back/apple.rs
+++ b/compiler/rustc_codegen_ssa/src/back/apple.rs
@@ -1,7 +1,6 @@
use std::env;
use std::ffi::OsString;
-use std::fmt::{Display, from_fn};
-use std::num::ParseIntError;
+use std::str::FromStr;
use std::path::PathBuf;
use std::process::Command;
@@ -9,6 +8,7 @@ use itertools::Itertools;
use rustc_middle::middle::exported_symbols::SymbolExportKind;
use rustc_session::Session;
use rustc_target::spec::Target;
+pub(super) use rustc_target::spec::apple::OSVersion;
use tracing::debug;
use crate::errors::{AppleDeploymentTarget, XcrunError, XcrunSdkPathWarning};
@@ -134,76 +134,6 @@ pub(super) fn add_data_and_relocation(
Ok(())
}
-/// Deployment target or SDK version.
-///
-/// The size of the numbers in here are limited by Mach-O's `LC_BUILD_VERSION`.
-type OSVersion = (u16, u8, u8);
-
-/// Parse an OS version triple (SDK version or deployment target).
-fn parse_version(version: &str) -> Result<OSVersion, ParseIntError> {
- if let Some((major, minor)) = version.split_once('.') {
- let major = major.parse()?;
- if let Some((minor, patch)) = minor.split_once('.') {
- Ok((major, minor.parse()?, patch.parse()?))
- } else {
- Ok((major, minor.parse()?, 0))
- }
- } else {
- Ok((version.parse()?, 0, 0))
- }
-}
-
-pub fn pretty_version(version: OSVersion) -> impl Display {
- let (major, minor, patch) = version;
- from_fn(move |f| {
- write!(f, "{major}.{minor}")?;
- if patch != 0 {
- write!(f, ".{patch}")?;
- }
- Ok(())
- })
-}
-
-/// Minimum operating system versions currently supported by `rustc`.
-fn os_minimum_deployment_target(os: &str) -> OSVersion {
- // When bumping a version in here, remember to update the platform-support docs too.
- //
- // NOTE: The defaults may change in future `rustc` versions, so if you are looking for the
- // default deployment target, prefer:
- // ```
- // $ rustc --print deployment-target
- // ```
- match os {
- "macos" => (10, 12, 0),
- "ios" => (10, 0, 0),
- "tvos" => (10, 0, 0),
- "watchos" => (5, 0, 0),
- "visionos" => (1, 0, 0),
- _ => unreachable!("tried to get deployment target for non-Apple platform"),
- }
-}
-
-/// The deployment target for the given target.
-///
-/// This is similar to `os_minimum_deployment_target`, except that on certain targets it makes sense
-/// to raise the minimum OS version.
-///
-/// This matches what LLVM does, see in part:
-/// <https://github.com/llvm/llvm-project/blob/llvmorg-18.1.8/llvm/lib/TargetParser/Triple.cpp#L1900-L1932>
-fn minimum_deployment_target(target: &Target) -> OSVersion {
- match (&*target.os, &*target.arch, &*target.abi) {
- ("macos", "aarch64", _) => (11, 0, 0),
- ("ios", "aarch64", "macabi") => (14, 0, 0),
- ("ios", "aarch64", "sim") => (14, 0, 0),
- ("ios", _, _) if target.llvm_target.starts_with("arm64e") => (14, 0, 0),
- // Mac Catalyst defaults to 13.1 in Clang.
- ("ios", _, "macabi") => (13, 1, 0),
- ("tvos", "aarch64", "sim") => (14, 0, 0),
- ("watchos", "aarch64", "sim") => (7, 0, 0),
- (os, _, _) => os_minimum_deployment_target(os),
- }
-}
-
/// Name of the environment variable used to fetch the deployment target on the given OS.
pub fn deployment_target_env_var(os: &str) -> &'static str {
match os {
@@ -219,13 +149,13 @@ pub fn deployment_target_env_var(os: &str) -> &'static str {
/// Get the deployment target based on the standard environment variables, or fall back to the
/// minimum version supported by `rustc`.
pub fn deployment_target(sess: &Session) -> OSVersion {
- let min = minimum_deployment_target(&sess.target);
+ let min = OSVersion::minimum_deployment_target(&sess.target);
let env_var = deployment_target_env_var(&sess.target.os);
if let Ok(deployment_target) = env::var(env_var) {
- match parse_version(&deployment_target) {
+ match OSVersion::from_str(&deployment_target) {
Ok(version) => {
- let os_min = os_minimum_deployment_target(&sess.target.os);
+ let os_min = OSVersion::os_minimum_deployment_target(&sess.target.os);
// It is common that the deployment target is set a bit too low, for example on
// macOS Aarch64 to also target older x86_64. So we only want to warn when variable
// is lower than the minimum OS supported by rustc, not when the variable is lower
@@ -233,8 +163,8 @@ pub fn deployment_target(sess: &Session) -> OSVersion {
if version < os_min {
sess.dcx().emit_warn(AppleDeploymentTarget::TooLow {
env_var,
- version: pretty_version(version).to_string(),
- os_min: pretty_version(os_min).to_string(),
+ version: version.fmt_pretty().to_string(),
+ os_min: os_min.fmt_pretty().to_string(),
});
}
@@ -263,18 +193,17 @@ pub(super) fn add_version_to_llvm_target(
let environment = components.next();
assert_eq!(components.next(), None, "too many LLVM triple components");
- let (major, minor, patch) = deployment_target;
-
assert!(
!os.contains(|c: char| c.is_ascii_digit()),
"LLVM target must not already be versioned"
);
+ let version = deployment_target.fmt_full();
if let Some(env) = environment {
// Insert version into OS, before environment
- format!("{arch}-{vendor}-{os}{major}.{minor}.{patch}-{env}")
+ format!("{arch}-{vendor}-{os}{version}-{env}")
} else {
- format!("{arch}-{vendor}-{os}{major}.{minor}.{patch}")
+ format!("{arch}-{vendor}-{os}{version}")
}
}
diff --git a/compiler/rustc_codegen_ssa/src/back/apple/tests.rs b/compiler/rustc_codegen_ssa/src/back/apple/tests.rs
index 8df740a4bcf7d..5afe79b71954a 100644
--- a/compiler/rustc_codegen_ssa/src/back/apple/tests.rs
+++ b/compiler/rustc_codegen_ssa/src/back/apple/tests.rs
@@ -3,23 +3,15 @@ use super::*;
#[test]
fn test_add_version_to_llvm_target() {
assert_eq!(
- add_version_to_llvm_target("aarch64-apple-macosx", (10, 14, 1)),
+ add_version_to_llvm_target("aarch64-apple-macosx", OSVersion::new(10, 14, 1)),
"aarch64-apple-macosx10.14.1"
);
assert_eq!(
- add_version_to_llvm_target("aarch64-apple-ios-simulator", (16, 1, 0)),
+ add_version_to_llvm_target("aarch64-apple-ios-simulator", OSVersion::new(16, 1, 0)),
"aarch64-apple-ios16.1.0-simulator"
);
}
-#[test]
-fn test_parse_version() {
- assert_eq!(parse_version("10"), Ok((10, 0, 0)));
- assert_eq!(parse_version("10.12"), Ok((10, 12, 0)));
- assert_eq!(parse_version("10.12.6"), Ok((10, 12, 6)));
- assert_eq!(parse_version("9999.99.99"), Ok((9999, 99, 99)));
-}
-
#[test]
#[cfg_attr(not(target_os = "macos"), ignore = "xcode-select is only available on macOS")]
fn lookup_developer_dir() {
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index b59d73a9aae09..3dd99592ee54c 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -3115,8 +3115,7 @@ fn add_apple_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavo
_ => bug!("invalid OS/ABI combination for Apple target: {target_os}, {target_abi}"),
};
- let (major, minor, patch) = apple::deployment_target(sess);
- let min_version = format!("{major}.{minor}.{patch}");
+ let min_version = apple::deployment_target(sess).fmt_full().to_string();
// The SDK version is used at runtime when compiling with a newer SDK / version of Xcode:
// - By dyld to give extra warnings and errors, see e.g.:
@@ -3185,10 +3184,10 @@ fn add_apple_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavo
// The presence of `-mmacosx-version-min` makes CC default to
// macOS, and it sets the deployment target.
- let (major, minor, patch) = apple::deployment_target(sess);
+ let version = apple::deployment_target(sess).fmt_full();
// Intentionally pass this as a single argument, Clang doesn't
// seem to like it otherwise.
- cmd.cc_arg(&format!("-mmacosx-version-min={major}.{minor}.{patch}"));
+ cmd.cc_arg(&format!("-mmacosx-version-min={version}"));
// macOS has no environment, so with these two, we've told CC the
// four desired parameters.
diff --git a/compiler/rustc_codegen_ssa/src/back/metadata.rs b/compiler/rustc_codegen_ssa/src/back/metadata.rs
index 68b453ff42425..a60fcc9f27676 100644
--- a/compiler/rustc_codegen_ssa/src/back/metadata.rs
+++ b/compiler/rustc_codegen_ssa/src/back/metadata.rs
@@ -388,7 +388,7 @@ pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {
fn macho_object_build_version_for_target(sess: &Session) -> object::write::MachOBuildVersion {
/// The `object` crate demands "X.Y.Z encoded in nibbles as xxxx.yy.zz"
/// e.g. minOS 14.0 = 0x000E0000, or SDK 16.2 = 0x00100200
- fn pack_version((major, minor, patch): (u16, u8, u8)) -> u32 {
+ fn pack_version(apple::OSVersion { major, minor, patch }: apple::OSVersion) -> u32 {
let (major, minor, patch) = (major as u32, minor as u32, patch as u32);
(major << 16) | (minor << 8) | patch
}
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index d26d6edf3149d..ec1d2926519e3 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -7,7 +7,6 @@
#![doc(rust_logo)]
#![feature(assert_matches)]
#![feature(box_patterns)]
-#![feature(debug_closure_helpers)]
#![feature(file_buffered)]
#![feature(if_let_guard)]
#![feature(let_chains)]
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 37755e7d61db1..ecf10764cc48d 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -783,7 +783,7 @@ fn print_crate_info(
println_info!(
"{}={}",
apple::deployment_target_env_var(&sess.target.os),
- apple::pretty_version(apple::deployment_target(sess)),
+ apple::deployment_target(sess).fmt_pretty(),
)
} else {
#[allow(rustc::diagnostic_outside_of_impl)]
diff --git a/compiler/rustc_target/src/lib.rs b/compiler/rustc_target/src/lib.rs
index a8d7da5692de4..df99280f5712e 100644
--- a/compiler/rustc_target/src/lib.rs
+++ b/compiler/rustc_target/src/lib.rs
@@ -12,6 +12,7 @@
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![doc(rust_logo)]
#![feature(assert_matches)]
+#![feature(debug_closure_helpers)]
#![feature(iter_intersperse)]
#![feature(let_chains)]
#![feature(rustc_attrs)]
diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs
index 66c85146c2944..613ea33ed1329 100644
--- a/compiler/rustc_target/src/spec/base/apple/mod.rs
+++ b/compiler/rustc_target/src/spec/base/apple/mod.rs
@@ -1,9 +1,12 @@
use std::borrow::Cow;
use std::env;
+use std::fmt::{Display, from_fn};
+use std::num::ParseIntError;
+use std::str::FromStr;
use crate::spec::{
BinaryFormat, Cc, DebuginfoKind, FloatAbi, FramePointer, LinkerFlavor, Lld, RustcAbi,
- SplitDebuginfo, StackProbeType, StaticCow, TargetOptions, cvs,
+ SplitDebuginfo, StackProbeType, StaticCow, Target, TargetOptions, cvs,
};
#[cfg(test)]
@@ -222,3 +225,95 @@ fn link_env_remove(os: &'static str) -> StaticCow<[StaticCow<str>]> {
cvs!["MACOSX_DEPLOYMENT_TARGET"]
}
}
+
+/// Deployment target or SDK version.
+///
+/// The size of the numbers in here are limited by Mach-O's `LC_BUILD_VERSION`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct OSVersion {
+ pub major: u16,
+ pub minor: u8,
+ pub patch: u8,
+}
+
+impl FromStr for OSVersion {
+ type Err = ParseIntError;
+
+ /// Parse an OS version triple (SDK version or deployment target).
+ fn from_str(version: &str) -> Result<Self, ParseIntError> {
+ if let Some((major, minor)) = version.split_once('.') {
+ let major = major.parse()?;
+ if let Some((minor, patch)) = minor.split_once('.') {
+ Ok(Self { major, minor: minor.parse()?, patch: patch.parse()? })
+ } else {
+ Ok(Self { major, minor: minor.parse()?, patch: 0 })
+ }
+ } else {
+ Ok(Self { major: version.parse()?, minor: 0, patch: 0 })
+ }
+ }
+}
+
+impl OSVersion {
+ pub fn new(major: u16, minor: u8, patch: u8) -> Self {
+ Self { major, minor, patch }
+ }
+
+ pub fn fmt_pretty(self) -> impl Display {
+ let Self { major, minor, patch } = self;
+ from_fn(move |f| {
+ write!(f, "{major}.{minor}")?;
+ if patch != 0 {
+ write!(f, ".{patch}")?;
+ }
+ Ok(())
+ })
+ }
+
+ pub fn fmt_full(self) -> impl Display {
+ let Self { major, minor, patch } = self;
+ from_fn(move |f| write!(f, "{major}.{minor}.{patch}"))
+ }
+
+ /// Minimum operating system versions currently supported by `rustc`.
+ pub fn os_minimum_deployment_target(os: &str) -> Self {
+ // When bumping a version in here, remember to update the platform-support docs too.
+ //
+ // NOTE: The defaults may change in future `rustc` versions, so if you are looking for the
+ // default deployment target, prefer:
+ // ```
+ // $ rustc --print deployment-target
+ // ```
+ let (major, minor, patch) = match os {
+ "macos" => (10, 12, 0),
+ "ios" => (10, 0, 0),
+ "tvos" => (10, 0, 0),
+ "watchos" => (5, 0, 0),
+ "visionos" => (1, 0, 0),
+ _ => unreachable!("tried to get deployment target for non-Apple platform"),
+ };
+ Self { major, minor, patch }
+ }
+
+ /// The deployment target for the given target.
+ ///
+ /// This is similar to `os_minimum_deployment_target`, except that on certain targets it makes sense
+ /// to raise the minimum OS version.
+ ///
+ /// This matches what LLVM does, see in part:
+ /// <https://github.com/llvm/llvm-project/blob/llvmorg-18.1.8/llvm/lib/TargetParser/Triple.cpp#L1900-L1932>
+ pub fn minimum_deployment_target(target: &Target) -> Self {
+ let (major, minor, patch) = match (&*target.os, &*target.arch, &*target.abi) {
+ ("macos", "aarch64", _) => (11, 0, 0),
+ ("ios", "aarch64", "macabi") => (14, 0, 0),
+ ("ios", "aarch64", "sim") => (14, 0, 0),
+ ("ios", _, _) if target.llvm_target.starts_with("arm64e") => (14, 0, 0),
+ // Mac Catalyst defaults to 13.1 in Clang.
+ ("ios", _, "macabi") => (13, 1, 0),
+ ("tvos", "aarch64", "sim") => (14, 0, 0),
+ ("watchos", "aarch64", "sim") => (7, 0, 0),
+ (os, _, _) => return Self::os_minimum_deployment_target(os),
+ };
+ Self { major, minor, patch }
+ }
+}
diff --git a/compiler/rustc_target/src/spec/base/apple/tests.rs b/compiler/rustc_target/src/spec/base/apple/tests.rs
index 7a985ad4dc056..391f347010436 100644
--- a/compiler/rustc_target/src/spec/base/apple/tests.rs
+++ b/compiler/rustc_target/src/spec/base/apple/tests.rs
@@ -1,3 +1,4 @@
+use super::OSVersion;
use crate::spec::targets::{
aarch64_apple_darwin, aarch64_apple_ios_sim, aarch64_apple_visionos_sim,
aarch64_apple_watchos_sim, i686_apple_darwin, x86_64_apple_darwin, x86_64_apple_ios,
@@ -42,3 +43,11 @@ fn macos_link_environment_unmodified() {
);
}
}
+
+#[test]
+fn test_parse_version() {
+ assert_eq!("10".parse(), Ok(OSVersion::new(10, 0, 0)));
+ assert_eq!("10.12".parse(), Ok(OSVersion::new(10, 12, 0)));
+ assert_eq!("10.12.6".parse(), Ok(OSVersion::new(10, 12, 6)));
+ assert_eq!("9999.99.99".parse(), Ok(OSVersion::new(9999, 99, 99)));
+}
diff --git a/compiler/rustc_target/src/spec/base/mod.rs b/compiler/rustc_target/src/spec/base/mod.rs
index e8fdc87178539..71b6528c2dd11 100644
--- a/compiler/rustc_target/src/spec/base/mod.rs
+++ b/compiler/rustc_target/src/spec/base/mod.rs
@@ -1,6 +1,6 @@
pub(crate) mod aix;
pub(crate) mod android;
-pub(crate) mod apple;
+pub mod apple;
pub(crate) mod avr;
pub(crate) mod bpf;
pub(crate) mod cygwin;
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 7234d1dc63ee1..bd1830ce27117 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -60,6 +60,7 @@ pub mod crt_objects;
mod base;
mod json;
+pub use base::apple;
pub use base::avr::ef_avr_arch;
/// Linker is called through a C/C++ compiler.
From 72b5ef0cf90408ec078571d4482fbae0af0c901d Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Tue, 11 Feb 2025 11:02:36 +0100
Subject: [PATCH 04/33] refactor: Move env parsing of deployment target to
rustc_session
---
compiler/rustc_codegen_ssa/messages.ftl | 6 ---
compiler/rustc_codegen_ssa/src/back/apple.rs | 52 +------------------
compiler/rustc_codegen_ssa/src/back/link.rs | 4 +-
.../rustc_codegen_ssa/src/back/metadata.rs | 2 +-
compiler/rustc_codegen_ssa/src/back/mod.rs | 2 +-
compiler/rustc_codegen_ssa/src/errors.rs | 9 ----
compiler/rustc_driver_impl/src/lib.rs | 5 +-
compiler/rustc_session/messages.ftl | 6 +++
compiler/rustc_session/src/errors.rs | 10 +++-
compiler/rustc_session/src/session.rs | 41 ++++++++++++++-
.../rustc_target/src/spec/base/apple/mod.rs | 12 +++++
11 files changed, 74 insertions(+), 75 deletions(-)
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 954a601480935..1dabf01ffd654 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -4,12 +4,6 @@ codegen_ssa_add_native_library = failed to add native library {$library_path}: {
codegen_ssa_aix_strip_not_used = using host's `strip` binary to cross-compile to AIX which is not guaranteed to work
-codegen_ssa_apple_deployment_target_invalid =
- failed to parse deployment target specified in {$env_var}: {$error}
-
-codegen_ssa_apple_deployment_target_too_low =
- deployment target in {$env_var} was set to {$version}, but the minimum supported by `rustc` is {$os_min}
-
codegen_ssa_archive_build_failure = failed to build archive at `{$path}`: {$error}
codegen_ssa_atomic_compare_exchange = Atomic compare-exchange intrinsic missing failure memory ordering
diff --git a/compiler/rustc_codegen_ssa/src/back/apple.rs b/compiler/rustc_codegen_ssa/src/back/apple.rs
index 8954ec0fcdd2f..d242efaf4fd42 100644
--- a/compiler/rustc_codegen_ssa/src/back/apple.rs
+++ b/compiler/rustc_codegen_ssa/src/back/apple.rs
@@ -1,6 +1,4 @@
-use std::env;
use std::ffi::OsString;
-use std::str::FromStr;
use std::path::PathBuf;
use std::process::Command;
@@ -11,7 +9,7 @@ use rustc_target::spec::Target;
pub(super) use rustc_target::spec::apple::OSVersion;
use tracing::debug;
-use crate::errors::{AppleDeploymentTarget, XcrunError, XcrunSdkPathWarning};
+use crate::errors::{XcrunError, XcrunSdkPathWarning};
use crate::fluent_generated as fluent;
#[cfg(test)]
@@ -134,54 +132,6 @@ pub(super) fn add_data_and_relocation(
Ok(())
}
-/// Name of the environment variable used to fetch the deployment target on the given OS.
-pub fn deployment_target_env_var(os: &str) -> &'static str {
- match os {
- "macos" => "MACOSX_DEPLOYMENT_TARGET",
- "ios" => "IPHONEOS_DEPLOYMENT_TARGET",
- "watchos" => "WATCHOS_DEPLOYMENT_TARGET",
- "tvos" => "TVOS_DEPLOYMENT_TARGET",
- "visionos" => "XROS_DEPLOYMENT_TARGET",
- _ => unreachable!("tried to get deployment target env var for non-Apple platform"),
- }
-}
-
-/// Get the deployment target based on the standard environment variables, or fall back to the
-/// minimum version supported by `rustc`.
-pub fn deployment_target(sess: &Session) -> OSVersion {
- let min = OSVersion::minimum_deployment_target(&sess.target);
- let env_var = deployment_target_env_var(&sess.target.os);
-
- if let Ok(deployment_target) = env::var(env_var) {
- match OSVersion::from_str(&deployment_target) {
- Ok(version) => {
- let os_min = OSVersion::os_minimum_deployment_target(&sess.target.os);
- // It is common that the deployment target is set a bit too low, for example on
- // macOS Aarch64 to also target older x86_64. So we only want to warn when variable
- // is lower than the minimum OS supported by rustc, not when the variable is lower
- // than the minimum for a specific target.
- if version < os_min {
- sess.dcx().emit_warn(AppleDeploymentTarget::TooLow {
- env_var,
- version: version.fmt_pretty().to_string(),
- os_min: os_min.fmt_pretty().to_string(),
- });
- }
-
- // Raise the deployment target to the minimum supported.
- version.max(min)
- }
- Err(error) => {
- sess.dcx().emit_err(AppleDeploymentTarget::Invalid { env_var, error });
- min
- }
- }
- } else {
- // If no deployment target variable is set, default to the minimum found above.
- min
- }
-}
-
pub(super) fn add_version_to_llvm_target(
llvm_target: &str,
deployment_target: OSVersion,
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 3dd99592ee54c..b3cb6e595ffad 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -3115,7 +3115,7 @@ fn add_apple_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavo
_ => bug!("invalid OS/ABI combination for Apple target: {target_os}, {target_abi}"),
};
- let min_version = apple::deployment_target(sess).fmt_full().to_string();
+ let min_version = sess.apple_deployment_target().fmt_full().to_string();
// The SDK version is used at runtime when compiling with a newer SDK / version of Xcode:
// - By dyld to give extra warnings and errors, see e.g.:
@@ -3184,7 +3184,7 @@ fn add_apple_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavo
// The presence of `-mmacosx-version-min` makes CC default to
// macOS, and it sets the deployment target.
- let version = apple::deployment_target(sess).fmt_full();
+ let version = sess.apple_deployment_target().fmt_full();
// Intentionally pass this as a single argument, Clang doesn't
// seem to like it otherwise.
cmd.cc_arg(&format!("-mmacosx-version-min={version}"));
diff --git a/compiler/rustc_codegen_ssa/src/back/metadata.rs b/compiler/rustc_codegen_ssa/src/back/metadata.rs
index a60fcc9f27676..0f1c5cdfd82e7 100644
--- a/compiler/rustc_codegen_ssa/src/back/metadata.rs
+++ b/compiler/rustc_codegen_ssa/src/back/metadata.rs
@@ -394,7 +394,7 @@ fn macho_object_build_version_for_target(sess: &Session) -> object::write::MachO
}
let platform = apple::macho_platform(&sess.target);
- let min_os = apple::deployment_target(sess);
+ let min_os = sess.apple_deployment_target();
let mut build_version = object::write::MachOBuildVersion::default();
build_version.platform = platform;
diff --git a/compiler/rustc_codegen_ssa/src/back/mod.rs b/compiler/rustc_codegen_ssa/src/back/mod.rs
index 64b5d4569ecce..76971096a5820 100644
--- a/compiler/rustc_codegen_ssa/src/back/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/back/mod.rs
@@ -20,7 +20,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 {
- apple::add_version_to_llvm_target(&sess.target.llvm_target, apple::deployment_target(sess))
+ apple::add_version_to_llvm_target(&sess.target.llvm_target, sess.apple_deployment_target())
.into()
} else {
// FIXME(madsmtm): Certain other targets also include a version,
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index f52d29baf9dc0..b33de8802d83a 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -3,7 +3,6 @@
use std::borrow::Cow;
use std::ffi::OsString;
use std::io::Error;
-use std::num::ParseIntError;
use std::path::{Path, PathBuf};
use std::process::ExitStatus;
@@ -738,14 +737,6 @@ pub enum ExtractBundledLibsError<'a> {
ExtractSection { rlib: &'a Path, error: Box<dyn std::error::Error> },
}
-#[derive(Diagnostic)]
-pub(crate) enum AppleDeploymentTarget {
- #[diag(codegen_ssa_apple_deployment_target_invalid)]
- Invalid { env_var: &'static str, error: ParseIntError },
- #[diag(codegen_ssa_apple_deployment_target_too_low)]
- TooLow { env_var: &'static str, version: String, os_min: String },
-}
-
#[derive(Diagnostic)]
#[diag(codegen_ssa_read_file)]
pub(crate) struct ReadFileError {
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index ecf10764cc48d..19c0dbf9ab779 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -34,7 +34,6 @@ use std::time::{Instant, SystemTime};
use std::{env, str};
use rustc_ast as ast;
-use rustc_codegen_ssa::back::apple;
use rustc_codegen_ssa::traits::CodegenBackend;
use rustc_codegen_ssa::{CodegenErrors, CodegenResults};
use rustc_data_structures::profiling::{
@@ -782,8 +781,8 @@ fn print_crate_info(
if sess.target.is_like_osx {
println_info!(
"{}={}",
- apple::deployment_target_env_var(&sess.target.os),
- apple::deployment_target(sess).fmt_pretty(),
+ rustc_target::spec::apple::deployment_target_env_var(&sess.target.os),
+ sess.apple_deployment_target().fmt_pretty(),
)
} else {
#[allow(rustc::diagnostic_outside_of_impl)]
diff --git a/compiler/rustc_session/messages.ftl b/compiler/rustc_session/messages.ftl
index 74b8087e07769..2f1a918d3a67d 100644
--- a/compiler/rustc_session/messages.ftl
+++ b/compiler/rustc_session/messages.ftl
@@ -1,3 +1,9 @@
+session_apple_deployment_target_invalid =
+ failed to parse deployment target specified in {$env_var}: {$error}
+
+session_apple_deployment_target_too_low =
+ deployment target in {$env_var} was set to {$version}, but the minimum supported by `rustc` is {$os_min}
+
session_binary_float_literal_not_supported = binary float literal is not supported
session_branch_protection_requires_aarch64 = `-Zbranch-protection` is only supported on aarch64
diff --git a/compiler/rustc_session/src/errors.rs b/compiler/rustc_session/src/errors.rs
index 71d8dbe44fed0..c4e726613a07a 100644
--- a/compiler/rustc_session/src/errors.rs
+++ b/compiler/rustc_session/src/errors.rs
@@ -1,4 +1,4 @@
-use std::num::NonZero;
+use std::num::{NonZero, ParseIntError};
use rustc_ast::token;
use rustc_ast::util::literal::LitError;
@@ -14,6 +14,14 @@ use rustc_target::spec::{SplitDebuginfo, StackProtector, TargetTuple};
use crate::config::CrateType;
use crate::parse::ParseSess;
+#[derive(Diagnostic)]
+pub(crate) enum AppleDeploymentTarget {
+ #[diag(session_apple_deployment_target_invalid)]
+ Invalid { env_var: &'static str, error: ParseIntError },
+ #[diag(session_apple_deployment_target_too_low)]
+ TooLow { env_var: &'static str, version: String, os_min: String },
+}
+
pub(crate) struct FeatureGateError {
pub(crate) span: MultiSpan,
pub(crate) explain: DiagMessage,
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index a87b1961a9951..c8fbecc888603 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -29,7 +29,7 @@ use rustc_target::asm::InlineAsmArch;
use rustc_target::spec::{
CodeModel, DebuginfoKind, PanicStrategy, RelocModel, RelroLevel, SanitizerSet,
SmallDataThresholdSupport, SplitDebuginfo, StackProtector, SymbolVisibility, Target,
- TargetTuple, TlsModel,
+ TargetTuple, TlsModel, apple,
};
use crate::code_stats::CodeStats;
@@ -891,6 +891,45 @@ impl Session {
FileNameDisplayPreference::Local
}
}
+
+ /// Get the deployment target on Apple platforms based on the standard environment variables,
+ /// or fall back to the minimum version supported by `rustc`.
+ ///
+ /// This should be guarded behind `if sess.target.is_like_osx`.
+ pub fn apple_deployment_target(&self) -> apple::OSVersion {
+ let min = apple::OSVersion::minimum_deployment_target(&self.target);
+ let env_var = apple::deployment_target_env_var(&self.target.os);
+
+ // FIXME(madsmtm): Track changes to this.
+ if let Ok(deployment_target) = env::var(env_var) {
+ match apple::OSVersion::from_str(&deployment_target) {
+ Ok(version) => {
+ let os_min = apple::OSVersion::os_minimum_deployment_target(&self.target.os);
+ // It is common that the deployment target is set a bit too low, for example on
+ // macOS Aarch64 to also target older x86_64. So we only want to warn when variable
+ // is lower than the minimum OS supported by rustc, not when the variable is lower
+ // than the minimum for a specific target.
+ if version < os_min {
+ self.dcx().emit_warn(errors::AppleDeploymentTarget::TooLow {
+ env_var,
+ version: version.fmt_pretty().to_string(),
+ os_min: os_min.fmt_pretty().to_string(),
+ });
+ }
+
+ // Raise the deployment target to the minimum supported.
+ version.max(min)
+ }
+ Err(error) => {
+ self.dcx().emit_err(errors::AppleDeploymentTarget::Invalid { env_var, error });
+ min
+ }
+ }
+ } else {
+ // If no deployment target variable is set, default to the minimum found above.
+ min
+ }
+ }
}
// JUSTIFICATION: part of session construction
diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs
index 613ea33ed1329..4165fa5b89cc7 100644
--- a/compiler/rustc_target/src/spec/base/apple/mod.rs
+++ b/compiler/rustc_target/src/spec/base/apple/mod.rs
@@ -317,3 +317,15 @@ impl OSVersion {
Self { major, minor, patch }
}
}
+
+/// Name of the environment variable used to fetch the deployment target on the given OS.
+pub fn deployment_target_env_var(os: &str) -> &'static str {
+ match os {
+ "macos" => "MACOSX_DEPLOYMENT_TARGET",
+ "ios" => "IPHONEOS_DEPLOYMENT_TARGET",
+ "watchos" => "WATCHOS_DEPLOYMENT_TARGET",
+ "tvos" => "TVOS_DEPLOYMENT_TARGET",
+ "visionos" => "XROS_DEPLOYMENT_TARGET",
+ _ => unreachable!("tried to get deployment target env var for non-Apple platform"),
+ }
+}
From 6ce74f78f002d40b98138ee2ba00bbb21af2630d Mon Sep 17 00:00:00 2001
From: Jane Losare-Lusby <jlusby@yaah.dev>
Date: Tue, 25 Mar 2025 11:56:55 -0700
Subject: [PATCH 05/33] replace extra_filename with strict version hash in
metrics file names
---
compiler/rustc_driver_impl/src/lib.rs | 13 +++++--------
compiler/rustc_middle/src/ty/context.rs | 5 +++++
2 files changed, 10 insertions(+), 8 deletions(-)
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 6ea14d15c1440..981cdf1d1d6e3 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -60,6 +60,7 @@ use rustc_session::lint::{Lint, LintId};
use rustc_session::output::collect_crate_types;
use rustc_session::{EarlyDiagCtxt, Session, config, filesearch};
use rustc_span::FileName;
+use rustc_span::def_id::LOCAL_CRATE;
use rustc_target::json::ToJson;
use rustc_target::spec::{Target, TargetTuple};
use time::OffsetDateTime;
@@ -383,14 +384,10 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
}
fn dump_feature_usage_metrics(tcxt: TyCtxt<'_>, metrics_dir: &Path) {
- let output_filenames = tcxt.output_filenames(());
- let mut metrics_file_name = std::ffi::OsString::from("unstable_feature_usage_metrics-");
- let mut metrics_path = output_filenames.with_directory_and_extension(metrics_dir, "json");
- let metrics_file_stem =
- metrics_path.file_name().expect("there should be a valid default output filename");
- metrics_file_name.push(metrics_file_stem);
- metrics_path.pop();
- metrics_path.push(metrics_file_name);
+ let hash = tcxt.crate_hash(LOCAL_CRATE);
+ let crate_name = tcxt.crate_name(LOCAL_CRATE);
+ let metrics_file_name = format!("unstable_feature_usage_metrics-{crate_name}-{hash}.json");
+ let metrics_path = metrics_dir.join(metrics_file_name);
if let Err(error) = tcxt.features().dump_feature_usage_metrics(metrics_path) {
// FIXME(yaahc): once metrics can be enabled by default we will want "failure to emit
// default metrics" to only produce a warning when metrics are enabled by default and emit
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 86248b495cdc3..8b6b2bc2493e6 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -1738,10 +1738,15 @@ impl<'tcx> TyCtxt<'tcx> {
// - needs_metadata: for putting into crate metadata.
// - instrument_coverage: for putting into coverage data (see
// `hash_mir_source`).
+ // - metrics_dir: metrics use the strict version hash in the filenames
+ // for dumped metrics files to prevent overwriting distinct metrics
+ // for similar source builds (may change in the future, this is part
+ // of the proof of concept impl for the metrics initiative project goal)
cfg!(debug_assertions)
|| self.sess.opts.incremental.is_some()
|| self.needs_metadata()
|| self.sess.instrument_coverage()
+ || self.sess.opts.unstable_opts.metrics_dir.is_some()
}
#[inline]
From 53ef53aed9cb43e6719f6f31aec82e05f236cd57 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 2 Apr 2025 12:39:58 -0500
Subject: [PATCH 06/33] settings.js: begin typechecking migration
this also makes `changeSetting` more robust in case it somehow
gets called before `main.js` has finished loading.
---
src/librustdoc/html/static/js/main.js | 3 ---
src/librustdoc/html/static/js/rustdoc.d.ts | 2 ++
src/librustdoc/html/static/js/settings.js | 21 +++++++++++++++++----
3 files changed, 19 insertions(+), 7 deletions(-)
diff --git a/src/librustdoc/html/static/js/main.js b/src/librustdoc/html/static/js/main.js
index 4150c5609a97e..d6f4c2e0fa842 100644
--- a/src/librustdoc/html/static/js/main.js
+++ b/src/librustdoc/html/static/js/main.js
@@ -1101,7 +1101,6 @@ function preLoadCss(cssUrl) {
});
}());
- // @ts-expect-error
window.rustdoc_add_line_numbers_to_examples = () => {
// @ts-expect-error
function generateLine(nb) {
@@ -1123,7 +1122,6 @@ function preLoadCss(cssUrl) {
});
};
- // @ts-expect-error
window.rustdoc_remove_line_numbers_from_examples = () => {
onEachLazy(
document.querySelectorAll(".rustdoc:not(.src) :not(.scraped-example) > .example-wrap"),
@@ -1132,7 +1130,6 @@ function preLoadCss(cssUrl) {
};
if (getSettingValue("line-numbers") === "true") {
- // @ts-expect-error
window.rustdoc_add_line_numbers_to_examples();
}
diff --git a/src/librustdoc/html/static/js/rustdoc.d.ts b/src/librustdoc/html/static/js/rustdoc.d.ts
index 91a58fab86eff..0465866e3671a 100644
--- a/src/librustdoc/html/static/js/rustdoc.d.ts
+++ b/src/librustdoc/html/static/js/rustdoc.d.ts
@@ -78,6 +78,8 @@ declare global {
pending_implementors?: rustdoc.Implementors,
register_type_impls?: function(rustdoc.TypeImpls): void,
pending_type_impls?: rustdoc.TypeImpls,
+ rustdoc_add_line_numbers_to_examples?: function(),
+ rustdoc_remove_line_numbers_from_examples?: function(),
}
interface HTMLElement {
/** Used by the popover tooltip code. */
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index 5f1bbd27328cb..ff21c828611a0 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -4,19 +4,26 @@
/* global MAIN_ID, getVar, getSettingsButton, getHelpButton */
// Eventually fix this.
-// @ts-nocheck
"use strict";
(function() {
const isSettingsPage = window.location.pathname.endsWith("/settings.html");
+ /**
+ * @overload {"theme"|"preferred-dark-theme"|"preferred-light-theme"}
+ * @param {string} settingName
+ * @param {string} value
+ * @returns
+ * @param {string} settingName
+ * @param {string|boolean} value
+ */
function changeSetting(settingName, value) {
if (settingName === "theme") {
const useSystem = value === "system preference" ? "true" : "false";
updateLocalStorage("use-system-theme", useSystem);
}
- updateLocalStorage(settingName, value);
+ updateLocalStorage(settingName, "" + value);
switch (settingName) {
case "theme":
@@ -27,9 +34,15 @@
break;
case "line-numbers":
if (value === true) {
- window.rustdoc_add_line_numbers_to_examples();
+ const f = window.rustdoc_add_line_numbers_to_examples;
+ if (f !== undefined) {
+ f();
+ }
} else {
- window.rustdoc_remove_line_numbers_from_examples();
+ const f = window.rustdoc_remove_line_numbers_from_examples;
+ if (f !== undefined) {
+ f();
+ }
}
break;
case "hide-sidebar":
From 6ca7bd041b2da04274d019f4dd001f5cfc51e78a Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 2 Apr 2025 13:06:17 -0500
Subject: [PATCH 07/33] settings.js: add new rustdoc.Setting interface
---
src/librustdoc/html/static/js/rustdoc.d.ts | 10 +++++
src/librustdoc/html/static/js/settings.js | 43 +++++++++++++---------
2 files changed, 36 insertions(+), 17 deletions(-)
diff --git a/src/librustdoc/html/static/js/rustdoc.d.ts b/src/librustdoc/html/static/js/rustdoc.d.ts
index 0465866e3671a..1b28fcb19defc 100644
--- a/src/librustdoc/html/static/js/rustdoc.d.ts
+++ b/src/librustdoc/html/static/js/rustdoc.d.ts
@@ -479,4 +479,14 @@ declare namespace rustdoc {
* is a tuple of (filename, subdirs, filenames).
*/
type Dir = [string, rustdoc.Dir[], string[]]
+
+ /**
+ * Indivitual setting object, used in `settings.js`
+ */
+ interface Setting {
+ js_name: string,
+ name: string,
+ options?: string[],
+ default: string | boolean,
+ }
}
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index ff21c828611a0..694a26cdac200 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -102,6 +102,9 @@
}
}
+ /**
+ * @param {HTMLElement} settingsElement
+ */
function setEvents(settingsElement) {
updateLightAndDark();
onEachLazy(settingsElement.querySelectorAll("input[type=\"checkbox\"]"), toggle => {
@@ -114,23 +117,27 @@
changeSetting(toggle.id, toggle.checked);
};
});
- onEachLazy(settingsElement.querySelectorAll("input[type=\"radio\"]"), elem => {
- const settingId = elem.name;
- let settingValue = getSettingValue(settingId);
- if (settingId === "theme") {
- const useSystem = getSettingValue("use-system-theme");
- if (useSystem === "true" || settingValue === null) {
- // "light" is the default theme
- settingValue = useSystem === "false" ? "light" : "system preference";
+ onEachLazy(
+ settingsElement.querySelectorAll("input[type=\"radio\"]"),
+ /** @param {HTMLInputElement} elem */
+ elem => {
+ const settingId = elem.name;
+ let settingValue = getSettingValue(settingId);
+ if (settingId === "theme") {
+ const useSystem = getSettingValue("use-system-theme");
+ if (useSystem === "true" || settingValue === null) {
+ // "light" is the default theme
+ settingValue = useSystem === "false" ? "light" : "system preference";
+ }
}
+ if (settingValue !== null && settingValue !== "null") {
+ elem.checked = settingValue === elem.value;
+ }
+ elem.addEventListener("change", ev => {
+ changeSetting(elem.name, elem.value);
+ });
}
- if (settingValue !== null && settingValue !== "null") {
- elem.checked = settingValue === elem.value;
- }
- elem.addEventListener("change", ev => {
- changeSetting(ev.target.name, ev.target.value);
- });
- });
+ );
}
/**
@@ -138,7 +145,7 @@
* as argument which describes each setting and how to render it. It returns a string
* representing the raw HTML.
*
- * @param {Array<Object>} settings
+ * @param {Array<rustdoc.Setting>} settings
*
* @return {string}
*/
@@ -195,7 +202,9 @@
* @return {HTMLElement}
*/
function buildSettingsPage() {
- const theme_names = getVar("themes").split(",").filter(t => t);
+ const theme_list = getVar("themes")
+ const theme_names = (theme_list === null ? "" : theme_list)
+ .split(",").filter(t => t);
theme_names.push("light", "dark", "ayu");
const settings = [
From f05683639d64dc26e51f63d97a0ba3cd812dc374 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 2 Apr 2025 13:08:05 -0500
Subject: [PATCH 08/33] settings.js: remove dead code for adding <hr> to
settings page
---
src/librustdoc/html/static/js/settings.js | 5 -----
1 file changed, 5 deletions(-)
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index 694a26cdac200..5e706e284928d 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -153,11 +153,6 @@
let output = "";
for (const setting of settings) {
- if (setting === "hr") {
- output += "<hr>";
- continue;
- }
-
const js_data_name = setting["js_name"];
const setting_name = setting["name"];
From 9f8d3d0bc9057ecc9de715a5cf65d97dc67da766 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 2 Apr 2025 13:09:49 -0500
Subject: [PATCH 09/33] settings.js: refactor settingsBlurHandler
changes:
* Add type signature
* Add null checks
* getHelpButton and getSettingsButton are only called once,
which should marginally improve performance due to less queries.
unfortunatly 2 @ts-expect-error was needed,
as typescript is unaware the EventTarget is likely an Element.
---
src/librustdoc/html/static/js/settings.js | 19 ++++++++++++++-----
1 file changed, 14 insertions(+), 5 deletions(-)
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index 5e706e284928d..f61673c9088ea 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -310,12 +310,21 @@
});
}
+ /**
+ * @param {MouseEvent} event
+ */
function settingsBlurHandler(event) {
- if (!getHelpButton().contains(document.activeElement) &&
- !getHelpButton().contains(event.relatedTarget) &&
- !getSettingsButton().contains(document.activeElement) &&
- !getSettingsButton().contains(event.relatedTarget)
- ) {
+ const helpBtn = getHelpButton();
+ const settingsBtn = getSettingsButton();
+ const helpUnfocused = helpBtn === null ||
+ (!helpBtn.contains(document.activeElement) &&
+ // @ts-expect-error
+ !helpBtn.contains(event.relatedTarget));
+ const settingsUnfocused = settingsBtn === null ||
+ (!settingsBtn.contains(document.activeElement) &&
+ // @ts-expect-error
+ !settingsBtn.contains(event.relatedTarget));
+ if (helpUnfocused && settingsUnfocused) {
window.hidePopoverMenus();
}
}
From d2ff26bbe696e3aa8f6c92de787d8de4c68d7a5e Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 2 Apr 2025 13:24:55 -0500
Subject: [PATCH 10/33] settings.js: add some null checks to buildSettingsPage
---
src/librustdoc/html/static/js/settings.js | 10 ++++++++--
1 file changed, 8 insertions(+), 2 deletions(-)
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index f61673c9088ea..ea02e01dccf7b 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -289,10 +289,16 @@
el.innerHTML = innerHTML;
if (isSettingsPage) {
- document.getElementById(MAIN_ID).appendChild(el);
+ const mainElem = document.getElementById(MAIN_ID);
+ if (mainElem !== null) {
+ mainElem.appendChild(el);
+ }
} else {
el.setAttribute("tabindex", "-1");
- getSettingsButton().appendChild(el);
+ const settingsBtn = getSettingsButton();
+ if (settingsBtn !== null) {
+ settingsBtn.appendChild(el);
+ }
}
return el;
}
From a805f5253e96dd1746cd929fd172a3e8391c6517 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 2 Apr 2025 13:45:35 -0500
Subject: [PATCH 11/33] settings.js: make top-level code typecheck
With this, almost the entire file is fully typechecked,
the only exception being the Element.contains(EventTarget) pattern
that is used several times, those are annotated with
@ts-expect-error
---
src/librustdoc/html/static/js/main.js | 2 +-
src/librustdoc/html/static/js/rustdoc.d.ts | 2 ++
src/librustdoc/html/static/js/settings.js | 18 ++++++++++--------
3 files changed, 13 insertions(+), 9 deletions(-)
diff --git a/src/librustdoc/html/static/js/main.js b/src/librustdoc/html/static/js/main.js
index d6f4c2e0fa842..754eb90b4723a 100644
--- a/src/librustdoc/html/static/js/main.js
+++ b/src/librustdoc/html/static/js/main.js
@@ -1,6 +1,6 @@
// Local js definitions:
/* global addClass, getSettingValue, hasClass, updateLocalStorage */
-/* global onEachLazy, removeClass, getVar */
+/* global onEachLazy, removeClass, getVar, nonnull */
"use strict";
diff --git a/src/librustdoc/html/static/js/rustdoc.d.ts b/src/librustdoc/html/static/js/rustdoc.d.ts
index 1b28fcb19defc..0d2e19e019f34 100644
--- a/src/librustdoc/html/static/js/rustdoc.d.ts
+++ b/src/librustdoc/html/static/js/rustdoc.d.ts
@@ -30,6 +30,8 @@ declare global {
currentCrate: string|null;
/**
* Hide popovers, tooltips, or the mobile sidebar.
+ *
+ * Pass `true` to reset focus for tooltip popovers.
*/
hideAllModals: function(boolean),
/**
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index ea02e01dccf7b..4facb45ae38ef 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -1,9 +1,7 @@
// Local js definitions:
/* global getSettingValue, updateLocalStorage, updateTheme */
/* global addClass, removeClass, onEach, onEachLazy */
-/* global MAIN_ID, getVar, getSettingsButton, getHelpButton */
-
-// Eventually fix this.
+/* global MAIN_ID, getVar, getSettingsButton, getHelpButton, nonnull */
"use strict";
@@ -317,7 +315,7 @@
}
/**
- * @param {MouseEvent} event
+ * @param {FocusEvent} event
*/
function settingsBlurHandler(event) {
const helpBtn = getHelpButton();
@@ -337,22 +335,26 @@
if (!isSettingsPage) {
// We replace the existing "onclick" callback.
- const settingsButton = getSettingsButton();
- const settingsMenu = document.getElementById("settings");
+ // These elements must exist, as (outside of the settings page)
+ // `settings.js` is only loaded after the settings button is clicked.
+ const settingsButton = nonnull(getSettingsButton());
+ const settingsMenu = nonnull(document.getElementById("settings"));
settingsButton.onclick = event => {
+ // @ts-expect-error
if (settingsMenu.contains(event.target)) {
return;
}
event.preventDefault();
const shouldDisplaySettings = settingsMenu.style.display === "none";
- window.hideAllModals();
+ window.hideAllModals(false);
if (shouldDisplaySettings) {
displaySettings();
}
};
settingsButton.onblur = settingsBlurHandler;
- settingsButton.querySelector("a").onblur = settingsBlurHandler;
+ // the settings button should always have a link in it
+ nonnull(settingsButton.querySelector("a")).onblur = settingsBlurHandler;
onEachLazy(settingsMenu.querySelectorAll("input"), el => {
el.onblur = settingsBlurHandler;
});
From 8a341298ec1c6a029bda1cc9f0ec696e9444caa9 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 2 Apr 2025 13:48:05 -0500
Subject: [PATCH 12/33] main.js: make hideAllModals docs clearer
"true" looks like a string value, `true` makes it more clear
that we are talking about the actual boolean value.
---
src/librustdoc/html/static/js/main.js | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/librustdoc/html/static/js/main.js b/src/librustdoc/html/static/js/main.js
index 754eb90b4723a..9902918fe5e70 100644
--- a/src/librustdoc/html/static/js/main.js
+++ b/src/librustdoc/html/static/js/main.js
@@ -1593,7 +1593,7 @@ function preLoadCss(cssUrl) {
/**
* Hide popover menus, clickable tooltips, and the sidebar (if applicable).
*
- * Pass "true" to reset focus for tooltip popovers.
+ * Pass `true` to reset focus for tooltip popovers.
*/
window.hideAllModals = switchFocus => {
hideSidebar();
From 9f54910f4ba9d1183c5246ec16f0a35183772db2 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 2 Apr 2025 13:56:31 -0500
Subject: [PATCH 13/33] settings.js: add elemContainsTarget utility function
this allows us to eliminate the last 3 @ts-expect-error
in this file.
---
src/librustdoc/html/static/js/settings.js | 21 +++++++++++++++------
1 file changed, 15 insertions(+), 6 deletions(-)
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index 4facb45ae38ef..d82f5f5463345 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -8,6 +8,18 @@
(function() {
const isSettingsPage = window.location.pathname.endsWith("/settings.html");
+ /**
+ * @param {Element} elem
+ * @param {EventTarget|null} target
+ */
+ function elemContainsTarget(elem, target) {
+ if (target instanceof Node) {
+ return elem.contains(target);
+ } else {
+ return false;
+ }
+ }
+
/**
* @overload {"theme"|"preferred-dark-theme"|"preferred-light-theme"}
* @param {string} settingName
@@ -322,12 +334,10 @@
const settingsBtn = getSettingsButton();
const helpUnfocused = helpBtn === null ||
(!helpBtn.contains(document.activeElement) &&
- // @ts-expect-error
- !helpBtn.contains(event.relatedTarget));
+ !elemContainsTarget(helpBtn, event.relatedTarget));
const settingsUnfocused = settingsBtn === null ||
(!settingsBtn.contains(document.activeElement) &&
- // @ts-expect-error
- !settingsBtn.contains(event.relatedTarget));
+ !elemContainsTarget(settingsBtn, event.relatedTarget));
if (helpUnfocused && settingsUnfocused) {
window.hidePopoverMenus();
}
@@ -340,8 +350,7 @@
const settingsButton = nonnull(getSettingsButton());
const settingsMenu = nonnull(document.getElementById("settings"));
settingsButton.onclick = event => {
- // @ts-expect-error
- if (settingsMenu.contains(event.target)) {
+ if (elemContainsTarget(settingsMenu, event.target)) {
return;
}
event.preventDefault();
From 6a1f57d095d3f6236b737655182cffb34cbf1ae2 Mon Sep 17 00:00:00 2001
From: Noratrieb <48135649+Noratrieb@users.noreply.github.com>
Date: Sat, 1 Mar 2025 22:21:26 +0100
Subject: [PATCH 14/33] Demote i686-pc-windows-gnu to Tier 2
In accordance with RFC 3771.
I also added a stub doc page for the target and renamed the
windows-gnullvm page for consistency.
---
.../src/spec/targets/i686_pc_windows_gnu.rs | 2 +-
src/bootstrap/mk/Makefile.in | 4 ---
.../docker/host-x86_64/mingw-check/Dockerfile | 2 +-
.../x86_64-gnu-tools/checktools.sh | 1 -
src/ci/github-actions/jobs.yml | 27 +---------------
src/doc/rustc/src/SUMMARY.md | 3 +-
src/doc/rustc/src/platform-support.md | 10 +++---
.../rustc/src/platform-support/windows-gnu.md | 32 +++++++++++++++++++
...-windows-gnullvm.md => windows-gnullvm.md} | 8 ++---
9 files changed, 46 insertions(+), 43 deletions(-)
create mode 100644 src/doc/rustc/src/platform-support/windows-gnu.md
rename src/doc/rustc/src/platform-support/{pc-windows-gnullvm.md => windows-gnullvm.md} (88%)
diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs
index 2a26323e5147b..e775c8fc524c4 100644
--- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs
@@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
llvm_target: "i686-pc-windows-gnu".into(),
metadata: TargetMetadata {
description: Some("32-bit MinGW (Windows 10+)".into()),
- tier: Some(1),
+ tier: Some(2),
host_tools: Some(true),
std: Some(true),
},
diff --git a/src/bootstrap/mk/Makefile.in b/src/bootstrap/mk/Makefile.in
index 6cb0b19d7632a..605f54d1d7fc7 100644
--- a/src/bootstrap/mk/Makefile.in
+++ b/src/bootstrap/mk/Makefile.in
@@ -120,10 +120,6 @@ ci-msvc: ci-msvc-py ci-msvc-ps1
# Set of tests that should represent half of the time of the test suite.
# Used to split tests across multiple CI runners.
# Test both x and bootstrap entrypoints.
-ci-mingw-x-1:
- $(Q)$(CFG_SRC_DIR)/x test --stage 2 $(SKIP_COMPILER) $(TEST_SET2)
-ci-mingw-x-2:
- $(Q)$(CFG_SRC_DIR)/x test --stage 2 $(SKIP_SRC) $(TEST_SET2)
ci-mingw-x:
$(Q)$(CFG_SRC_DIR)/x test --stage 2 $(TEST_SET1)
ci-mingw-bootstrap:
diff --git a/src/ci/docker/host-x86_64/mingw-check/Dockerfile b/src/ci/docker/host-x86_64/mingw-check/Dockerfile
index b32fa6c8e4eef..8bb7116c3ec58 100644
--- a/src/ci/docker/host-x86_64/mingw-check/Dockerfile
+++ b/src/ci/docker/host-x86_64/mingw-check/Dockerfile
@@ -47,7 +47,7 @@ COPY host-x86_64/mingw-check/validate-error-codes.sh /scripts/
ENV SCRIPT \
python3 ../x.py check --stage 0 --set build.optimized-compiler-builtins=false core alloc std --target=aarch64-unknown-linux-gnu,i686-pc-windows-msvc,i686-unknown-linux-gnu,x86_64-apple-darwin,x86_64-pc-windows-gnu,x86_64-pc-windows-msvc && \
/scripts/check-default-config-profiles.sh && \
- python3 ../x.py check --target=i686-pc-windows-gnu --host=i686-pc-windows-gnu && \
+ python3 ../x.py check --target=x86_64-pc-windows-gnu --host=x86_64-pc-windows-gnu && \
python3 ../x.py clippy ci && \
python3 ../x.py build --stage 0 src/tools/build-manifest && \
python3 ../x.py test --stage 0 src/tools/compiletest && \
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-tools/checktools.sh b/src/ci/docker/host-x86_64/x86_64-gnu-tools/checktools.sh
index 8324d1ec58624..28c035daa5d50 100755
--- a/src/ci/docker/host-x86_64/x86_64-gnu-tools/checktools.sh
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-tools/checktools.sh
@@ -62,7 +62,6 @@ case $HOST_TARGET in
# See <https://github.com/rust-lang/rust/issues/127883>
# For now, these tests are moved to `x86_64-msvc-ext2` in `src/ci/github-actions/jobs.yml`.
#python3 "$X_PY" test --stage 2 src/tools/miri --target aarch64-apple-darwin --test-args pass
- #python3 "$X_PY" test --stage 2 src/tools/miri --target i686-pc-windows-gnu --test-args pass
;;
*)
echo "FATAL: unexpected host $HOST_TARGET"
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index f62ed23d038c7..26ff17e423b5d 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -501,7 +501,7 @@ auto:
env:
SCRIPT: >
python x.py test --stage 2 src/tools/miri --target aarch64-apple-darwin --test-args pass &&
- python x.py test --stage 2 src/tools/miri --target i686-pc-windows-gnu --test-args pass &&
+ python x.py test --stage 2 src/tools/miri --target x86_64-pc-windows-gnu --test-args pass &&
python x.py miri --stage 2 library/core --test-args notest &&
python x.py miri --stage 2 library/alloc --test-args notest &&
python x.py miri --stage 2 library/std --test-args notest
@@ -533,31 +533,6 @@ auto:
# came from the mingw-w64 SourceForge download site. Unfortunately
# SourceForge is notoriously flaky, so we mirror it on our own infrastructure.
- # i686-mingw is split into three jobs to run tests in parallel.
- - name: i686-mingw-1
- env:
- RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu
- SCRIPT: make ci-mingw-x-1
- # There is no dist-i686-mingw-alt, so there is no prebuilt LLVM with assertions
- NO_DOWNLOAD_CI_LLVM: 1
- <<: *job-windows-25
-
- - name: i686-mingw-2
- env:
- RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu
- SCRIPT: make ci-mingw-x-2
- # There is no dist-i686-mingw-alt, so there is no prebuilt LLVM with assertions
- NO_DOWNLOAD_CI_LLVM: 1
- <<: *job-windows-25
-
- - name: i686-mingw-3
- env:
- RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu
- SCRIPT: make ci-mingw-bootstrap
- # There is no dist-i686-mingw-alt, so there is no prebuilt LLVM with assertions
- NO_DOWNLOAD_CI_LLVM: 1
- <<: *job-windows-25
-
# x86_64-mingw is split into two jobs to run tests in parallel.
- name: x86_64-mingw-1
env:
diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index e1ba27c07daef..9bb64adfa7869 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -103,7 +103,6 @@
- [s390x-unknown-linux-musl](platform-support/s390x-unknown-linux-musl.md)
- [sparc-unknown-none-elf](./platform-support/sparc-unknown-none-elf.md)
- [solaris](platform-support/solaris.md)
- - [\*-pc-windows-gnullvm](platform-support/pc-windows-gnullvm.md)
- [\*-nto-qnx-\*](platform-support/nto-qnx.md)
- [\*-unikraft-linux-musl](platform-support/unikraft-linux-musl.md)
- [\*-unknown-hermit](platform-support/hermit.md)
@@ -122,6 +121,8 @@
- [wasm32-unknown-unknown](platform-support/wasm32-unknown-unknown.md)
- [wasm32v1-none](platform-support/wasm32v1-none.md)
- [wasm64-unknown-unknown](platform-support/wasm64-unknown-unknown.md)
+ - [windows-gnu](platform-support/windows-gnu.md)
+ - [windows-gnullvm](platform-support/windows-gnullvm.md)
- [\*-win7-windows-gnu](platform-support/win7-windows-gnu.md)
- [\*-win7-windows-msvc](platform-support/win7-windows-msvc.md)
- [x86_64-fortanix-unknown-sgx](platform-support/x86_64-fortanix-unknown-sgx.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index bc97568f85c97..4149b4cb92020 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -34,11 +34,10 @@ target | notes
-------|-------
[`aarch64-apple-darwin`](platform-support/apple-darwin.md) | ARM64 macOS (11.0+, Big Sur+)
`aarch64-unknown-linux-gnu` | ARM64 Linux (kernel 4.1, glibc 2.17+)
-`i686-pc-windows-gnu` | 32-bit MinGW (Windows 10+, Windows Server 2016+, Pentium 4) [^x86_32-floats-return-ABI]
`i686-pc-windows-msvc` | 32-bit MSVC (Windows 10+, Windows Server 2016+, Pentium 4) [^x86_32-floats-return-ABI]
`i686-unknown-linux-gnu` | 32-bit Linux (kernel 3.2+, glibc 2.17+, Pentium 4) [^x86_32-floats-return-ABI]
[`x86_64-apple-darwin`](platform-support/apple-darwin.md) | 64-bit macOS (10.12+, Sierra+)
-`x86_64-pc-windows-gnu` | 64-bit MinGW (Windows 10+, Windows Server 2016+)
+[`x86_64-pc-windows-gnu`](platform-support/windows-gnu.md) | 64-bit MinGW (Windows 10+, Windows Server 2016+)
`x86_64-pc-windows-msvc` | 64-bit MSVC (Windows 10+, Windows Server 2016+)
`x86_64-unknown-linux-gnu` | 64-bit Linux (kernel 3.2+, glibc 2.17+)
@@ -96,6 +95,7 @@ target | notes
[`armv7-unknown-linux-ohos`](platform-support/openharmony.md) | Armv7-A OpenHarmony
[`loongarch64-unknown-linux-gnu`](platform-support/loongarch-linux.md) | LoongArch64 Linux, LP64D ABI (kernel 5.19, glibc 2.36)
[`loongarch64-unknown-linux-musl`](platform-support/loongarch-linux.md) | LoongArch64 Linux, LP64D ABI (kernel 5.19, musl 1.2.5)
+[`i686-pc-windows-gnu`](platform-support/windows-gnu.md) | 32-bit MinGW (Windows 10+, Windows Server 2016+, Pentium 4) [^x86_32-floats-return-ABI]
`powerpc-unknown-linux-gnu` | PowerPC Linux (kernel 3.2, glibc 2.17)
`powerpc64-unknown-linux-gnu` | PPC64 Linux (kernel 3.2, glibc 2.17)
[`powerpc64le-unknown-linux-gnu`](platform-support/powerpc64le-unknown-linux-gnu.md) | PPC64LE Linux (kernel 3.10, glibc 2.17)
@@ -143,7 +143,7 @@ target | std | notes
[`aarch64-apple-ios-macabi`](platform-support/apple-ios-macabi.md) | ✓ | Mac Catalyst on ARM64
[`aarch64-apple-ios-sim`](platform-support/apple-ios.md) | ✓ | Apple iOS Simulator on ARM64
[`aarch64-linux-android`](platform-support/android.md) | ✓ | ARM64 Android
-[`aarch64-pc-windows-gnullvm`](platform-support/pc-windows-gnullvm.md) | ✓ | ARM64 MinGW (Windows 10+), LLVM ABI
+[`aarch64-pc-windows-gnullvm`](platform-support/windows-gnullvm.md) | ✓ | ARM64 MinGW (Windows 10+), LLVM ABI
[`aarch64-unknown-fuchsia`](platform-support/fuchsia.md) | ✓ | ARM64 Fuchsia
`aarch64-unknown-none` | * | Bare ARM64, hardfloat
`aarch64-unknown-none-softfloat` | * | Bare ARM64, softfloat
@@ -166,7 +166,7 @@ target | std | notes
`i586-unknown-linux-gnu` | ✓ | 32-bit Linux (kernel 3.2, glibc 2.17, original Pentium) [^x86_32-floats-x87]
`i586-unknown-linux-musl` | ✓ | 32-bit Linux (musl 1.2.3, original Pentium) [^x86_32-floats-x87]
[`i686-linux-android`](platform-support/android.md) | ✓ | 32-bit x86 Android ([Pentium 4 plus various extensions](https://developer.android.com/ndk/guides/abis.html#x86)) [^x86_32-floats-return-ABI]
-[`i686-pc-windows-gnullvm`](platform-support/pc-windows-gnullvm.md) | ✓ | 32-bit x86 MinGW (Windows 10+, Pentium 4), LLVM ABI [^x86_32-floats-return-ABI]
+[`i686-pc-windows-gnullvm`](platform-support/windows-gnullvm.md) | ✓ | 32-bit x86 MinGW (Windows 10+, Pentium 4), LLVM ABI [^x86_32-floats-return-ABI]
[`i686-unknown-freebsd`](platform-support/freebsd.md) | ✓ | 32-bit x86 FreeBSD (Pentium 4) [^x86_32-floats-return-ABI]
`i686-unknown-linux-musl` | ✓ | 32-bit Linux with musl 1.2.3 (Pentium 4) [^x86_32-floats-return-ABI]
[`i686-unknown-uefi`](platform-support/unknown-uefi.md) | ? | 32-bit UEFI (Pentium 4, softfloat)
@@ -202,7 +202,7 @@ target | std | notes
[`x86_64-fortanix-unknown-sgx`](platform-support/x86_64-fortanix-unknown-sgx.md) | ✓ | [Fortanix ABI] for 64-bit Intel SGX
[`x86_64-linux-android`](platform-support/android.md) | ✓ | 64-bit x86 Android
[`x86_64-pc-solaris`](platform-support/solaris.md) | ✓ | 64-bit x86 Solaris 11.4
-[`x86_64-pc-windows-gnullvm`](platform-support/pc-windows-gnullvm.md) | ✓ | 64-bit x86 MinGW (Windows 10+), LLVM ABI
+[`x86_64-pc-windows-gnullvm`](platform-support/windows-gnullvm.md) | ✓ | 64-bit x86 MinGW (Windows 10+), LLVM ABI
[`x86_64-unknown-fuchsia`](platform-support/fuchsia.md) | ✓ | 64-bit x86 Fuchsia
`x86_64-unknown-linux-gnux32` | ✓ | 64-bit Linux (x32 ABI) (kernel 4.15, glibc 2.27)
[`x86_64-unknown-none`](platform-support/x86_64-unknown-none.md) | * | Freestanding/bare-metal x86_64, softfloat
diff --git a/src/doc/rustc/src/platform-support/windows-gnu.md b/src/doc/rustc/src/platform-support/windows-gnu.md
new file mode 100644
index 0000000000000..a867ebcfe2539
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/windows-gnu.md
@@ -0,0 +1,32 @@
+# \*-windows-gnu
+
+**⚠️ This documentation page is a stub, you can help improving it by sending a PR. ⚠️**
+
+**Tier: 1/2 (with host tools)**
+
+Target triples available:
+- `i686-pc-windows-gnu`: Tier 2
+- `x86_64-pc-windows-gnu`: Tier 1
+
+## Target maintainers
+
+**⚠️ These targets do not have any maintainers and are not properly maintained. ⚠️**
+
+If you are using this target, consider signing up to become a target maintainer.
+See the target tier policy for details.
+Without maintainers, these targets may be demoted in the future.
+
+## Requirements
+
+These targets support std and host tools.
+
+Unlike their MSVC counterparts, windows-gnu targets support cross-compilation and are free of all MSVC licensing implications.
+
+They follow Windows calling convention for `extern "C"`.
+
+Like with any other Windows target, created binaries are in PE format.
+
+## Building Rust programs
+
+Rust does ship a pre-compiled std library for those targets.
+That means one can easily compile and cross-compile for those targets from other hosts if C proper toolchain is installed.
diff --git a/src/doc/rustc/src/platform-support/pc-windows-gnullvm.md b/src/doc/rustc/src/platform-support/windows-gnullvm.md
similarity index 88%
rename from src/doc/rustc/src/platform-support/pc-windows-gnullvm.md
rename to src/doc/rustc/src/platform-support/windows-gnullvm.md
index f14fe7df42286..1ff559fe9600c 100644
--- a/src/doc/rustc/src/platform-support/pc-windows-gnullvm.md
+++ b/src/doc/rustc/src/platform-support/windows-gnullvm.md
@@ -1,8 +1,8 @@
-# \*-pc-windows-gnullvm
+# \*-windows-gnullvm
**Tier: 2 (without host tools)**
-Windows targets similar to `*-pc-windows-gnu` but using UCRT as the runtime and various LLVM tools/libraries instead of GCC/Binutils.
+Windows targets similar to `*-windows-gnu` but using UCRT as the runtime and various LLVM tools/libraries instead of GCC/Binutils.
Target triples available so far:
- `aarch64-pc-windows-gnullvm`
@@ -17,9 +17,9 @@ Target triples available so far:
## Requirements
The easiest way to obtain these targets is cross-compilation, but native build from `x86_64-pc-windows-gnu` is possible with few hacks which I don't recommend.
-Std support is expected to be on par with `*-pc-windows-gnu`.
+Std support is expected to be on par with `*-windows-gnu`.
-Binaries for this target should be at least on par with `*-pc-windows-gnu` in terms of requirements and functionality.
+Binaries for this target should be at least on par with `*-windows-gnu` in terms of requirements and functionality.
Those targets follow Windows calling convention for `extern "C"`.
From ef1827b97452f697c28d028f94148463606b2fd8 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 2 Apr 2025 15:24:38 -0500
Subject: [PATCH 15/33] settings.js: fix whitespace
---
src/librustdoc/html/static/js/settings.js | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index d82f5f5463345..2c051d0025cb5 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -19,7 +19,7 @@
return false;
}
}
-
+
/**
* @overload {"theme"|"preferred-dark-theme"|"preferred-light-theme"}
* @param {string} settingName
From 4435c999db7a4affa81662d1d90a75595da94b78 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 2 Apr 2025 16:36:08 -0500
Subject: [PATCH 16/33] rustdoc js: satisfy eslint
---
src/librustdoc/html/static/js/main.js | 2 +-
src/librustdoc/html/static/js/settings.js | 6 +++---
2 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/librustdoc/html/static/js/main.js b/src/librustdoc/html/static/js/main.js
index 9902918fe5e70..a7ce2bf9048bf 100644
--- a/src/librustdoc/html/static/js/main.js
+++ b/src/librustdoc/html/static/js/main.js
@@ -1,6 +1,6 @@
// Local js definitions:
/* global addClass, getSettingValue, hasClass, updateLocalStorage */
-/* global onEachLazy, removeClass, getVar, nonnull */
+/* global onEachLazy, removeClass, getVar */
"use strict";
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index 2c051d0025cb5..2430b5829b2ba 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -143,10 +143,10 @@
if (settingValue !== null && settingValue !== "null") {
elem.checked = settingValue === elem.value;
}
- elem.addEventListener("change", ev => {
+ elem.addEventListener("change", () => {
changeSetting(elem.name, elem.value);
});
- }
+ },
);
}
@@ -207,7 +207,7 @@
* @return {HTMLElement}
*/
function buildSettingsPage() {
- const theme_list = getVar("themes")
+ const theme_list = getVar("themes");
const theme_names = (theme_list === null ? "" : theme_list)
.split(",").filter(t => t);
theme_names.push("light", "dark", "ayu");
From 0d8c33f6f14c2a2e0ce03d82b313006e84b7a9c2 Mon Sep 17 00:00:00 2001
From: Jake Wharton <jw@squareup.com>
Date: Wed, 2 Apr 2025 23:03:55 -0400
Subject: [PATCH 17/33] Remove creation of duplicate AnonPipe
The File is unwrapped to a Handle into an AnonPipe, and then that AnonPipe was unwrapped to a Handle into another AnonPipe. The second operation is entirely redundant.
---
library/std/src/sys/pal/windows/pipe.rs | 1 -
1 file changed, 1 deletion(-)
diff --git a/library/std/src/sys/pal/windows/pipe.rs b/library/std/src/sys/pal/windows/pipe.rs
index c785246492268..7fd6233961951 100644
--- a/library/std/src/sys/pal/windows/pipe.rs
+++ b/library/std/src/sys/pal/windows/pipe.rs
@@ -143,7 +143,6 @@ pub fn anon_pipe(ours_readable: bool, their_handle_inheritable: bool) -> io::Res
};
opts.security_attributes(&mut sa);
let theirs = File::open(Path::new(&name), &opts)?;
- let theirs = AnonPipe { inner: theirs.into_inner() };
Ok(Pipes {
ours: AnonPipe { inner: ours },
From a2a081a0500bc5bdf88a833d320293f138ce529b Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 3 Apr 2025 14:23:49 +1100
Subject: [PATCH 18/33] Allow for missing invisible close delim when reparsing
an expression.
This can happen when invalid syntax is passed to a declarative macro. We
shouldn't be too strict about the token stream position once the parser
has rejected the invalid syntax.
Fixes #139248.
---
compiler/rustc_parse/src/parser/mod.rs | 5 +-
.../ui/macros/no-close-delim-issue-139248.rs | 9 ++++
.../macros/no-close-delim-issue-139248.stderr | 51 +++++++++++++++++++
3 files changed, 64 insertions(+), 1 deletion(-)
create mode 100644 tests/ui/macros/no-close-delim-issue-139248.rs
create mode 100644 tests/ui/macros/no-close-delim-issue-139248.stderr
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 392a1c1057abb..dd33491b5828d 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -778,7 +778,10 @@ impl<'a> Parser<'a> {
self.bump();
Some(res)
} else {
- panic!("no close delim when reparsing {mv_kind:?}");
+ // This can occur when invalid syntax is passed to a decl macro. E.g. see #139248,
+ // where the reparse attempt of an invalid expr consumed the trailing invisible
+ // delimiter.
+ None
}
} else {
None
diff --git a/tests/ui/macros/no-close-delim-issue-139248.rs b/tests/ui/macros/no-close-delim-issue-139248.rs
new file mode 100644
index 0000000000000..bdeeb5b98e5bf
--- /dev/null
+++ b/tests/ui/macros/no-close-delim-issue-139248.rs
@@ -0,0 +1,9 @@
+// This code caused a "no close delim when reparsing Expr" ICE in #139248.
+
+thread_local! { static a : () = (if b) }
+//~^ error: expected `{`, found `)`
+//~| error: expected `{`, found `)`
+//~| error: expected `{`, found `)`
+//~| error: expected expression, found end of macro arguments
+
+fn main() {}
diff --git a/tests/ui/macros/no-close-delim-issue-139248.stderr b/tests/ui/macros/no-close-delim-issue-139248.stderr
new file mode 100644
index 0000000000000..1ad36644a729b
--- /dev/null
+++ b/tests/ui/macros/no-close-delim-issue-139248.stderr
@@ -0,0 +1,51 @@
+error: expected `{`, found `)`
+ --> $DIR/no-close-delim-issue-139248.rs:3:38
+ |
+LL | thread_local! { static a : () = (if b) }
+ | ^ expected `{`
+ |
+note: the `if` expression is missing a block after this condition
+ --> $DIR/no-close-delim-issue-139248.rs:3:37
+ |
+LL | thread_local! { static a : () = (if b) }
+ | ^
+
+error: expected `{`, found `)`
+ --> $DIR/no-close-delim-issue-139248.rs:3:38
+ |
+LL | thread_local! { static a : () = (if b) }
+ | ^ expected `{`
+ |
+note: the `if` expression is missing a block after this condition
+ --> $DIR/no-close-delim-issue-139248.rs:3:37
+ |
+LL | thread_local! { static a : () = (if b) }
+ | ^
+ = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: expected `{`, found `)`
+ --> $DIR/no-close-delim-issue-139248.rs:3:38
+ |
+LL | thread_local! { static a : () = (if b) }
+ | ^ expected `{`
+ |
+note: the `if` expression is missing a block after this condition
+ --> $DIR/no-close-delim-issue-139248.rs:3:37
+ |
+LL | thread_local! { static a : () = (if b) }
+ | ^
+ = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: expected expression, found end of macro arguments
+ --> $DIR/no-close-delim-issue-139248.rs:3:1
+ |
+LL | thread_local! { static a : () = (if b) }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected expression
+ --> $SRC_DIR/std/src/sys/thread_local/native/mod.rs:LL:COL
+ |
+ = note: while parsing argument for this `expr` macro fragment
+ |
+ = note: this error originates in the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 4 previous errors
+
From fadea8e0ba18f1e6a33720451943f079caad0856 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Mon, 31 Mar 2025 15:09:43 +0000
Subject: [PATCH 19/33] Unset RUSTC_WRAPPER in cg_clif's build system
---
compiler/rustc_codegen_cranelift/build_system/utils.rs | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/compiler/rustc_codegen_cranelift/build_system/utils.rs b/compiler/rustc_codegen_cranelift/build_system/utils.rs
index c2114caf8692e..f239976845964 100644
--- a/compiler/rustc_codegen_cranelift/build_system/utils.rs
+++ b/compiler/rustc_codegen_cranelift/build_system/utils.rs
@@ -105,7 +105,11 @@ impl CargoProject {
.arg(self.manifest_path(dirs))
.arg("--target-dir")
.arg(self.target_dir(dirs))
- .arg("--locked");
+ .arg("--locked")
+ // bootstrap sets both RUSTC and RUSTC_WRAPPER to the same wrapper. RUSTC is already
+ // respected by the rustc-clif wrapper, but RUSTC_WRAPPER will misinterpret rustc-clif
+ // as filename, so we need to unset it.
+ .env_remove("RUSTC_WRAPPER");
if dirs.frozen {
cmd.arg("--frozen");
From 3e762b1897a71818ceb78707d0a734c7c3d45d70 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 3 Apr 2025 21:32:53 +1100
Subject: [PATCH 20/33] compiletest: Allow `--fail-fast` as a command-line
option
---
src/tools/compiletest/src/common.rs | 4 ++++
src/tools/compiletest/src/lib.rs | 19 +++++++++++--------
2 files changed, 15 insertions(+), 8 deletions(-)
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 08d3c1c343e08..cee351cd8b316 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -178,6 +178,10 @@ pub struct Config {
/// `true` to overwrite stderr/stdout files instead of complaining about changes in output.
pub bless: bool,
+ /// Stop as soon as possible after any test fails.
+ /// May run a few more tests before stopping, due to threading.
+ pub fail_fast: bool,
+
/// The library paths required for running the compiler.
pub compile_lib_path: PathBuf,
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 950566b2582a8..01899c2c8a630 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -50,6 +50,12 @@ use crate::util::logv;
/// some code here that inspects environment variables or even runs executables
/// (e.g. when discovering debugger versions).
pub fn parse_config(args: Vec<String>) -> Config {
+ if env::var("RUST_TEST_NOCAPTURE").is_ok() {
+ eprintln!(
+ "WARNING: RUST_TEST_NOCAPTURE is not supported. Use the `--no-capture` flag instead."
+ );
+ }
+
let mut opts = Options::new();
opts.reqopt("", "compile-lib-path", "path to host shared libraries", "PATH")
.reqopt("", "run-lib-path", "path to target shared libraries", "PATH")
@@ -128,6 +134,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
"bless",
"overwrite stderr/stdout files instead of complaining about a mismatch",
)
+ .optflag("", "fail-fast", "stop as soon as possible after any test fails")
.optflag("", "quiet", "print one character per test instead of one line")
.optopt("", "color", "coloring: auto, always, never", "WHEN")
.optflag("", "json", "emit json output instead of plaintext output")
@@ -319,6 +326,9 @@ pub fn parse_config(args: Vec<String>) -> Config {
Config {
bless: matches.opt_present("bless"),
+ fail_fast: matches.opt_present("fail-fast")
+ || env::var_os("RUSTC_TEST_FAIL_FAST").is_some(),
+
compile_lib_path: make_absolute(opt_path(matches, "compile-lib-path")),
run_lib_path: make_absolute(opt_path(matches, "run-lib-path")),
rustc_path: opt_path(matches, "rustc-path"),
@@ -603,13 +613,6 @@ pub fn run_tests(config: Arc<Config>) {
}
pub fn test_opts(config: &Config) -> test::TestOpts {
- if env::var("RUST_TEST_NOCAPTURE").is_ok() {
- eprintln!(
- "WARNING: RUST_TEST_NOCAPTURE is no longer used. \
- Use the `--nocapture` flag instead."
- );
- }
-
test::TestOpts {
exclude_should_panic: false,
filters: config.filters.clone(),
@@ -629,7 +632,7 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
options: test::Options::new(),
time_options: None,
force_run_in_process: false,
- fail_fast: std::env::var_os("RUSTC_TEST_FAIL_FAST").is_some(),
+ fail_fast: config.fail_fast,
}
}
From 13970949d135f3b0e1b9ece433c5fc230804d657 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Tue, 1 Apr 2025 13:54:08 +0000
Subject: [PATCH 21/33] Run coretests and alloctests with cg_clif in CI
---
.../build_system/tests.rs | 47 ++++++++++---------
compiler/rustc_codegen_cranelift/config.txt | 2 +-
library/coretests/Cargo.toml | 1 +
3 files changed, 28 insertions(+), 22 deletions(-)
diff --git a/compiler/rustc_codegen_cranelift/build_system/tests.rs b/compiler/rustc_codegen_cranelift/build_system/tests.rs
index 122b541fa35f8..eb15a3fc027eb 100644
--- a/compiler/rustc_codegen_cranelift/build_system/tests.rs
+++ b/compiler/rustc_codegen_cranelift/build_system/tests.rs
@@ -99,6 +99,32 @@ const BASE_SYSROOT_SUITE: &[TestCase] = &[
runner.run_out_command("gen_block_iterate", &[]);
}),
TestCase::build_bin_and_run("aot.raw-dylib", "example/raw-dylib.rs", &[]),
+ TestCase::custom("test.sysroot", &|runner| {
+ apply_patches(
+ &runner.dirs,
+ "sysroot_tests",
+ &runner.stdlib_source.join("library"),
+ &SYSROOT_TESTS_SRC.to_path(&runner.dirs),
+ );
+
+ SYSROOT_TESTS.clean(&runner.dirs);
+
+ // coretests and alloctests produce a bunch of warnings. When running
+ // in rust's CI warnings are denied, so we have to override that here.
+ let mut target_compiler = runner.target_compiler.clone();
+ target_compiler.rustflags.push("--cap-lints=allow".to_owned());
+
+ if runner.is_native {
+ let mut test_cmd = SYSROOT_TESTS.test(&target_compiler, &runner.dirs);
+ test_cmd.args(["-p", "coretests", "-p", "alloctests", "--tests", "--", "-q"]);
+ spawn_and_wait(test_cmd);
+ } else {
+ eprintln!("Cross-Compiling: Not running tests");
+ let mut build_cmd = SYSROOT_TESTS.build(&target_compiler, &runner.dirs);
+ build_cmd.args(["-p", "coretests", "-p", "alloctests", "--tests"]);
+ spawn_and_wait(build_cmd);
+ }
+ }),
];
pub(crate) static RAND_REPO: GitRepo = GitRepo::github(
@@ -146,27 +172,6 @@ const EXTENDED_SYSROOT_SUITE: &[TestCase] = &[
spawn_and_wait(build_cmd);
}
}),
- TestCase::custom("test.sysroot", &|runner| {
- apply_patches(
- &runner.dirs,
- "sysroot_tests",
- &runner.stdlib_source.join("library"),
- &SYSROOT_TESTS_SRC.to_path(&runner.dirs),
- );
-
- SYSROOT_TESTS.clean(&runner.dirs);
-
- if runner.is_native {
- let mut test_cmd = SYSROOT_TESTS.test(&runner.target_compiler, &runner.dirs);
- test_cmd.args(["-p", "coretests", "-p", "alloctests", "--", "-q"]);
- spawn_and_wait(test_cmd);
- } else {
- eprintln!("Cross-Compiling: Not running tests");
- let mut build_cmd = SYSROOT_TESTS.build(&runner.target_compiler, &runner.dirs);
- build_cmd.args(["-p", "coretests", "-p", "alloctests", "--tests"]);
- spawn_and_wait(build_cmd);
- }
- }),
TestCase::custom("test.regex", &|runner| {
REGEX_REPO.patch(&runner.dirs);
diff --git a/compiler/rustc_codegen_cranelift/config.txt b/compiler/rustc_codegen_cranelift/config.txt
index 714414fe8d685..6ae4767adfdf5 100644
--- a/compiler/rustc_codegen_cranelift/config.txt
+++ b/compiler/rustc_codegen_cranelift/config.txt
@@ -32,9 +32,9 @@ aot.issue-59326
aot.neon
aot.gen_block_iterate
aot.raw-dylib
+test.sysroot
testsuite.extended_sysroot
test.rust-random/rand
-test.sysroot
test.regex
test.portable-simd
diff --git a/library/coretests/Cargo.toml b/library/coretests/Cargo.toml
index e44f01d347b3d..7656388d24bee 100644
--- a/library/coretests/Cargo.toml
+++ b/library/coretests/Cargo.toml
@@ -12,6 +12,7 @@ edition = "2024"
path = "lib.rs"
test = false
bench = false
+doc = false
[[test]]
name = "coretests"
From ecf9e204c942b8e9bd4f04c9e2873ba04036e7e6 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 3 Apr 2025 20:58:34 +1100
Subject: [PATCH 22/33] compiletest: Encapsulate all of the code that touches
libtest
---
src/tools/compiletest/src/common.rs | 2 +-
src/tools/compiletest/src/executor.rs | 156 ++++++++++++++++++++++
src/tools/compiletest/src/header.rs | 33 ++---
src/tools/compiletest/src/header/tests.rs | 13 +-
src/tools/compiletest/src/lib.rs | 88 +++---------
5 files changed, 194 insertions(+), 98 deletions(-)
create mode 100644 src/tools/compiletest/src/executor.rs
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index cee351cd8b316..9e35d2b466763 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -9,9 +9,9 @@ use std::{fmt, iter};
use build_helper::git::GitConfig;
use semver::Version;
use serde::de::{Deserialize, Deserializer, Error as _};
-use test::{ColorConfig, OutputFormat};
pub use self::Mode::*;
+use crate::executor::{ColorConfig, OutputFormat};
use crate::util::{PathBufExt, add_dylib_path};
macro_rules! string_enum {
diff --git a/src/tools/compiletest/src/executor.rs b/src/tools/compiletest/src/executor.rs
new file mode 100644
index 0000000000000..7588fee2b2b06
--- /dev/null
+++ b/src/tools/compiletest/src/executor.rs
@@ -0,0 +1,156 @@
+//! This module encapsulates all of the code that interacts directly with
+//! libtest, to execute the collected tests.
+//!
+//! This will hopefully make it easier to migrate away from libtest someday.
+
+use std::borrow::Cow;
+use std::io;
+use std::sync::Arc;
+
+use crate::common::{Config, TestPaths};
+
+/// Delegates to libtest to run the list of collected tests.
+///
+/// Returns `Ok(true)` if all tests passed, or `Ok(false)` if one or more tests failed.
+pub(crate) fn execute_tests(config: &Config, tests: Vec<CollectedTest>) -> io::Result<bool> {
+ let opts = test_opts(config);
+ let tests = tests.into_iter().map(|t| t.into_libtest()).collect::<Vec<_>>();
+
+ test::run_tests_console(&opts, tests)
+}
+
+/// Information needed to create a `test::TestDescAndFn`.
+pub(crate) struct CollectedTest {
+ pub(crate) desc: CollectedTestDesc,
+ pub(crate) config: Arc<Config>,
+ pub(crate) testpaths: TestPaths,
+ pub(crate) revision: Option<String>,
+}
+
+/// Information needed to create a `test::TestDesc`.
+pub(crate) struct CollectedTestDesc {
+ pub(crate) name: String,
+ pub(crate) ignore: bool,
+ pub(crate) ignore_message: Option<Cow<'static, str>>,
+ pub(crate) should_panic: ShouldPanic,
+}
+
+impl CollectedTest {
+ fn into_libtest(self) -> test::TestDescAndFn {
+ let Self { desc, config, testpaths, revision } = self;
+ let CollectedTestDesc { name, ignore, ignore_message, should_panic } = desc;
+
+ // Libtest requires the ignore message to be a &'static str, so we might
+ // have to leak memory to create it. This is fine, as we only do so once
+ // per test, so the leak won't grow indefinitely.
+ let ignore_message = ignore_message.map(|msg| match msg {
+ Cow::Borrowed(s) => s,
+ Cow::Owned(s) => &*String::leak(s),
+ });
+
+ let desc = test::TestDesc {
+ name: test::DynTestName(name),
+ ignore,
+ ignore_message,
+ source_file: "",
+ start_line: 0,
+ start_col: 0,
+ end_line: 0,
+ end_col: 0,
+ should_panic: should_panic.to_libtest(),
+ compile_fail: false,
+ no_run: false,
+ test_type: test::TestType::Unknown,
+ };
+
+ // This closure is invoked when libtest returns control to compiletest
+ // to execute the test.
+ let testfn = test::DynTestFn(Box::new(move || {
+ crate::runtest::run(config, &testpaths, revision.as_deref());
+ Ok(())
+ }));
+
+ test::TestDescAndFn { desc, testfn }
+ }
+}
+
+/// Whether console output should be colored or not.
+#[derive(Copy, Clone, Default, Debug)]
+pub enum ColorConfig {
+ #[default]
+ AutoColor,
+ AlwaysColor,
+ NeverColor,
+}
+
+impl ColorConfig {
+ fn to_libtest(self) -> test::ColorConfig {
+ match self {
+ Self::AutoColor => test::ColorConfig::AutoColor,
+ Self::AlwaysColor => test::ColorConfig::AlwaysColor,
+ Self::NeverColor => test::ColorConfig::NeverColor,
+ }
+ }
+}
+
+/// Format of the test results output.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
+pub enum OutputFormat {
+ /// Verbose output
+ Pretty,
+ /// Quiet output
+ #[default]
+ Terse,
+ /// JSON output
+ Json,
+}
+
+impl OutputFormat {
+ fn to_libtest(self) -> test::OutputFormat {
+ match self {
+ Self::Pretty => test::OutputFormat::Pretty,
+ Self::Terse => test::OutputFormat::Terse,
+ Self::Json => test::OutputFormat::Json,
+ }
+ }
+}
+
+/// Whether test is expected to panic or not.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub(crate) enum ShouldPanic {
+ No,
+ Yes,
+}
+
+impl ShouldPanic {
+ fn to_libtest(self) -> test::ShouldPanic {
+ match self {
+ Self::No => test::ShouldPanic::No,
+ Self::Yes => test::ShouldPanic::Yes,
+ }
+ }
+}
+
+fn test_opts(config: &Config) -> test::TestOpts {
+ test::TestOpts {
+ exclude_should_panic: false,
+ filters: config.filters.clone(),
+ filter_exact: config.filter_exact,
+ run_ignored: if config.run_ignored { test::RunIgnored::Yes } else { test::RunIgnored::No },
+ format: config.format.to_libtest(),
+ logfile: config.logfile.clone(),
+ run_tests: true,
+ bench_benchmarks: true,
+ nocapture: config.nocapture,
+ color: config.color.to_libtest(),
+ shuffle: false,
+ shuffle_seed: None,
+ test_threads: None,
+ skip: config.skip.clone(),
+ list: false,
+ options: test::Options::new(),
+ time_options: None,
+ force_run_in_process: false,
+ fail_fast: config.fail_fast,
+ }
+}
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index f654bd9c90b51..a0178f4bcc576 100644
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -11,6 +11,7 @@ use tracing::*;
use crate::common::{Config, Debugger, FailMode, Mode, PassMode};
use crate::debuggers::{extract_cdb_version, extract_gdb_version};
+use crate::executor::{CollectedTestDesc, ShouldPanic};
use crate::header::auxiliary::{AuxProps, parse_and_update_aux};
use crate::header::needs::CachedNeedsConditions;
use crate::util::static_regex;
@@ -1355,15 +1356,15 @@ where
Some((min, max))
}
-pub fn make_test_description<R: Read>(
+pub(crate) fn make_test_description<R: Read>(
config: &Config,
cache: &HeadersCache,
- name: test::TestName,
+ name: String,
path: &Path,
src: R,
test_revision: Option<&str>,
poisoned: &mut bool,
-) -> test::TestDesc {
+) -> CollectedTestDesc {
let mut ignore = false;
let mut ignore_message = None;
let mut should_fail = false;
@@ -1387,10 +1388,7 @@ pub fn make_test_description<R: Read>(
match $e {
IgnoreDecision::Ignore { reason } => {
ignore = true;
- // The ignore reason must be a &'static str, so we have to leak memory to
- // create it. This is fine, as the header is parsed only at the start of
- // compiletest so it won't grow indefinitely.
- ignore_message = Some(&*Box::leak(Box::<str>::from(reason)));
+ ignore_message = Some(reason.into());
}
IgnoreDecision::Error { message } => {
eprintln!("error: {}:{line_number}: {message}", path.display());
@@ -1431,25 +1429,12 @@ pub fn make_test_description<R: Read>(
// since we run the pretty printer across all tests by default.
// If desired, we could add a `should-fail-pretty` annotation.
let should_panic = match config.mode {
- crate::common::Pretty => test::ShouldPanic::No,
- _ if should_fail => test::ShouldPanic::Yes,
- _ => test::ShouldPanic::No,
+ crate::common::Pretty => ShouldPanic::No,
+ _ if should_fail => ShouldPanic::Yes,
+ _ => ShouldPanic::No,
};
- test::TestDesc {
- name,
- ignore,
- ignore_message,
- source_file: "",
- start_line: 0,
- start_col: 0,
- end_line: 0,
- end_col: 0,
- should_panic,
- compile_fail: false,
- no_run: false,
- test_type: test::TestType::Unknown,
- }
+ CollectedTestDesc { name, ignore, ignore_message, should_panic }
}
fn ignore_cdb(config: &Config, line: &str) -> IgnoreDecision {
diff --git a/src/tools/compiletest/src/header/tests.rs b/src/tools/compiletest/src/header/tests.rs
index 4d90f152ee204..ff6bc49b72a13 100644
--- a/src/tools/compiletest/src/header/tests.rs
+++ b/src/tools/compiletest/src/header/tests.rs
@@ -8,14 +8,15 @@ use super::{
parse_normalize_rule,
};
use crate::common::{Config, Debugger, Mode};
+use crate::executor::{CollectedTestDesc, ShouldPanic};
fn make_test_description<R: Read>(
config: &Config,
- name: test::TestName,
+ name: String,
path: &Path,
src: R,
revision: Option<&str>,
-) -> test::TestDesc {
+) -> CollectedTestDesc {
let cache = HeadersCache::load(config);
let mut poisoned = false;
let test = crate::header::make_test_description(
@@ -233,7 +234,7 @@ fn parse_rs(config: &Config, contents: &str) -> EarlyProps {
}
fn check_ignore(config: &Config, contents: &str) -> bool {
- let tn = test::DynTestName(String::new());
+ let tn = String::new();
let p = Path::new("a.rs");
let d = make_test_description(&config, tn, p, std::io::Cursor::new(contents), None);
d.ignore
@@ -242,13 +243,13 @@ fn check_ignore(config: &Config, contents: &str) -> bool {
#[test]
fn should_fail() {
let config: Config = cfg().build();
- let tn = test::DynTestName(String::new());
+ let tn = String::new();
let p = Path::new("a.rs");
let d = make_test_description(&config, tn.clone(), p, std::io::Cursor::new(""), None);
- assert_eq!(d.should_panic, test::ShouldPanic::No);
+ assert_eq!(d.should_panic, ShouldPanic::No);
let d = make_test_description(&config, tn, p, std::io::Cursor::new("//@ should-fail"), None);
- assert_eq!(d.should_panic, test::ShouldPanic::Yes);
+ assert_eq!(d.should_panic, ShouldPanic::Yes);
}
#[test]
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 01899c2c8a630..8145ae1c1bced 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -12,6 +12,7 @@ pub mod common;
pub mod compute_diff;
mod debuggers;
pub mod errors;
+mod executor;
pub mod header;
mod json;
mod raise_fd_limit;
@@ -32,7 +33,6 @@ use std::{env, fs, vec};
use build_helper::git::{get_git_modified_files, get_git_untracked_files};
use getopts::Options;
-use test::ColorConfig;
use tracing::*;
use walkdir::WalkDir;
@@ -41,6 +41,7 @@ use crate::common::{
CompareMode, Config, Debugger, Mode, PassMode, TestPaths, UI_EXTENSIONS, expected_output_path,
output_base_dir, output_relative_path,
};
+use crate::executor::{CollectedTest, ColorConfig, OutputFormat};
use crate::header::HeadersCache;
use crate::util::logv;
@@ -402,9 +403,9 @@ pub fn parse_config(args: Vec<String>) -> Config {
verbose: matches.opt_present("verbose"),
format: match (matches.opt_present("quiet"), matches.opt_present("json")) {
(true, true) => panic!("--quiet and --json are incompatible"),
- (true, false) => test::OutputFormat::Terse,
- (false, true) => test::OutputFormat::Json,
- (false, false) => test::OutputFormat::Pretty,
+ (true, false) => OutputFormat::Terse,
+ (false, true) => OutputFormat::Json,
+ (false, false) => OutputFormat::Pretty,
},
only_modified: matches.opt_present("only-modified"),
color,
@@ -535,8 +536,6 @@ pub fn run_tests(config: Arc<Config>) {
// Let tests know which target they're running as
env::set_var("TARGET", &config.target);
- let opts = test_opts(&config);
-
let mut configs = Vec::new();
if let Mode::DebugInfo = config.mode {
// Debugging emscripten code doesn't make sense today
@@ -563,12 +562,12 @@ pub fn run_tests(config: Arc<Config>) {
tests.extend(collect_and_make_tests(c));
}
- tests.sort_by(|a, b| a.desc.name.as_slice().cmp(&b.desc.name.as_slice()));
+ tests.sort_by(|a, b| Ord::cmp(&a.desc.name, &b.desc.name));
// Delegate to libtest to filter and run the big list of structures created
- // during test discovery. When libtest decides to run a test, it will invoke
- // the corresponding closure created by `make_test_closure`.
- let res = test::run_tests_console(&opts, tests);
+ // during test discovery. When libtest decides to run a test, it will
+ // return control to compiletest by invoking a closure.
+ let res = crate::executor::execute_tests(&config, tests);
// Check the outcome reported by libtest.
match res {
@@ -612,30 +611,6 @@ pub fn run_tests(config: Arc<Config>) {
}
}
-pub fn test_opts(config: &Config) -> test::TestOpts {
- test::TestOpts {
- exclude_should_panic: false,
- filters: config.filters.clone(),
- filter_exact: config.filter_exact,
- run_ignored: if config.run_ignored { test::RunIgnored::Yes } else { test::RunIgnored::No },
- format: config.format,
- logfile: config.logfile.clone(),
- run_tests: true,
- bench_benchmarks: true,
- nocapture: config.nocapture,
- color: config.color,
- shuffle: false,
- shuffle_seed: None,
- test_threads: None,
- skip: config.skip.clone(),
- list: false,
- options: test::Options::new(),
- time_options: None,
- force_run_in_process: false,
- fail_fast: config.fail_fast,
- }
-}
-
/// Read-only context data used during test collection.
struct TestCollectorCx {
config: Arc<Config>,
@@ -646,17 +621,17 @@ struct TestCollectorCx {
/// Mutable state used during test collection.
struct TestCollector {
- tests: Vec<test::TestDescAndFn>,
+ tests: Vec<CollectedTest>,
found_path_stems: HashSet<PathBuf>,
poisoned: bool,
}
-/// Creates libtest structures for every test/revision in the test suite directory.
+/// Creates test structures for every test/revision in the test suite directory.
///
/// This always inspects _all_ test files in the suite (e.g. all 17k+ ui tests),
/// regardless of whether any filters/tests were specified on the command-line,
/// because filtering is handled later by libtest.
-pub fn collect_and_make_tests(config: Arc<Config>) -> Vec<test::TestDescAndFn> {
+pub(crate) fn collect_and_make_tests(config: Arc<Config>) -> Vec<CollectedTest> {
debug!("making tests from {}", config.src_test_suite_root.display());
let common_inputs_stamp = common_inputs_stamp(&config);
let modified_tests =
@@ -885,7 +860,7 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
};
// For each revision (or the sole dummy revision), create and append a
- // `test::TestDescAndFn` that can be handed over to libtest.
+ // `CollectedTest` that can be handed over to the test executor.
collector.tests.extend(revisions.into_iter().map(|revision| {
// Create a test name and description to hand over to libtest.
let src_file = fs::File::open(&test_path).expect("open test file to parse ignores");
@@ -908,13 +883,14 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
if !cx.config.force_rerun && is_up_to_date(cx, testpaths, &early_props, revision) {
desc.ignore = true;
// Keep this in sync with the "up-to-date" message detected by bootstrap.
- desc.ignore_message = Some("up-to-date");
+ desc.ignore_message = Some("up-to-date".into());
}
- // Create the callback that will run this test/revision when libtest calls it.
- let testfn = make_test_closure(Arc::clone(&cx.config), testpaths, revision);
+ let config = Arc::clone(&cx.config);
+ let testpaths = testpaths.clone();
+ let revision = revision.map(str::to_owned);
- test::TestDescAndFn { desc, testfn }
+ CollectedTest { desc, config, testpaths, revision }
}));
}
@@ -1046,11 +1022,7 @@ impl Stamp {
}
/// Creates a name for this test/revision that can be handed over to libtest.
-fn make_test_name(
- config: &Config,
- testpaths: &TestPaths,
- revision: Option<&str>,
-) -> test::TestName {
+fn make_test_name(config: &Config, testpaths: &TestPaths, revision: Option<&str>) -> String {
// Print the name of the file, relative to the sources root.
let path = testpaths.file.strip_prefix(&config.src_root).unwrap();
let debugger = match config.debugger {
@@ -1062,32 +1034,14 @@ fn make_test_name(
None => String::new(),
};
- test::DynTestName(format!(
+ format!(
"[{}{}{}] {}{}",
config.mode,
debugger,
mode_suffix,
path.display(),
revision.map_or("".to_string(), |rev| format!("#{}", rev))
- ))
-}
-
-/// Creates a callback for this test/revision that libtest will call when it
-/// decides to actually run the underlying test.
-fn make_test_closure(
- config: Arc<Config>,
- testpaths: &TestPaths,
- revision: Option<&str>,
-) -> test::TestFn {
- let testpaths = testpaths.clone();
- let revision = revision.map(str::to_owned);
-
- // This callback is the link between compiletest's test discovery code,
- // and the parts of compiletest that know how to run an individual test.
- test::DynTestFn(Box::new(move || {
- runtest::run(config, &testpaths, revision.as_deref());
- Ok(())
- }))
+ )
}
/// Checks that test discovery didn't find any tests whose name stem is a prefix
From 6af96f873a20a6ffd582ee5b1f5475fc924d19e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Tue, 18 Mar 2025 08:00:10 +0100
Subject: [PATCH 23/33] Add a helper function for checking if LLD was used to
`run-make-support`
---
src/tools/run-make-support/src/lib.rs | 1 +
src/tools/run-make-support/src/linker.rs | 36 ++++++++++
.../rust-lld-by-default-beta-stable/rmake.rs | 17 +----
.../rust-lld-by-default-nightly/rmake.rs | 27 +-------
.../run-make/rust-lld-custom-target/rmake.rs | 39 +++--------
tests/run-make/rust-lld/rmake.rs | 66 +++++--------------
6 files changed, 68 insertions(+), 118 deletions(-)
create mode 100644 src/tools/run-make-support/src/linker.rs
diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
index fd22ff6c8bced..c75d500d2f06e 100644
--- a/src/tools/run-make-support/src/lib.rs
+++ b/src/tools/run-make-support/src/lib.rs
@@ -17,6 +17,7 @@ pub mod assertion_helpers;
pub mod diff;
pub mod env;
pub mod external_deps;
+pub mod linker;
pub mod path_helpers;
pub mod run;
pub mod scoped_run;
diff --git a/src/tools/run-make-support/src/linker.rs b/src/tools/run-make-support/src/linker.rs
new file mode 100644
index 0000000000000..89093cf011393
--- /dev/null
+++ b/src/tools/run-make-support/src/linker.rs
@@ -0,0 +1,36 @@
+use regex::Regex;
+
+use crate::{Rustc, is_msvc};
+
+/// Asserts that `rustc` uses LLD for linking when executed.
+pub fn assert_rustc_uses_lld(rustc: &mut Rustc) {
+ let stderr = get_stderr_with_linker_messages(rustc);
+ assert!(
+ has_lld_version_in_logs(&stderr),
+ "LLD version should be present in rustc stderr:\n{stderr}"
+ );
+}
+
+/// Asserts that `rustc` doesn't use LLD for linking when executed.
+pub fn assert_rustc_doesnt_use_lld(rustc: &mut Rustc) {
+ let stderr = get_stderr_with_linker_messages(rustc);
+ assert!(
+ !has_lld_version_in_logs(&stderr),
+ "LLD version should NOT be present in rustc stderr:\n{stderr}"
+ );
+}
+
+fn get_stderr_with_linker_messages(rustc: &mut Rustc) -> String {
+ // lld-link is used if msvc, otherwise a gnu-compatible lld is used.
+ let linker_version_flag = if is_msvc() { "--version" } else { "-Wl,-v" };
+
+ let output = rustc.arg("-Wlinker-messages").link_arg(linker_version_flag).run();
+ output.stderr_utf8()
+}
+
+fn has_lld_version_in_logs(stderr: &str) -> bool {
+ // Strip the `-Wlinker-messages` wrappers prefixing the linker output.
+ let stderr = Regex::new(r"warning: linker std(out|err):").unwrap().replace_all(&stderr, "");
+ let lld_version_re = Regex::new(r"^LLD [0-9]+\.[0-9]+\.[0-9]+").unwrap();
+ stderr.lines().any(|line| lld_version_re.is_match(line.trim()))
+}
diff --git a/tests/run-make/rust-lld-by-default-beta-stable/rmake.rs b/tests/run-make/rust-lld-by-default-beta-stable/rmake.rs
index 263bb9b2e2002..9a08991c4b895 100644
--- a/tests/run-make/rust-lld-by-default-beta-stable/rmake.rs
+++ b/tests/run-make/rust-lld-by-default-beta-stable/rmake.rs
@@ -4,24 +4,11 @@
//@ ignore-nightly
//@ only-x86_64-unknown-linux-gnu
-use std::process::Output;
-
-use run_make_support::regex::Regex;
+use run_make_support::linker::assert_rustc_doesnt_use_lld;
use run_make_support::rustc;
fn main() {
// A regular compilation should not use rust-lld by default. We'll check that by asking the
// linker to display its version number with a link-arg.
- let output = rustc().arg("-Wlinker-messages").link_arg("-Wl,-v").input("main.rs").run();
- assert!(
- !find_lld_version_in_logs(output.stderr_utf8()),
- "the LLD version string should not be present in the output logs:\n{}",
- output.stderr_utf8()
- );
-}
-
-fn find_lld_version_in_logs(stderr: String) -> bool {
- let lld_version_re =
- Regex::new(r"^warning: linker stdout: LLD [0-9]+\.[0-9]+\.[0-9]+").unwrap();
- stderr.lines().any(|line| lld_version_re.is_match(line.trim()))
+ assert_rustc_doesnt_use_lld(rustc().input("main.rs"));
}
diff --git a/tests/run-make/rust-lld-by-default-nightly/rmake.rs b/tests/run-make/rust-lld-by-default-nightly/rmake.rs
index 7a0a08863dd39..3ff1e2770e65e 100644
--- a/tests/run-make/rust-lld-by-default-nightly/rmake.rs
+++ b/tests/run-make/rust-lld-by-default-nightly/rmake.rs
@@ -6,35 +6,14 @@
//@ ignore-stable
//@ only-x86_64-unknown-linux-gnu
-use run_make_support::regex::Regex;
+use run_make_support::linker::{assert_rustc_doesnt_use_lld, assert_rustc_uses_lld};
use run_make_support::rustc;
fn main() {
// A regular compilation should use rust-lld by default. We'll check that by asking the linker
// to display its version number with a link-arg.
- let output = rustc().arg("-Wlinker-messages").link_arg("-Wl,-v").input("main.rs").run();
- assert!(
- find_lld_version_in_logs(output.stderr_utf8()),
- "the LLD version string should be present in the output logs:\n{}",
- output.stderr_utf8()
- );
+ assert_rustc_uses_lld(rustc().input("main.rs"));
// But it can still be disabled by turning the linker feature off.
- let output = rustc()
- .arg("-Wlinker-messages")
- .link_arg("-Wl,-v")
- .arg("-Zlinker-features=-lld")
- .input("main.rs")
- .run();
- assert!(
- !find_lld_version_in_logs(output.stderr_utf8()),
- "the LLD version string should not be present in the output logs:\n{}",
- output.stderr_utf8()
- );
-}
-
-fn find_lld_version_in_logs(stderr: String) -> bool {
- let lld_version_re =
- Regex::new(r"^warning: linker stdout: LLD [0-9]+\.[0-9]+\.[0-9]+").unwrap();
- stderr.lines().any(|line| lld_version_re.is_match(line.trim()))
+ assert_rustc_doesnt_use_lld(rustc().arg("-Zlinker-features=-lld").input("main.rs"));
}
diff --git a/tests/run-make/rust-lld-custom-target/rmake.rs b/tests/run-make/rust-lld-custom-target/rmake.rs
index 993a248ad00d1..e2b065a10b170 100644
--- a/tests/run-make/rust-lld-custom-target/rmake.rs
+++ b/tests/run-make/rust-lld-custom-target/rmake.rs
@@ -8,43 +8,22 @@
//@ needs-rust-lld
//@ only-x86_64-unknown-linux-gnu
-use run_make_support::regex::Regex;
+use run_make_support::linker::{assert_rustc_doesnt_use_lld, assert_rustc_uses_lld};
use run_make_support::rustc;
fn main() {
// Compile to a custom target spec with rust-lld enabled by default. We'll check that by asking
// the linker to display its version number with a link-arg.
- let output = rustc()
- .crate_type("cdylib")
- .arg("-Wlinker-messages")
- .target("custom-target.json")
- .link_arg("-Wl,-v")
- .input("lib.rs")
- .run();
- assert!(
- find_lld_version_in_logs(output.stderr_utf8()),
- "the LLD version string should be present in the output logs:\n{}",
- output.stderr_utf8()
+ assert_rustc_uses_lld(
+ rustc().crate_type("cdylib").target("custom-target.json").input("lib.rs"),
);
// But it can also be disabled via linker features.
- let output = rustc()
- .crate_type("cdylib")
- .arg("-Wlinker-messages")
- .target("custom-target.json")
- .arg("-Zlinker-features=-lld")
- .link_arg("-Wl,-v")
- .input("lib.rs")
- .run();
- assert!(
- !find_lld_version_in_logs(output.stderr_utf8()),
- "the LLD version string should not be present in the output logs:\n{}",
- output.stderr_utf8()
+ assert_rustc_doesnt_use_lld(
+ rustc()
+ .crate_type("cdylib")
+ .target("custom-target.json")
+ .arg("-Zlinker-features=-lld")
+ .input("lib.rs"),
);
}
-
-fn find_lld_version_in_logs(stderr: String) -> bool {
- let lld_version_re =
- Regex::new(r"^warning: linker stdout: LLD [0-9]+\.[0-9]+\.[0-9]+").unwrap();
- stderr.lines().any(|line| lld_version_re.is_match(line.trim()))
-}
diff --git a/tests/run-make/rust-lld/rmake.rs b/tests/run-make/rust-lld/rmake.rs
index 35f716c24c71a..aafd4b96d7771 100644
--- a/tests/run-make/rust-lld/rmake.rs
+++ b/tests/run-make/rust-lld/rmake.rs
@@ -4,64 +4,32 @@
//@ needs-rust-lld
//@ ignore-s390x lld does not yet support s390x as target
-use run_make_support::regex::Regex;
-use run_make_support::{is_msvc, rustc};
+use run_make_support::linker::{assert_rustc_doesnt_use_lld, assert_rustc_uses_lld};
+use run_make_support::rustc;
fn main() {
- // lld-link is used if msvc, otherwise a gnu-compatible lld is used.
- let linker_version_flag = if is_msvc() { "--version" } else { "-Wl,-v" };
-
// Opt-in to lld and the self-contained linker, to link with rust-lld. We'll check that by
// asking the linker to display its version number with a link-arg.
- let output = rustc()
- .arg("-Zlinker-features=+lld")
- .arg("-Clink-self-contained=+linker")
- .arg("-Zunstable-options")
- .arg("-Wlinker-messages")
- .link_arg(linker_version_flag)
- .input("main.rs")
- .run();
- assert!(
- find_lld_version_in_logs(output.stderr_utf8()),
- "the LLD version string should be present in the output logs:\n{}",
- output.stderr_utf8()
+ assert_rustc_uses_lld(
+ rustc()
+ .arg("-Zlinker-features=+lld")
+ .arg("-Clink-self-contained=+linker")
+ .arg("-Zunstable-options")
+ .input("main.rs"),
);
// It should not be used when we explicitly opt-out of lld.
- let output = rustc()
- .link_arg(linker_version_flag)
- .arg("-Zlinker-features=-lld")
- .arg("-Wlinker-messages")
- .input("main.rs")
- .run();
- assert!(
- !find_lld_version_in_logs(output.stderr_utf8()),
- "the LLD version string should not be present in the output logs:\n{}",
- output.stderr_utf8()
- );
+ assert_rustc_doesnt_use_lld(rustc().arg("-Zlinker-features=-lld").input("main.rs"));
// While we're here, also check that the last linker feature flag "wins" when passed multiple
// times to rustc.
- let output = rustc()
- .link_arg(linker_version_flag)
- .arg("-Clink-self-contained=+linker")
- .arg("-Zunstable-options")
- .arg("-Zlinker-features=-lld")
- .arg("-Zlinker-features=+lld")
- .arg("-Zlinker-features=-lld,+lld")
- .arg("-Wlinker-messages")
- .input("main.rs")
- .run();
- assert!(
- find_lld_version_in_logs(output.stderr_utf8()),
- "the LLD version string should be present in the output logs:\n{}",
- output.stderr_utf8()
+ assert_rustc_uses_lld(
+ rustc()
+ .arg("-Clink-self-contained=+linker")
+ .arg("-Zunstable-options")
+ .arg("-Zlinker-features=-lld")
+ .arg("-Zlinker-features=+lld")
+ .arg("-Zlinker-features=-lld,+lld")
+ .input("main.rs"),
);
}
-
-fn find_lld_version_in_logs(stderr: String) -> bool {
- // Strip the `-Wlinker-messages` wrappers prefixing the linker output.
- let stderr = Regex::new(r"warning: linker std(out|err):").unwrap().replace_all(&stderr, "");
- let lld_version_re = Regex::new(r"^LLD [0-9]+\.[0-9]+\.[0-9]+").unwrap();
- stderr.lines().any(|line| lld_version_re.is_match(line.trim()))
-}
From 9ec11c246d616be224e963cafc8603b39e07926f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 24 Mar 2025 12:15:22 +0100
Subject: [PATCH 24/33] Move `link-self-contained-consistency` test to a more
reasonable location
---
tests/run-make/rust-lld/rmake.rs | 2 +-
.../link-self-contained-consistency.many.stderr | 0
.../link-self-contained-consistency.one.stderr | 0
.../link-self-contained-consistency.rs | 0
4 files changed, 1 insertion(+), 1 deletion(-)
rename tests/ui/{linkage-attr => linking}/link-self-contained-consistency.many.stderr (100%)
rename tests/ui/{linkage-attr => linking}/link-self-contained-consistency.one.stderr (100%)
rename tests/ui/{linkage-attr => linking}/link-self-contained-consistency.rs (100%)
diff --git a/tests/run-make/rust-lld/rmake.rs b/tests/run-make/rust-lld/rmake.rs
index aafd4b96d7771..9470f5d0be183 100644
--- a/tests/run-make/rust-lld/rmake.rs
+++ b/tests/run-make/rust-lld/rmake.rs
@@ -18,7 +18,7 @@ fn main() {
.input("main.rs"),
);
- // It should not be used when we explicitly opt-out of lld.
+ // It should not be used when we explicitly opt out of lld.
assert_rustc_doesnt_use_lld(rustc().arg("-Zlinker-features=-lld").input("main.rs"));
// While we're here, also check that the last linker feature flag "wins" when passed multiple
diff --git a/tests/ui/linkage-attr/link-self-contained-consistency.many.stderr b/tests/ui/linking/link-self-contained-consistency.many.stderr
similarity index 100%
rename from tests/ui/linkage-attr/link-self-contained-consistency.many.stderr
rename to tests/ui/linking/link-self-contained-consistency.many.stderr
diff --git a/tests/ui/linkage-attr/link-self-contained-consistency.one.stderr b/tests/ui/linking/link-self-contained-consistency.one.stderr
similarity index 100%
rename from tests/ui/linkage-attr/link-self-contained-consistency.one.stderr
rename to tests/ui/linking/link-self-contained-consistency.one.stderr
diff --git a/tests/ui/linkage-attr/link-self-contained-consistency.rs b/tests/ui/linking/link-self-contained-consistency.rs
similarity index 100%
rename from tests/ui/linkage-attr/link-self-contained-consistency.rs
rename to tests/ui/linking/link-self-contained-consistency.rs
From fde54c2c0301be851543220ce64c74a468a17311 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 3 Apr 2025 15:30:01 +0000
Subject: [PATCH 25/33] Fix testing with randomized layouts enabled
---
compiler/rustc_codegen_cranelift/build_system/tests.rs | 4 +++-
library/alloc/Cargo.toml | 1 -
2 files changed, 3 insertions(+), 2 deletions(-)
diff --git a/compiler/rustc_codegen_cranelift/build_system/tests.rs b/compiler/rustc_codegen_cranelift/build_system/tests.rs
index eb15a3fc027eb..eec89c026b26a 100644
--- a/compiler/rustc_codegen_cranelift/build_system/tests.rs
+++ b/compiler/rustc_codegen_cranelift/build_system/tests.rs
@@ -109,10 +109,12 @@ const BASE_SYSROOT_SUITE: &[TestCase] = &[
SYSROOT_TESTS.clean(&runner.dirs);
+ let mut target_compiler = runner.target_compiler.clone();
// coretests and alloctests produce a bunch of warnings. When running
// in rust's CI warnings are denied, so we have to override that here.
- let mut target_compiler = runner.target_compiler.clone();
target_compiler.rustflags.push("--cap-lints=allow".to_owned());
+ // The standard library may have been compiled with -Zrandomize-layout.
+ target_compiler.rustflags.extend(["--cfg".to_owned(), "randomized_layouts".to_owned()]);
if runner.is_native {
let mut test_cmd = SYSROOT_TESTS.test(&target_compiler, &runner.dirs);
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index b729d5e116d2c..1d2dd1e60819f 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -36,5 +36,4 @@ check-cfg = [
'cfg(no_global_oom_handling)',
'cfg(no_rc)',
'cfg(no_sync)',
- 'cfg(randomized_layouts)',
]
From 6189594c0a614432a4f099b15f176d57a46c257b Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Thu, 3 Apr 2025 10:43:32 +0000
Subject: [PATCH 26/33] Deduplicate some `rustc_middle` function bodies by
calling the `rustc_type_ir` equivalent
---
compiler/rustc_middle/src/ty/sty.rs | 47 ++-----------------
compiler/rustc_type_ir/src/inherent.rs | 57 +----------------------
compiler/rustc_type_ir/src/ty_kind.rs | 62 ++++++++++++++++++++++++++
3 files changed, 67 insertions(+), 99 deletions(-)
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 74a94d8278453..27ee363f1c142 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -8,7 +8,7 @@ use std::iter;
use std::ops::{ControlFlow, Range};
use hir::def::{CtorKind, DefKind};
-use rustc_abi::{ExternAbi, FIRST_VARIANT, FieldIdx, VariantIdx};
+use rustc_abi::{FIRST_VARIANT, FieldIdx, VariantIdx};
use rustc_errors::{ErrorGuaranteed, MultiSpan};
use rustc_hir as hir;
use rustc_hir::LangItem;
@@ -1441,23 +1441,7 @@ impl<'tcx> Ty<'tcx> {
#[tracing::instrument(level = "trace", skip(tcx))]
pub fn fn_sig(self, tcx: TyCtxt<'tcx>) -> PolyFnSig<'tcx> {
- match self.kind() {
- FnDef(def_id, args) => tcx.fn_sig(*def_id).instantiate(tcx, args),
- FnPtr(sig_tys, hdr) => sig_tys.with(*hdr),
- Error(_) => {
- // ignore errors (#54954)
- Binder::dummy(ty::FnSig {
- inputs_and_output: ty::List::empty(),
- c_variadic: false,
- safety: hir::Safety::Safe,
- abi: ExternAbi::Rust,
- })
- }
- Closure(..) => bug!(
- "to get the signature of a closure, use `args.as_closure().sig()` not `fn_sig()`",
- ),
- _ => bug!("Ty::fn_sig() called on non-fn type: {:?}", self),
- }
+ self.kind().fn_sig(tcx)
}
#[inline]
@@ -2043,32 +2027,7 @@ impl<'tcx> Ty<'tcx> {
/// nested types may be further simplified, the outermost [`TyKind`] or
/// type constructor remains the same.
pub fn is_known_rigid(self) -> bool {
- match self.kind() {
- Bool
- | Char
- | Int(_)
- | Uint(_)
- | Float(_)
- | Adt(_, _)
- | Foreign(_)
- | Str
- | Array(_, _)
- | Pat(_, _)
- | Slice(_)
- | RawPtr(_, _)
- | Ref(_, _, _)
- | FnDef(_, _)
- | FnPtr(..)
- | Dynamic(_, _, _)
- | Closure(_, _)
- | CoroutineClosure(_, _)
- | Coroutine(_, _)
- | CoroutineWitness(..)
- | Never
- | Tuple(_)
- | UnsafeBinder(_) => true,
- Error(_) | Infer(_) | Alias(_, _) | Param(_) | Bound(_, _) | Placeholder(_) => false,
- }
+ self.kind().is_known_rigid()
}
}
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index d4134bdf3a782..59c2d3c2fc8d9 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -146,67 +146,14 @@ pub trait Ty<I: Interner<Ty = Self>>:
fn has_unsafe_fields(self) -> bool;
fn fn_sig(self, interner: I) -> ty::Binder<I, ty::FnSig<I>> {
- match self.kind() {
- ty::FnPtr(sig_tys, hdr) => sig_tys.with(hdr),
- ty::FnDef(def_id, args) => interner.fn_sig(def_id).instantiate(interner, args),
- ty::Error(_) => {
- // ignore errors (#54954)
- ty::Binder::dummy(ty::FnSig {
- inputs_and_output: Default::default(),
- c_variadic: false,
- safety: I::Safety::safe(),
- abi: I::Abi::rust(),
- })
- }
- ty::Closure(..) => panic!(
- "to get the signature of a closure, use `args.as_closure().sig()` not `fn_sig()`",
- ),
- _ => panic!("Ty::fn_sig() called on non-fn type: {:?}", self),
- }
+ self.kind().fn_sig(interner)
}
fn discriminant_ty(self, interner: I) -> I::Ty;
fn async_destructor_ty(self, interner: I) -> I::Ty;
-
- /// Returns `true` when the outermost type cannot be further normalized,
- /// resolved, or instantiated. This includes all primitive types, but also
- /// things like ADTs and trait objects, since even if their arguments or
- /// nested types may be further simplified, the outermost [`ty::TyKind`] or
- /// type constructor remains the same.
fn is_known_rigid(self) -> bool {
- match self.kind() {
- ty::Bool
- | ty::Char
- | ty::Int(_)
- | ty::Uint(_)
- | ty::Float(_)
- | ty::Adt(_, _)
- | ty::Foreign(_)
- | ty::Str
- | ty::Array(_, _)
- | ty::Pat(_, _)
- | ty::Slice(_)
- | ty::RawPtr(_, _)
- | ty::Ref(_, _, _)
- | ty::FnDef(_, _)
- | ty::FnPtr(..)
- | ty::UnsafeBinder(_)
- | ty::Dynamic(_, _, _)
- | ty::Closure(_, _)
- | ty::CoroutineClosure(_, _)
- | ty::Coroutine(_, _)
- | ty::CoroutineWitness(..)
- | ty::Never
- | ty::Tuple(_) => true,
-
- ty::Error(_)
- | ty::Infer(_)
- | ty::Alias(_, _)
- | ty::Param(_)
- | ty::Bound(_, _)
- | ty::Placeholder(_) => false,
- }
+ self.kind().is_known_rigid()
}
}
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 9bea4482b550c..d35b22d517c52 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -273,6 +273,68 @@ pub enum TyKind<I: Interner> {
Error(I::ErrorGuaranteed),
}
+impl<I: Interner> TyKind<I> {
+ pub fn fn_sig(self, interner: I) -> ty::Binder<I, ty::FnSig<I>> {
+ match self {
+ ty::FnPtr(sig_tys, hdr) => sig_tys.with(hdr),
+ ty::FnDef(def_id, args) => interner.fn_sig(def_id).instantiate(interner, args),
+ ty::Error(_) => {
+ // ignore errors (#54954)
+ ty::Binder::dummy(ty::FnSig {
+ inputs_and_output: Default::default(),
+ c_variadic: false,
+ safety: I::Safety::safe(),
+ abi: I::Abi::rust(),
+ })
+ }
+ ty::Closure(..) => panic!(
+ "to get the signature of a closure, use `args.as_closure().sig()` not `fn_sig()`",
+ ),
+ _ => panic!("Ty::fn_sig() called on non-fn type: {:?}", self),
+ }
+ }
+
+ /// Returns `true` when the outermost type cannot be further normalized,
+ /// resolved, or instantiated. This includes all primitive types, but also
+ /// things like ADTs and trait objects, since even if their arguments or
+ /// nested types may be further simplified, the outermost [`ty::TyKind`] or
+ /// type constructor remains the same.
+ pub fn is_known_rigid(self) -> bool {
+ match self {
+ ty::Bool
+ | ty::Char
+ | ty::Int(_)
+ | ty::Uint(_)
+ | ty::Float(_)
+ | ty::Adt(_, _)
+ | ty::Foreign(_)
+ | ty::Str
+ | ty::Array(_, _)
+ | ty::Pat(_, _)
+ | ty::Slice(_)
+ | ty::RawPtr(_, _)
+ | ty::Ref(_, _, _)
+ | ty::FnDef(_, _)
+ | ty::FnPtr(..)
+ | ty::UnsafeBinder(_)
+ | ty::Dynamic(_, _, _)
+ | ty::Closure(_, _)
+ | ty::CoroutineClosure(_, _)
+ | ty::Coroutine(_, _)
+ | ty::CoroutineWitness(..)
+ | ty::Never
+ | ty::Tuple(_) => true,
+
+ ty::Error(_)
+ | ty::Infer(_)
+ | ty::Alias(_, _)
+ | ty::Param(_)
+ | ty::Bound(_, _)
+ | ty::Placeholder(_) => false,
+ }
+ }
+}
+
// This is manually implemented because a derive would require `I: Debug`
impl<I: Interner> fmt::Debug for TyKind<I> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
From 64b58dd13b06a23d8429a73c225347b4cd3b2c3c Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 3 Apr 2025 18:53:48 +0000
Subject: [PATCH 27/33] Pass correct param-env to error_implies
---
compiler/rustc_infer/src/infer/mod.rs | 3 +-
.../traits/fulfillment_errors.rs | 32 ++++++++++-----
.../src/error_reporting/traits/mod.rs | 28 +++++--------
...onst-param-has-ty-goal-in-error-implies.rs | 41 +++++++++++++++++++
...-param-has-ty-goal-in-error-implies.stderr | 23 +++++++++++
5 files changed, 98 insertions(+), 29 deletions(-)
create mode 100644 tests/ui/const-generics/const-param-has-ty-goal-in-error-implies.rs
create mode 100644 tests/ui/const-generics/const-param-has-ty-goal-in-error-implies.stderr
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index fa8dea064daaa..5fc44b8f356b5 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -27,6 +27,7 @@ use rustc_middle::bug;
use rustc_middle::infer::canonical::{CanonicalQueryInput, CanonicalVarValues};
use rustc_middle::mir::ConstraintCategory;
use rustc_middle::traits::select;
+use rustc_middle::traits::solve::Goal;
use rustc_middle::ty::error::{ExpectedFound, TypeError};
use rustc_middle::ty::{
self, BoundVarReplacerDelegate, ConstVid, FloatVid, GenericArg, GenericArgKind, GenericArgs,
@@ -268,7 +269,7 @@ pub struct InferCtxt<'tcx> {
/// The set of predicates on which errors have been reported, to
/// avoid reporting the same error twice.
pub reported_trait_errors:
- RefCell<FxIndexMap<Span, (Vec<ty::Predicate<'tcx>>, ErrorGuaranteed)>>,
+ RefCell<FxIndexMap<Span, (Vec<Goal<'tcx, ty::Predicate<'tcx>>>, ErrorGuaranteed)>>,
pub reported_signature_mismatch: RefCell<FxHashSet<(Span, Option<Span>)>>,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 73ae5177c4895..bc45fc11e9bbe 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -14,6 +14,7 @@ use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
use rustc_hir::intravisit::Visitor;
use rustc_hir::{self as hir, LangItem, Node};
use rustc_infer::infer::{InferOk, TypeTrace};
+use rustc_infer::traits::solve::Goal;
use rustc_middle::traits::SignatureMismatchData;
use rustc_middle::traits::select::OverflowError;
use rustc_middle::ty::abstract_const::NotConstEvaluatable;
@@ -930,7 +931,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
)) = arg.kind
&& let Node::Pat(pat) = self.tcx.hir_node(*hir_id)
&& let Some((preds, guar)) = self.reported_trait_errors.borrow().get(&pat.span)
- && preds.contains(&obligation.predicate)
+ && preds.contains(&obligation.as_goal())
{
return Err(*guar);
}
@@ -1292,6 +1293,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
fn can_match_trait(
&self,
+ param_env: ty::ParamEnv<'tcx>,
goal: ty::TraitPredicate<'tcx>,
assumption: ty::PolyTraitPredicate<'tcx>,
) -> bool {
@@ -1306,11 +1308,12 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
assumption,
);
- self.can_eq(ty::ParamEnv::empty(), goal.trait_ref, trait_assumption.trait_ref)
+ self.can_eq(param_env, goal.trait_ref, trait_assumption.trait_ref)
}
fn can_match_projection(
&self,
+ param_env: ty::ParamEnv<'tcx>,
goal: ty::ProjectionPredicate<'tcx>,
assumption: ty::PolyProjectionPredicate<'tcx>,
) -> bool {
@@ -1320,7 +1323,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
assumption,
);
- let param_env = ty::ParamEnv::empty();
self.can_eq(param_env, goal.projection_term, assumption.projection_term)
&& self.can_eq(param_env, goal.term, assumption.term)
}
@@ -1330,24 +1332,32 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
#[instrument(level = "debug", skip(self), ret)]
pub(super) fn error_implies(
&self,
- cond: ty::Predicate<'tcx>,
- error: ty::Predicate<'tcx>,
+ cond: Goal<'tcx, ty::Predicate<'tcx>>,
+ error: Goal<'tcx, ty::Predicate<'tcx>>,
) -> bool {
if cond == error {
return true;
}
- if let Some(error) = error.as_trait_clause() {
+ // FIXME: We could be smarter about this, i.e. if cond's param-env is a
+ // subset of error's param-env. This only matters when binders will carry
+ // predicates though, and obviously only matters for error reporting.
+ if cond.param_env != error.param_env {
+ return false;
+ }
+ let param_env = error.param_env;
+
+ if let Some(error) = error.predicate.as_trait_clause() {
self.enter_forall(error, |error| {
- elaborate(self.tcx, std::iter::once(cond))
+ elaborate(self.tcx, std::iter::once(cond.predicate))
.filter_map(|implied| implied.as_trait_clause())
- .any(|implied| self.can_match_trait(error, implied))
+ .any(|implied| self.can_match_trait(param_env, error, implied))
})
- } else if let Some(error) = error.as_projection_clause() {
+ } else if let Some(error) = error.predicate.as_projection_clause() {
self.enter_forall(error, |error| {
- elaborate(self.tcx, std::iter::once(cond))
+ elaborate(self.tcx, std::iter::once(cond.predicate))
.filter_map(|implied| implied.as_projection_clause())
- .any(|implied| self.can_match_projection(error, implied))
+ .any(|implied| self.can_match_projection(param_env, error, implied))
})
} else {
false
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
index efee6e2aa1d45..8ff7030717a8b 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
@@ -12,6 +12,7 @@ use rustc_errors::{Applicability, Diag, E0038, E0276, MultiSpan, struct_span_cod
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::intravisit::Visitor;
use rustc_hir::{self as hir, AmbigArg, LangItem};
+use rustc_infer::traits::solve::Goal;
use rustc_infer::traits::{
DynCompatibilityViolation, Obligation, ObligationCause, ObligationCauseCode,
PredicateObligation, SelectionError,
@@ -144,7 +145,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
#[derive(Debug)]
struct ErrorDescriptor<'tcx> {
- predicate: ty::Predicate<'tcx>,
+ goal: Goal<'tcx, ty::Predicate<'tcx>>,
index: Option<usize>, // None if this is an old error
}
@@ -152,15 +153,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
.reported_trait_errors
.borrow()
.iter()
- .map(|(&span, predicates)| {
- (
- span,
- predicates
- .0
- .iter()
- .map(|&predicate| ErrorDescriptor { predicate, index: None })
- .collect(),
- )
+ .map(|(&span, goals)| {
+ (span, goals.0.iter().map(|&goal| ErrorDescriptor { goal, index: None }).collect())
})
.collect();
@@ -186,10 +180,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
span = expn_data.call_site;
}
- error_map.entry(span).or_default().push(ErrorDescriptor {
- predicate: error.obligation.predicate,
- index: Some(index),
- });
+ error_map
+ .entry(span)
+ .or_default()
+ .push(ErrorDescriptor { goal: error.obligation.as_goal(), index: Some(index) });
}
// We do this in 2 passes because we want to display errors in order, though
@@ -210,9 +204,9 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
continue;
}
- if self.error_implies(error2.predicate, error.predicate)
+ if self.error_implies(error2.goal, error.goal)
&& !(error2.index >= error.index
- && self.error_implies(error.predicate, error2.predicate))
+ && self.error_implies(error.goal, error2.goal))
{
info!("skipping {:?} (implied by {:?})", error, error2);
is_suppressed[index] = true;
@@ -243,7 +237,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
.entry(span)
.or_insert_with(|| (vec![], guar))
.0
- .push(error.obligation.predicate);
+ .push(error.obligation.as_goal());
}
}
}
diff --git a/tests/ui/const-generics/const-param-has-ty-goal-in-error-implies.rs b/tests/ui/const-generics/const-param-has-ty-goal-in-error-implies.rs
new file mode 100644
index 0000000000000..231bb5252de1a
--- /dev/null
+++ b/tests/ui/const-generics/const-param-has-ty-goal-in-error-implies.rs
@@ -0,0 +1,41 @@
+// compile-flags: -Znext-solver
+
+// Test for a weird diagnostics corner case. In the error reporting code, when reporting
+// fulfillment errors for goals A and B, we try to see if elaborating A will result in
+// another goal that can equate with B. That would signal that B is "implied by" A,
+// allowing us to skip reporting it, which is beneficial for cutting down on the number
+// of diagnostics we report. In the new trait solver especially, but even in the old trait
+// solver through things like defining opaque type usages, this `can_equate` call was not
+// properly taking the param-env of the goals, resulting in nested obligations that had
+// empty param-envs. If one of these nested obligations was a `ConstParamHasTy` goal, then
+// we would ICE, since those goals are particularly strict about the param-env they're
+// evaluated in.
+
+// This is morally a fix for <https://github.com/rust-lang/rust/issues/139314>, but that
+// repro uses details about how defining usages in the `check_opaque_well_formed` code
+// can spring out of type equality, and will likely stop failing soon coincidentally once
+// we start using `PostBorrowck` mode in that check.
+
+trait Foo: Baz<()> {}
+trait Baz<T> {}
+
+trait IdentityWithConstArgGoal<const N: usize> {
+ type Assoc;
+}
+impl<T, const N: usize> IdentityWithConstArgGoal<N> for T {
+ type Assoc = T;
+}
+
+fn unsatisfied<T, const N: usize>()
+where
+ T: Foo,
+ T: Baz<<T as IdentityWithConstArgGoal<N>>::Assoc>,
+{
+}
+
+fn test<const N: usize>() {
+ unsatisfied::<(), N>();
+ //~^ ERROR the trait bound `(): Foo` is not satisfied
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/const-param-has-ty-goal-in-error-implies.stderr b/tests/ui/const-generics/const-param-has-ty-goal-in-error-implies.stderr
new file mode 100644
index 0000000000000..77bba4945523a
--- /dev/null
+++ b/tests/ui/const-generics/const-param-has-ty-goal-in-error-implies.stderr
@@ -0,0 +1,23 @@
+error[E0277]: the trait bound `(): Foo` is not satisfied
+ --> $DIR/const-param-has-ty-goal-in-error-implies.rs:37:19
+ |
+LL | unsatisfied::<(), N>();
+ | ^^ the trait `Foo` is not implemented for `()`
+ |
+help: this trait has no implementations, consider adding one
+ --> $DIR/const-param-has-ty-goal-in-error-implies.rs:19:1
+ |
+LL | trait Foo: Baz<()> {}
+ | ^^^^^^^^^^^^^^^^^^
+note: required by a bound in `unsatisfied`
+ --> $DIR/const-param-has-ty-goal-in-error-implies.rs:31:8
+ |
+LL | fn unsatisfied<T, const N: usize>()
+ | ----------- required by a bound in this function
+LL | where
+LL | T: Foo,
+ | ^^^ required by this bound in `unsatisfied`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
From 087ffd73bf43671db22087570c97e0afdde20f31 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Thu, 3 Apr 2025 17:19:11 -0400
Subject: [PATCH 28/33] add the autodiff batch mode frontend
---
.../rustc_ast/src/expand/autodiff_attrs.rs | 13 +
compiler/rustc_builtin_macros/messages.ftl | 1 +
compiler/rustc_builtin_macros/src/autodiff.rs | 339 +++++++++++-------
compiler/rustc_builtin_macros/src/errors.rs | 8 +
.../rustc_codegen_ssa/src/codegen_attrs.rs | 2 +-
5 files changed, 236 insertions(+), 127 deletions(-)
diff --git a/compiler/rustc_ast/src/expand/autodiff_attrs.rs b/compiler/rustc_ast/src/expand/autodiff_attrs.rs
index c8ec185ee5e29..f01c781f46c65 100644
--- a/compiler/rustc_ast/src/expand/autodiff_attrs.rs
+++ b/compiler/rustc_ast/src/expand/autodiff_attrs.rs
@@ -77,6 +77,17 @@ pub struct AutoDiffAttrs {
/// e.g. in the [JAX
/// Documentation](https://jax.readthedocs.io/en/latest/_tutorials/advanced-autodiff.html#how-it-s-made-two-foundational-autodiff-functions).
pub mode: DiffMode,
+ /// A user-provided, batching width. If not given, we will default to 1 (no batching).
+ /// Calling a differentiated, non-batched function through a loop 100 times is equivalent to:
+ /// - Calling the function 50 times with a batch size of 2
+ /// - Calling the function 25 times with a batch size of 4,
+ /// etc. A batched function takes more (or longer) arguments, and might be able to benefit from
+ /// cache locality, better re-usal of primal values, and other optimizations.
+ /// We will (before LLVM's vectorizer runs) just generate most LLVM-IR instructions `width`
+ /// times, so this massively increases code size. As such, values like 1024 are unlikely to
+ /// work. We should consider limiting this to u8 or u16, but will leave it at u32 for
+ /// experiments for now and focus on documenting the implications of a large width.
+ pub width: u32,
pub ret_activity: DiffActivity,
pub input_activity: Vec<DiffActivity>,
}
@@ -222,6 +233,7 @@ impl AutoDiffAttrs {
pub const fn error() -> Self {
AutoDiffAttrs {
mode: DiffMode::Error,
+ width: 0,
ret_activity: DiffActivity::None,
input_activity: Vec::new(),
}
@@ -229,6 +241,7 @@ impl AutoDiffAttrs {
pub fn source() -> Self {
AutoDiffAttrs {
mode: DiffMode::Source,
+ width: 0,
ret_activity: DiffActivity::None,
input_activity: Vec::new(),
}
diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
index 3f03834f8d781..603dc90bafca2 100644
--- a/compiler/rustc_builtin_macros/messages.ftl
+++ b/compiler/rustc_builtin_macros/messages.ftl
@@ -79,6 +79,7 @@ builtin_macros_autodiff_ret_activity = invalid return activity {$act} in {$mode}
builtin_macros_autodiff_ty_activity = {$act} can not be used for this type
builtin_macros_autodiff_unknown_activity = did not recognize Activity: `{$act}`
+builtin_macros_autodiff_width = autodiff width must fit u32, but is {$width}
builtin_macros_bad_derive_target = `derive` may only be applied to `struct`s, `enum`s and `union`s
.label = not applicable here
.label2 = not a `struct`, `enum` or `union`
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index 6591ed151cf6e..032ab82e9892a 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -12,12 +12,12 @@ mod llvm_enzyme {
valid_ty_for_activity,
};
use rustc_ast::ptr::P;
- use rustc_ast::token::{Token, TokenKind};
+ use rustc_ast::token::{Lit, LitKind, Token, TokenKind};
use rustc_ast::tokenstream::*;
use rustc_ast::visit::AssocCtxt::*;
use rustc_ast::{
- self as ast, AssocItemKind, BindingMode, FnRetTy, FnSig, Generics, ItemKind, MetaItemInner,
- PatKind, TyKind,
+ self as ast, AssocItemKind, BindingMode, ExprKind, FnRetTy, FnSig, Generics, ItemKind,
+ MetaItemInner, PatKind, QSelf, TyKind,
};
use rustc_expand::base::{Annotatable, ExtCtxt};
use rustc_span::{Ident, Span, Symbol, kw, sym};
@@ -45,6 +45,16 @@ mod llvm_enzyme {
}
}
fn first_ident(x: &MetaItemInner) -> rustc_span::Ident {
+ if let Some(l) = x.lit() {
+ match l.kind {
+ ast::LitKind::Int(val, _) => {
+ // get an Ident from a lit
+ return rustc_span::Ident::from_str(val.get().to_string().as_str());
+ }
+ _ => {}
+ }
+ }
+
let segments = &x.meta_item().unwrap().path.segments;
assert!(segments.len() == 1);
segments[0].ident
@@ -54,6 +64,14 @@ mod llvm_enzyme {
first_ident(x).name.to_string()
}
+ fn width(x: &MetaItemInner) -> Option<u128> {
+ let lit = x.lit()?;
+ match lit.kind {
+ ast::LitKind::Int(x, _) => Some(x.get()),
+ _ => return None,
+ }
+ }
+
pub(crate) fn from_ast(
ecx: &mut ExtCtxt<'_>,
meta_item: &ThinVec<MetaItemInner>,
@@ -65,9 +83,32 @@ mod llvm_enzyme {
dcx.emit_err(errors::AutoDiffInvalidMode { span: meta_item[1].span(), mode });
return AutoDiffAttrs::error();
};
+
+ // Now we check, whether the user wants autodiff in batch/vector mode, or scalar mode.
+ // If he doesn't specify an integer (=width), we default to scalar mode, thus width=1.
+ let mut first_activity = 2;
+
+ let width = if let [_, _, x, ..] = &meta_item[..]
+ && let Some(x) = width(x)
+ {
+ first_activity = 3;
+ match x.try_into() {
+ Ok(x) => x,
+ Err(_) => {
+ dcx.emit_err(errors::AutoDiffInvalidWidth {
+ span: meta_item[2].span(),
+ width: x,
+ });
+ return AutoDiffAttrs::error();
+ }
+ }
+ } else {
+ 1
+ };
+
let mut activities: Vec<DiffActivity> = vec![];
let mut errors = false;
- for x in &meta_item[2..] {
+ for x in &meta_item[first_activity..] {
let activity_str = name(&x);
let res = DiffActivity::from_str(&activity_str);
match res {
@@ -98,7 +139,20 @@ mod llvm_enzyme {
(&DiffActivity::None, activities.as_slice())
};
- AutoDiffAttrs { mode, ret_activity: *ret_activity, input_activity: input_activity.to_vec() }
+ AutoDiffAttrs {
+ mode,
+ width,
+ ret_activity: *ret_activity,
+ input_activity: input_activity.to_vec(),
+ }
+ }
+
+ fn meta_item_inner_to_ts(t: &MetaItemInner, ts: &mut Vec<TokenTree>) {
+ let comma: Token = Token::new(TokenKind::Comma, Span::default());
+ let val = first_ident(t);
+ let t = Token::from_ast_ident(val);
+ ts.push(TokenTree::Token(t, Spacing::Joint));
+ ts.push(TokenTree::Token(comma.clone(), Spacing::Alone));
}
/// We expand the autodiff macro to generate a new placeholder function which passes
@@ -197,27 +251,49 @@ mod llvm_enzyme {
// create TokenStream from vec elemtents:
// meta_item doesn't have a .tokens field
- let comma: Token = Token::new(TokenKind::Comma, Span::default());
let mut ts: Vec<TokenTree> = vec![];
if meta_item_vec.len() < 2 {
// At the bare minimum, we need a fnc name and a mode, even for a dummy function with no
// input and output args.
dcx.emit_err(errors::AutoDiffMissingConfig { span: item.span() });
return vec![item];
+ }
+
+ meta_item_inner_to_ts(&meta_item_vec[1], &mut ts);
+
+ // Now, if the user gave a width (vector aka batch-mode ad), then we copy it.
+ // If it is not given, we default to 1 (scalar mode).
+ let start_position;
+ let kind: LitKind = LitKind::Integer;
+ let symbol;
+ if meta_item_vec.len() >= 3
+ && let Some(width) = width(&meta_item_vec[2])
+ {
+ start_position = 3;
+ symbol = Symbol::intern(&width.to_string());
} else {
- for t in meta_item_vec.clone()[1..].iter() {
- let val = first_ident(t);
- let t = Token::from_ast_ident(val);
- ts.push(TokenTree::Token(t, Spacing::Joint));
- ts.push(TokenTree::Token(comma.clone(), Spacing::Alone));
- }
+ start_position = 2;
+ symbol = sym::integer(1);
}
+ let l: Lit = Lit { kind, symbol, suffix: None };
+ let t = Token::new(TokenKind::Literal(l), Span::default());
+ let comma = Token::new(TokenKind::Comma, Span::default());
+ ts.push(TokenTree::Token(t, Spacing::Joint));
+ ts.push(TokenTree::Token(comma.clone(), Spacing::Alone));
+
+ for t in meta_item_vec.clone()[start_position..].iter() {
+ meta_item_inner_to_ts(t, &mut ts);
+ }
+
if !has_ret {
// We don't want users to provide a return activity if the function doesn't return anything.
// For simplicity, we just add a dummy token to the end of the list.
let t = Token::new(TokenKind::Ident(sym::None, false.into()), Span::default());
ts.push(TokenTree::Token(t, Spacing::Joint));
+ ts.push(TokenTree::Token(comma, Spacing::Alone));
}
+ // We remove the last, trailing comma.
+ ts.pop();
let ts: TokenStream = TokenStream::from_iter(ts);
let x: AutoDiffAttrs = from_ast(ecx, &meta_item_vec, has_ret);
@@ -475,6 +551,8 @@ mod llvm_enzyme {
return body;
}
+ // Everything from here onwards just tries to fullfil the return type. Fun!
+
// having an active-only return means we'll drop the original return type.
// So that can be treated identical to not having one in the first place.
let primal_ret = has_ret(&sig.decl.output) && !x.has_active_only_ret();
@@ -502,86 +580,65 @@ mod llvm_enzyme {
return body;
}
- let mut exprs = ThinVec::<P<ast::Expr>>::new();
- if primal_ret {
- // We have both primal ret and active floats.
- // primal ret is first, by construction.
- exprs.push(primal_call);
- }
-
- // Now construct default placeholder for each active float.
- // Is there something nicer than f32::default() and f64::default()?
+ let mut exprs: P<ast::Expr> = primal_call.clone();
let d_ret_ty = match d_sig.decl.output {
FnRetTy::Ty(ref ty) => ty.clone(),
FnRetTy::Default(span) => {
panic!("Did not expect Default ret ty: {:?}", span);
}
};
- let mut d_ret_ty = match d_ret_ty.kind.clone() {
- TyKind::Tup(ref tys) => tys.clone(),
- TyKind::Path(_, rustc_ast::Path { segments, .. }) => {
- if let [segment] = &segments[..]
- && segment.args.is_none()
- {
- let id = vec![segments[0].ident];
- let kind = TyKind::Path(None, ecx.path(span, id));
- let ty = P(rustc_ast::Ty { kind, id: ast::DUMMY_NODE_ID, span, tokens: None });
- thin_vec![ty]
- } else {
- panic!("Expected tuple or simple path return type");
- }
- }
- _ => {
- // We messed up construction of d_sig
- panic!("Did not expect non-tuple ret ty: {:?}", d_ret_ty);
- }
- };
-
- if x.mode.is_fwd() && x.ret_activity == DiffActivity::Dual {
- assert!(d_ret_ty.len() == 2);
- // both should be identical, by construction
- let arg = d_ret_ty[0].kind.is_simple_path().unwrap();
- let arg2 = d_ret_ty[1].kind.is_simple_path().unwrap();
- assert!(arg == arg2);
- let sl: Vec<Symbol> = vec![arg, kw::Default];
- let tmp = ecx.def_site_path(&sl);
- let default_call_expr = ecx.expr_path(ecx.path(span, tmp));
- let default_call_expr = ecx.expr_call(new_decl_span, default_call_expr, thin_vec![]);
- exprs.push(default_call_expr);
- } else if x.mode.is_rev() {
- if primal_ret {
- // We have extra handling above for the primal ret
- d_ret_ty = d_ret_ty[1..].to_vec().into();
- }
- for arg in d_ret_ty.iter() {
- let arg = arg.kind.is_simple_path().unwrap();
- let sl: Vec<Symbol> = vec![arg, kw::Default];
- let tmp = ecx.def_site_path(&sl);
- let default_call_expr = ecx.expr_path(ecx.path(span, tmp));
+ if x.mode.is_fwd() {
+ // Fwd mode is easy. If the return activity is Const, we support arbitrary types.
+ // Otherwise, we only support a scalar, a pair of scalars, or an array of scalars.
+ // We checked that (on a best-effort base) in the preceding gen_enzyme_decl function.
+ // In all three cases, we can return `std::hint::black_box(<T>::default())`.
+ if x.ret_activity == DiffActivity::Const {
+ // Here we call the primal function, since our dummy function has the same return
+ // type due to the Const return activity.
+ exprs = ecx.expr_call(new_decl_span, bb_call_expr, thin_vec![exprs]);
+ } else {
+ let q = QSelf { ty: d_ret_ty.clone(), path_span: span, position: 0 };
+ let y =
+ ExprKind::Path(Some(P(q)), ecx.path_ident(span, Ident::from_str("default")));
+ let default_call_expr = ecx.expr(span, y);
let default_call_expr =
ecx.expr_call(new_decl_span, default_call_expr, thin_vec![]);
- exprs.push(default_call_expr);
- }
- }
-
- let ret: P<ast::Expr>;
- match &exprs[..] {
- [] => {
- assert!(!has_ret(&d_sig.decl.output));
- // We don't have to match the return type.
- return body;
- }
- [arg] => {
- ret = ecx.expr_call(new_decl_span, bb_call_expr, thin_vec![arg.clone()]);
+ exprs = ecx.expr_call(new_decl_span, bb_call_expr, thin_vec![default_call_expr]);
}
- args => {
- let ret_tuple: P<ast::Expr> = ecx.expr_tuple(span, args.into());
- ret = ecx.expr_call(new_decl_span, bb_call_expr, thin_vec![ret_tuple]);
+ } else if x.mode.is_rev() {
+ if x.width == 1 {
+ // We either have `-> ArbitraryType` or `-> (ArbitraryType, repeated_float_scalars)`.
+ match d_ret_ty.kind {
+ TyKind::Tup(ref args) => {
+ // We have a tuple return type. We need to create a tuple of the same size
+ // and fill it with default values.
+ let mut exprs2 = thin_vec![exprs];
+ for arg in args.iter().skip(1) {
+ let arg = arg.kind.is_simple_path().unwrap();
+ let sl: Vec<Symbol> = vec![arg, kw::Default];
+ let tmp = ecx.def_site_path(&sl);
+ let default_call_expr = ecx.expr_path(ecx.path(span, tmp));
+ let default_call_expr =
+ ecx.expr_call(new_decl_span, default_call_expr, thin_vec![]);
+ exprs2.push(default_call_expr);
+ }
+ exprs = ecx.expr_tuple(new_decl_span, exprs2);
+ }
+ _ => {
+ // Interestingly, even the `-> ArbitraryType` case
+ // ends up getting matched and handled correctly above,
+ // so we don't have to handle any other case for now.
+ panic!("Unsupported return type: {:?}", d_ret_ty);
+ }
+ }
}
+ exprs = ecx.expr_call(new_decl_span, bb_call_expr, thin_vec![exprs]);
+ } else {
+ unreachable!("Unsupported mode: {:?}", x.mode);
}
- assert!(has_ret(&d_sig.decl.output));
- body.stmts.push(ecx.stmt_expr(ret));
+
+ body.stmts.push(ecx.stmt_expr(exprs));
body
}
@@ -689,50 +746,55 @@ mod llvm_enzyme {
match activity {
DiffActivity::Active => {
act_ret.push(arg.ty.clone());
+ // if width =/= 1, then push [arg.ty; width] to act_ret
}
DiffActivity::ActiveOnly => {
// We will add the active scalar to the return type.
// This is handled later.
}
DiffActivity::Duplicated | DiffActivity::DuplicatedOnly => {
- let mut shadow_arg = arg.clone();
- // We += into the shadow in reverse mode.
- shadow_arg.ty = P(assure_mut_ref(&arg.ty));
- let old_name = if let PatKind::Ident(_, ident, _) = arg.pat.kind {
- ident.name
- } else {
- debug!("{:#?}", &shadow_arg.pat);
- panic!("not an ident?");
- };
- let name: String = format!("d{}", old_name);
- new_inputs.push(name.clone());
- let ident = Ident::from_str_and_span(&name, shadow_arg.pat.span);
- shadow_arg.pat = P(ast::Pat {
- id: ast::DUMMY_NODE_ID,
- kind: PatKind::Ident(BindingMode::NONE, ident, None),
- span: shadow_arg.pat.span,
- tokens: shadow_arg.pat.tokens.clone(),
- });
- d_inputs.push(shadow_arg);
+ for i in 0..x.width {
+ let mut shadow_arg = arg.clone();
+ // We += into the shadow in reverse mode.
+ shadow_arg.ty = P(assure_mut_ref(&arg.ty));
+ let old_name = if let PatKind::Ident(_, ident, _) = arg.pat.kind {
+ ident.name
+ } else {
+ debug!("{:#?}", &shadow_arg.pat);
+ panic!("not an ident?");
+ };
+ let name: String = format!("d{}_{}", old_name, i);
+ new_inputs.push(name.clone());
+ let ident = Ident::from_str_and_span(&name, shadow_arg.pat.span);
+ shadow_arg.pat = P(ast::Pat {
+ id: ast::DUMMY_NODE_ID,
+ kind: PatKind::Ident(BindingMode::NONE, ident, None),
+ span: shadow_arg.pat.span,
+ tokens: shadow_arg.pat.tokens.clone(),
+ });
+ d_inputs.push(shadow_arg.clone());
+ }
}
DiffActivity::Dual | DiffActivity::DualOnly => {
- let mut shadow_arg = arg.clone();
- let old_name = if let PatKind::Ident(_, ident, _) = arg.pat.kind {
- ident.name
- } else {
- debug!("{:#?}", &shadow_arg.pat);
- panic!("not an ident?");
- };
- let name: String = format!("b{}", old_name);
- new_inputs.push(name.clone());
- let ident = Ident::from_str_and_span(&name, shadow_arg.pat.span);
- shadow_arg.pat = P(ast::Pat {
- id: ast::DUMMY_NODE_ID,
- kind: PatKind::Ident(BindingMode::NONE, ident, None),
- span: shadow_arg.pat.span,
- tokens: shadow_arg.pat.tokens.clone(),
- });
- d_inputs.push(shadow_arg);
+ for i in 0..x.width {
+ let mut shadow_arg = arg.clone();
+ let old_name = if let PatKind::Ident(_, ident, _) = arg.pat.kind {
+ ident.name
+ } else {
+ debug!("{:#?}", &shadow_arg.pat);
+ panic!("not an ident?");
+ };
+ let name: String = format!("b{}_{}", old_name, i);
+ new_inputs.push(name.clone());
+ let ident = Ident::from_str_and_span(&name, shadow_arg.pat.span);
+ shadow_arg.pat = P(ast::Pat {
+ id: ast::DUMMY_NODE_ID,
+ kind: PatKind::Ident(BindingMode::NONE, ident, None),
+ span: shadow_arg.pat.span,
+ tokens: shadow_arg.pat.tokens.clone(),
+ });
+ d_inputs.push(shadow_arg.clone());
+ }
}
DiffActivity::Const => {
// Nothing to do here.
@@ -788,23 +850,48 @@ mod llvm_enzyme {
d_decl.inputs = d_inputs.into();
if x.mode.is_fwd() {
+ let ty = match d_decl.output {
+ FnRetTy::Ty(ref ty) => ty.clone(),
+ FnRetTy::Default(span) => {
+ // We want to return std::hint::black_box(()).
+ let kind = TyKind::Tup(ThinVec::new());
+ let ty = P(rustc_ast::Ty { kind, id: ast::DUMMY_NODE_ID, span, tokens: None });
+ d_decl.output = FnRetTy::Ty(ty.clone());
+ assert!(matches!(x.ret_activity, DiffActivity::None));
+ // this won't be used below, so any type would be fine.
+ ty
+ }
+ };
+
if let DiffActivity::Dual = x.ret_activity {
- let ty = match d_decl.output {
- FnRetTy::Ty(ref ty) => ty.clone(),
- FnRetTy::Default(span) => {
- panic!("Did not expect Default ret ty: {:?}", span);
- }
+ let kind = if x.width == 1 {
+ // Dual can only be used for f32/f64 ret.
+ // In that case we return now a tuple with two floats.
+ TyKind::Tup(thin_vec![ty.clone(), ty.clone()])
+ } else {
+ // We have to return [T; width+1], +1 for the primal return.
+ let anon_const = rustc_ast::AnonConst {
+ id: ast::DUMMY_NODE_ID,
+ value: ecx.expr_usize(span, 1 + x.width as usize),
+ };
+ TyKind::Array(ty.clone(), anon_const)
};
- // Dual can only be used for f32/f64 ret.
- // In that case we return now a tuple with two floats.
- let kind = TyKind::Tup(thin_vec![ty.clone(), ty.clone()]);
let ty = P(rustc_ast::Ty { kind, id: ty.id, span: ty.span, tokens: None });
d_decl.output = FnRetTy::Ty(ty);
}
if let DiffActivity::DualOnly = x.ret_activity {
// No need to change the return type,
- // we will just return the shadow in place
- // of the primal return.
+ // we will just return the shadow in place of the primal return.
+ // However, if we have a width > 1, then we don't return -> T, but -> [T; width]
+ if x.width > 1 {
+ let anon_const = rustc_ast::AnonConst {
+ id: ast::DUMMY_NODE_ID,
+ value: ecx.expr_usize(span, x.width as usize),
+ };
+ let kind = TyKind::Array(ty.clone(), anon_const);
+ let ty = P(rustc_ast::Ty { kind, id: ty.id, span: ty.span, tokens: None });
+ d_decl.output = FnRetTy::Ty(ty);
+ }
}
}
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
index 30597944124cb..4bbe212f4296c 100644
--- a/compiler/rustc_builtin_macros/src/errors.rs
+++ b/compiler/rustc_builtin_macros/src/errors.rs
@@ -202,6 +202,14 @@ mod autodiff {
pub(crate) mode: String,
}
+ #[derive(Diagnostic)]
+ #[diag(builtin_macros_autodiff_width)]
+ pub(crate) struct AutoDiffInvalidWidth {
+ #[primary_span]
+ pub(crate) span: Span,
+ pub(crate) width: u128,
+ }
+
#[derive(Diagnostic)]
#[diag(builtin_macros_autodiff)]
pub(crate) struct AutoDiffInvalidApplication {
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index d16d4ed228389..4b2fd61442bde 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -860,7 +860,7 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
}
}
- Some(AutoDiffAttrs { mode, ret_activity, input_activity: arg_activities })
+ Some(AutoDiffAttrs { mode, width: 1, ret_activity, input_activity: arg_activities })
}
pub(crate) fn provide(providers: &mut Providers) {
From e0c8ead8802fcc314ec852a6641e08fd09307708 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Thu, 3 Apr 2025 17:21:21 -0400
Subject: [PATCH 29/33] add autodiff batching middle-end
---
.../rustc_codegen_ssa/src/codegen_attrs.rs | 32 ++++++++++++++++---
1 file changed, 28 insertions(+), 4 deletions(-)
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 4b2fd61442bde..02f631c7b39bd 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -2,7 +2,7 @@ use std::str::FromStr;
use rustc_abi::ExternAbi;
use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, DiffActivity, DiffMode};
-use rustc_ast::{MetaItem, MetaItemInner, attr};
+use rustc_ast::{LitKind, MetaItem, MetaItemInner, attr};
use rustc_attr_parsing::ReprAttr::ReprAlign;
use rustc_attr_parsing::{AttributeKind, InlineAttr, InstructionSetAttr, OptimizeAttr};
use rustc_data_structures::fx::FxHashMap;
@@ -805,8 +805,8 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
return Some(AutoDiffAttrs::source());
}
- let [mode, input_activities @ .., ret_activity] = &list[..] else {
- span_bug!(attr.span(), "rustc_autodiff attribute must contain mode and activities");
+ let [mode, width_meta, input_activities @ .., ret_activity] = &list[..] else {
+ span_bug!(attr.span(), "rustc_autodiff attribute must contain mode, width and activities");
};
let mode = if let MetaItemInner::MetaItem(MetaItem { path: p1, .. }) = mode {
p1.segments.first().unwrap().ident
@@ -823,6 +823,30 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
}
};
+ let width: u32 = match width_meta {
+ MetaItemInner::MetaItem(MetaItem { path: p1, .. }) => {
+ let w = p1.segments.first().unwrap().ident;
+ match w.as_str().parse() {
+ Ok(val) => val,
+ Err(_) => {
+ span_bug!(w.span, "rustc_autodiff width should fit u32");
+ }
+ }
+ }
+ MetaItemInner::Lit(lit) => {
+ if let LitKind::Int(val, _) = lit.kind {
+ match val.get().try_into() {
+ Ok(val) => val,
+ Err(_) => {
+ span_bug!(lit.span, "rustc_autodiff width should fit u32");
+ }
+ }
+ } else {
+ span_bug!(lit.span, "rustc_autodiff width should be an integer");
+ }
+ }
+ };
+
// First read the ret symbol from the attribute
let ret_symbol = if let MetaItemInner::MetaItem(MetaItem { path: p1, .. }) = ret_activity {
p1.segments.first().unwrap().ident
@@ -860,7 +884,7 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
}
}
- Some(AutoDiffAttrs { mode, width: 1, ret_activity, input_activity: arg_activities })
+ Some(AutoDiffAttrs { mode, width, ret_activity, input_activity: arg_activities })
}
pub(crate) fn provide(providers: &mut Providers) {
From 90d5545e52a40aaa790b0e818eba46d78ae3388d Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Thu, 3 Apr 2025 17:23:01 -0400
Subject: [PATCH 30/33] add autodiff batching backend
---
.../src/builder/autodiff.rs | 199 ++++++++++++++----
compiler/rustc_codegen_llvm/src/consts.rs | 2 +-
compiler/rustc_codegen_llvm/src/context.rs | 23 +-
.../rustc_codegen_llvm/src/llvm/enzyme_ffi.rs | 4 +-
compiler/rustc_codegen_llvm/src/llvm/ffi.rs | 2 +-
.../rustc_llvm/llvm-wrapper/RustWrapper.cpp | 10 +
6 files changed, 196 insertions(+), 44 deletions(-)
diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index 7cd4ee539d875..c6092fba39671 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -3,8 +3,10 @@ use std::ptr;
use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, AutoDiffItem, DiffActivity, DiffMode};
use rustc_codegen_ssa::ModuleCodegen;
use rustc_codegen_ssa::back::write::ModuleConfig;
-use rustc_codegen_ssa::traits::BaseTypeCodegenMethods as _;
+use rustc_codegen_ssa::common::TypeKind;
+use rustc_codegen_ssa::traits::BaseTypeCodegenMethods;
use rustc_errors::FatalError;
+use rustc_middle::bug;
use tracing::{debug, trace};
use crate::back::write::llvm_err;
@@ -18,21 +20,42 @@ use crate::value::Value;
use crate::{CodegenContext, LlvmCodegenBackend, ModuleLlvm, attributes, llvm};
fn get_params(fnc: &Value) -> Vec<&Value> {
+ let param_num = llvm::LLVMCountParams(fnc) as usize;
+ let mut fnc_args: Vec<&Value> = vec![];
+ fnc_args.reserve(param_num);
unsafe {
- let param_num = llvm::LLVMCountParams(fnc) as usize;
- let mut fnc_args: Vec<&Value> = vec![];
- fnc_args.reserve(param_num);
llvm::LLVMGetParams(fnc, fnc_args.as_mut_ptr());
fnc_args.set_len(param_num);
- fnc_args
}
+ fnc_args
}
+fn has_sret(fnc: &Value) -> bool {
+ let num_args = llvm::LLVMCountParams(fnc) as usize;
+ if num_args == 0 {
+ false
+ } else {
+ unsafe { llvm::LLVMRustHasAttributeAtIndex(fnc, 0, llvm::AttributeKind::StructRet) }
+ }
+}
+
+// When we call the `__enzyme_autodiff` or `__enzyme_fwddiff` function, we need to pass all the
+// original inputs, as well as metadata and the additional shadow arguments.
+// This function matches the arguments from the outer function to the inner enzyme call.
+//
+// This function also considers that Rust level arguments not always match the llvm-ir level
+// arguments. A slice, `&[f32]`, for example, is represented as a pointer and a length on
+// llvm-ir level. The number of activities matches the number of Rust level arguments, so we
+// need to match those.
+// FIXME(ZuseZ4): This logic is a bit more complicated than it should be, can we simplify it
+// using iterators and peek()?
fn match_args_from_caller_to_enzyme<'ll>(
cx: &SimpleCx<'ll>,
+ width: u32,
args: &mut Vec<&'ll llvm::Value>,
inputs: &[DiffActivity],
outer_args: &[&'ll llvm::Value],
+ has_sret: bool,
) {
debug!("matching autodiff arguments");
// We now handle the issue that Rust level arguments not always match the llvm-ir level
@@ -44,6 +67,14 @@ fn match_args_from_caller_to_enzyme<'ll>(
let mut outer_pos: usize = 0;
let mut activity_pos = 0;
+ if has_sret {
+ // Then the first outer arg is the sret pointer. Enzyme doesn't know about sret, so the
+ // inner function will still return something. We increase our outer_pos by one,
+ // and once we're done with all other args we will take the return of the inner call and
+ // update the sret pointer with it
+ outer_pos = 1;
+ }
+
let enzyme_const = cx.create_metadata("enzyme_const".to_string()).unwrap();
let enzyme_out = cx.create_metadata("enzyme_out".to_string()).unwrap();
let enzyme_dup = cx.create_metadata("enzyme_dup".to_string()).unwrap();
@@ -92,23 +123,20 @@ fn match_args_from_caller_to_enzyme<'ll>(
// (..., metadata! enzyme_dup, ptr, ptr, int1, ...).
// FIXME(ZuseZ4): We will upstream a safety check later which asserts that
// int2 >= int1, which means the shadow vector is large enough to store the gradient.
- assert!(unsafe {
- llvm::LLVMRustGetTypeKind(next_outer_ty) == llvm::TypeKind::Integer
- });
- let next_outer_arg2 = outer_args[outer_pos + 2];
- let next_outer_ty2 = cx.val_ty(next_outer_arg2);
- assert!(unsafe {
- llvm::LLVMRustGetTypeKind(next_outer_ty2) == llvm::TypeKind::Pointer
- });
- let next_outer_arg3 = outer_args[outer_pos + 3];
- let next_outer_ty3 = cx.val_ty(next_outer_arg3);
- assert!(unsafe {
- llvm::LLVMRustGetTypeKind(next_outer_ty3) == llvm::TypeKind::Integer
- });
- args.push(next_outer_arg2);
+ assert_eq!(cx.type_kind(next_outer_ty), TypeKind::Integer);
+
+ for _ in 0..width {
+ let next_outer_arg2 = outer_args[outer_pos + 2];
+ let next_outer_ty2 = cx.val_ty(next_outer_arg2);
+ assert_eq!(cx.type_kind(next_outer_ty2), TypeKind::Pointer);
+ let next_outer_arg3 = outer_args[outer_pos + 3];
+ let next_outer_ty3 = cx.val_ty(next_outer_arg3);
+ assert_eq!(cx.type_kind(next_outer_ty3), TypeKind::Integer);
+ args.push(next_outer_arg2);
+ }
args.push(cx.get_metadata_value(enzyme_const));
args.push(next_outer_arg);
- outer_pos += 4;
+ outer_pos += 2 + 2 * width as usize;
activity_pos += 2;
} else {
// A duplicated pointer will have the following two outer_fn arguments:
@@ -116,15 +144,19 @@ fn match_args_from_caller_to_enzyme<'ll>(
// (..., metadata! enzyme_dup, ptr, ptr, ...).
if matches!(diff_activity, DiffActivity::Duplicated | DiffActivity::DuplicatedOnly)
{
- assert!(
- unsafe { llvm::LLVMRustGetTypeKind(next_outer_ty) }
- == llvm::TypeKind::Pointer
- );
+ assert_eq!(cx.type_kind(next_outer_ty), TypeKind::Pointer);
}
// In the case of Dual we don't have assumptions, e.g. f32 would be valid.
args.push(next_outer_arg);
outer_pos += 2;
activity_pos += 1;
+
+ // Now, if width > 1, we need to account for that
+ for _ in 1..width {
+ let next_outer_arg = outer_args[outer_pos];
+ args.push(next_outer_arg);
+ outer_pos += 1;
+ }
}
} else {
// We do not differentiate with resprect to this argument.
@@ -135,6 +167,76 @@ fn match_args_from_caller_to_enzyme<'ll>(
}
}
+// On LLVM-IR, we can luckily declare __enzyme_ functions without specifying the input
+// arguments. We do however need to declare them with their correct return type.
+// We already figured the correct return type out in our frontend, when generating the outer_fn,
+// so we can now just go ahead and use that. This is not always trivial, e.g. because sret.
+// Beyond sret, this article describes our challenges nicely:
+// <https://yorickpeterse.com/articles/the-mess-that-is-handling-structure-arguments-and-returns-in-llvm/>
+// I.e. (i32, f32) will get merged into i64, but we don't handle that yet.
+fn compute_enzyme_fn_ty<'ll>(
+ cx: &SimpleCx<'ll>,
+ attrs: &AutoDiffAttrs,
+ fn_to_diff: &'ll Value,
+ outer_fn: &'ll Value,
+) -> &'ll llvm::Type {
+ let fn_ty = cx.get_type_of_global(outer_fn);
+ let mut ret_ty = cx.get_return_type(fn_ty);
+
+ let has_sret = has_sret(outer_fn);
+
+ if has_sret {
+ // Now we don't just forward the return type, so we have to figure it out based on the
+ // primal return type, in combination with the autodiff settings.
+ let fn_ty = cx.get_type_of_global(fn_to_diff);
+ let inner_ret_ty = cx.get_return_type(fn_ty);
+
+ let void_ty = unsafe { llvm::LLVMVoidTypeInContext(cx.llcx) };
+ if inner_ret_ty == void_ty {
+ // This indicates that even the inner function has an sret.
+ // Right now I only look for an sret in the outer function.
+ // This *probably* needs some extra handling, but I never ran
+ // into such a case. So I'll wait for user reports to have a test case.
+ bug!("sret in inner function");
+ }
+
+ if attrs.width == 1 {
+ todo!("Handle sret for scalar ad");
+ } else {
+ // First we check if we also have to deal with the primal return.
+ match attrs.mode {
+ DiffMode::Forward => match attrs.ret_activity {
+ DiffActivity::Dual => {
+ let arr_ty =
+ unsafe { llvm::LLVMArrayType2(inner_ret_ty, attrs.width as u64 + 1) };
+ ret_ty = arr_ty;
+ }
+ DiffActivity::DualOnly => {
+ let arr_ty =
+ unsafe { llvm::LLVMArrayType2(inner_ret_ty, attrs.width as u64) };
+ ret_ty = arr_ty;
+ }
+ DiffActivity::Const => {
+ todo!("Not sure, do we need to do something here?");
+ }
+ _ => {
+ bug!("unreachable");
+ }
+ },
+ DiffMode::Reverse => {
+ todo!("Handle sret for reverse mode");
+ }
+ _ => {
+ bug!("unreachable");
+ }
+ }
+ }
+ }
+
+ // LLVM can figure out the input types on it's own, so we take a shortcut here.
+ unsafe { llvm::LLVMFunctionType(ret_ty, ptr::null(), 0, True) }
+}
+
/// When differentiating `fn_to_diff`, take a `outer_fn` and generate another
/// function with expected naming and calling conventions[^1] which will be
/// discovered by the enzyme LLVM pass and its body populated with the differentiated
@@ -197,17 +299,9 @@ fn generate_enzyme_call<'ll>(
// }
// ```
unsafe {
- // On LLVM-IR, we can luckily declare __enzyme_ functions without specifying the input
- // arguments. We do however need to declare them with their correct return type.
- // We already figured the correct return type out in our frontend, when generating the outer_fn,
- // so we can now just go ahead and use that. FIXME(ZuseZ4): This doesn't handle sret yet.
- let fn_ty = llvm::LLVMGlobalGetValueType(outer_fn);
- let ret_ty = llvm::LLVMGetReturnType(fn_ty);
-
- // LLVM can figure out the input types on it's own, so we take a shortcut here.
- let enzyme_ty = llvm::LLVMFunctionType(ret_ty, ptr::null(), 0, True);
+ let enzyme_ty = compute_enzyme_fn_ty(cx, &attrs, fn_to_diff, outer_fn);
- //FIXME(ZuseZ4): the CC/Addr/Vis values are best effort guesses, we should look at tests and
+ // FIXME(ZuseZ4): the CC/Addr/Vis values are best effort guesses, we should look at tests and
// think a bit more about what should go here.
let cc = llvm::LLVMGetFunctionCallConv(outer_fn);
let ad_fn = declare_simple_fn(
@@ -240,14 +334,27 @@ fn generate_enzyme_call<'ll>(
if matches!(attrs.ret_activity, DiffActivity::Dual | DiffActivity::Active) {
args.push(cx.get_metadata_value(enzyme_primal_ret));
}
+ if attrs.width > 1 {
+ let enzyme_width = cx.create_metadata("enzyme_width".to_string()).unwrap();
+ args.push(cx.get_metadata_value(enzyme_width));
+ args.push(cx.get_const_i64(attrs.width as u64));
+ }
+ let has_sret = has_sret(outer_fn);
let outer_args: Vec<&llvm::Value> = get_params(outer_fn);
- match_args_from_caller_to_enzyme(&cx, &mut args, &attrs.input_activity, &outer_args);
+ match_args_from_caller_to_enzyme(
+ &cx,
+ attrs.width,
+ &mut args,
+ &attrs.input_activity,
+ &outer_args,
+ has_sret,
+ );
let call = builder.call(enzyme_ty, ad_fn, &args, None);
// This part is a bit iffy. LLVM requires that a call to an inlineable function has some
- // metadata attachted to it, but we just created this code oota. Given that the
+ // metadata attached to it, but we just created this code oota. Given that the
// differentiated function already has partly confusing metadata, and given that this
// affects nothing but the auttodiff IR, we take a shortcut and just steal metadata from the
// dummy code which we inserted at a higher level.
@@ -268,7 +375,22 @@ fn generate_enzyme_call<'ll>(
// Now that we copied the metadata, get rid of dummy code.
llvm::LLVMRustEraseInstUntilInclusive(entry, last_inst);
- if cx.val_ty(call) == cx.type_void() {
+ if cx.val_ty(call) == cx.type_void() || has_sret {
+ if has_sret {
+ // This is what we already have in our outer_fn (shortened):
+ // define void @_foo(ptr <..> sret([32 x i8]) initializes((0, 32)) %0, <...>) {
+ // %7 = call [4 x double] (...) @__enzyme_fwddiff_foo(ptr @square, metadata !"enzyme_width", i64 4, <...>)
+ // <Here we are, we want to add the following two lines>
+ // store [4 x double] %7, ptr %0, align 8
+ // ret void
+ // }
+
+ // now store the result of the enzyme call into the sret pointer.
+ let sret_ptr = outer_args[0];
+ let call_ty = cx.val_ty(call);
+ assert_eq!(cx.type_kind(call_ty), TypeKind::Array);
+ llvm::LLVMBuildStore(&builder.llbuilder, call, sret_ptr);
+ }
builder.ret_void();
} else {
builder.ret(call);
@@ -300,8 +422,7 @@ pub(crate) fn differentiate<'ll>(
if !diff_items.is_empty()
&& !cgcx.opts.unstable_opts.autodiff.contains(&rustc_session::config::AutoDiff::Enable)
{
- let dcx = cgcx.create_dcx();
- return Err(dcx.handle().emit_almost_fatal(AutoDiffWithoutEnable));
+ return Err(diag_handler.handle().emit_almost_fatal(AutoDiffWithoutEnable));
}
// Before dumping the module, we want all the TypeTrees to become part of the module.
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 62fa2884e0f6f..d5acfe2053119 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -425,7 +425,7 @@ impl<'ll> CodegenCx<'ll, '_> {
let val_llty = self.val_ty(v);
let g = self.get_static_inner(def_id, val_llty);
- let llty = llvm::LLVMGlobalGetValueType(g);
+ let llty = self.get_type_of_global(g);
let g = if val_llty == llty {
g
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 926445c780b53..d163fa9811790 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -8,6 +8,7 @@ use std::str;
use rustc_abi::{HasDataLayout, Size, TargetDataLayout, VariantIdx};
use rustc_codegen_ssa::back::versioned_llvm_target;
use rustc_codegen_ssa::base::{wants_msvc_seh, wants_wasm_eh};
+use rustc_codegen_ssa::common::TypeKind;
use rustc_codegen_ssa::errors as ssa_errors;
use rustc_codegen_ssa::traits::*;
use rustc_data_structures::base_n::{ALPHANUMERIC_ONLY, ToBaseN};
@@ -38,7 +39,7 @@ use crate::debuginfo::metadata::apply_vcall_visibility_metadata;
use crate::llvm::Metadata;
use crate::type_::Type;
use crate::value::Value;
-use crate::{attributes, coverageinfo, debuginfo, llvm, llvm_util};
+use crate::{attributes, common, coverageinfo, debuginfo, llvm, llvm_util};
/// `TyCtxt` (and related cache datastructures) can't be move between threads.
/// However, there are various cx related functions which we want to be available to the builder and
@@ -643,7 +644,18 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
llvm::set_section(g, c"llvm.metadata");
}
}
-
+impl<'ll> SimpleCx<'ll> {
+ pub(crate) fn get_return_type(&self, ty: &'ll Type) -> &'ll Type {
+ assert_eq!(self.type_kind(ty), TypeKind::Function);
+ unsafe { llvm::LLVMGetReturnType(ty) }
+ }
+ pub(crate) fn get_type_of_global(&self, val: &'ll Value) -> &'ll Type {
+ unsafe { llvm::LLVMGlobalGetValueType(val) }
+ }
+ pub(crate) fn val_ty(&self, v: &'ll Value) -> &'ll Type {
+ common::val_ty(v)
+ }
+}
impl<'ll> SimpleCx<'ll> {
pub(crate) fn new(
llmod: &'ll llvm::Module,
@@ -660,6 +672,13 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
llvm::LLVMMetadataAsValue(self.llcx(), metadata)
}
+ // FIXME(autodiff): We should split `ConstCodegenMethods` to pull the reusable parts
+ // onto a trait that is also implemented for GenericCx.
+ pub(crate) fn get_const_i64(&self, n: u64) -> &'ll Value {
+ let ty = unsafe { llvm::LLVMInt64TypeInContext(self.llcx()) };
+ unsafe { llvm::LLVMConstInt(ty, n, llvm::False) }
+ }
+
pub(crate) fn get_function(&self, name: &str) -> Option<&'ll Value> {
let name = SmallCStr::new(name);
unsafe { llvm::LLVMGetNamedFunction((**self).borrow().llmod, name.as_ptr()) }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index f6b238629075c..9e495586db071 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -4,7 +4,7 @@
use libc::{c_char, c_uint};
use super::MetadataKindId;
-use super::ffi::{BasicBlock, Metadata, Module, Type, Value};
+use super::ffi::{AttributeKind, BasicBlock, Metadata, Module, Type, Value};
use crate::llvm::Bool;
#[link(name = "llvm-wrapper", kind = "static")]
@@ -17,6 +17,8 @@ unsafe extern "C" {
pub(crate) fn LLVMRustEraseInstFromParent(V: &Value);
pub(crate) fn LLVMRustGetTerminator<'a>(B: &BasicBlock) -> &'a Value;
pub(crate) fn LLVMRustVerifyFunction(V: &Value, action: LLVMRustVerifierFailureAction) -> Bool;
+ pub(crate) fn LLVMRustHasAttributeAtIndex(V: &Value, i: c_uint, Kind: AttributeKind) -> bool;
+ pub(crate) fn LLVMRustGetArrayNumElements(Ty: &Type) -> u64;
}
unsafe extern "C" {
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 83efb3ea66039..d861e635fc5de 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1172,7 +1172,7 @@ unsafe extern "C" {
// Operations on parameters
pub(crate) fn LLVMIsAArgument(Val: &Value) -> Option<&Value>;
- pub(crate) fn LLVMCountParams(Fn: &Value) -> c_uint;
+ pub(crate) safe fn LLVMCountParams(Fn: &Value) -> c_uint;
pub(crate) fn LLVMGetParam(Fn: &Value, Index: c_uint) -> &Value;
// Operations on basic blocks
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 53df59930f4fd..32e6da446d72e 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -384,6 +384,12 @@ static inline void AddAttributes(T *t, unsigned Index, LLVMAttributeRef *Attrs,
t->setAttributes(PALNew);
}
+extern "C" bool LLVMRustHasAttributeAtIndex(LLVMValueRef Fn, unsigned Index,
+ LLVMRustAttributeKind RustAttr) {
+ Function *F = unwrap<Function>(Fn);
+ return F->hasParamAttribute(Index, fromRust(RustAttr));
+}
+
extern "C" void LLVMRustAddFunctionAttributes(LLVMValueRef Fn, unsigned Index,
LLVMAttributeRef *Attrs,
size_t AttrsLen) {
@@ -636,6 +642,10 @@ static InlineAsm::AsmDialect fromRust(LLVMRustAsmDialect Dialect) {
}
}
+extern "C" uint64_t LLVMRustGetArrayNumElements(LLVMTypeRef Ty) {
+ return unwrap(Ty)->getArrayNumElements();
+}
+
extern "C" LLVMValueRef
LLVMRustInlineAsm(LLVMTypeRef Ty, char *AsmString, size_t AsmStringLen,
char *Constraints, size_t ConstraintsLen,
From eefe4236ec86568a933bd83c11dd2b0d8d03903e Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Thu, 3 Apr 2025 17:23:23 -0400
Subject: [PATCH 31/33] add new tests for autodiff batching and update old ones
---
tests/codegen/autodiff.rs | 4 +-
tests/codegen/autodiffv.rs | 116 ++++++++++++++++++++++
tests/pretty/autodiff_forward.pp | 100 +++++++++++++++----
tests/pretty/autodiff_forward.rs | 18 ++++
tests/pretty/autodiff_reverse.pp | 22 ++--
tests/ui/autodiff/autodiff_illegal.rs | 7 ++
tests/ui/autodiff/autodiff_illegal.stderr | 38 ++++---
7 files changed, 251 insertions(+), 54 deletions(-)
create mode 100644 tests/codegen/autodiffv.rs
diff --git a/tests/codegen/autodiff.rs b/tests/codegen/autodiff.rs
index cace0edb2b544..85358f5fcb693 100644
--- a/tests/codegen/autodiff.rs
+++ b/tests/codegen/autodiff.rs
@@ -11,7 +11,7 @@ fn square(x: &f64) -> f64 {
x * x
}
-// CHECK:define internal fastcc double @diffesquare(double %x.0.val, ptr nocapture align 8 %"x'"
+// CHECK:define internal fastcc double @diffesquare(double %x.0.val, ptr nocapture nonnull align 8 %"x'"
// CHECK-NEXT:invertstart:
// CHECK-NEXT: %_0 = fmul double %x.0.val, %x.0.val
// CHECK-NEXT: %0 = fadd fast double %x.0.val, %x.0.val
@@ -22,7 +22,7 @@ fn square(x: &f64) -> f64 {
// CHECK-NEXT:}
fn main() {
- let x = 3.0;
+ let x = std::hint::black_box(3.0);
let output = square(&x);
assert_eq!(9.0, output);
diff --git a/tests/codegen/autodiffv.rs b/tests/codegen/autodiffv.rs
new file mode 100644
index 0000000000000..e004711640553
--- /dev/null
+++ b/tests/codegen/autodiffv.rs
@@ -0,0 +1,116 @@
+//@ compile-flags: -Zautodiff=Enable -C opt-level=3 -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+//
+// In Enzyme, we test against a large range of LLVM versions (5+) and don't have overly many
+// breakages. One benefit is that we match the IR generated by Enzyme only after running it
+// through LLVM's O3 pipeline, which will remove most of the noise.
+// However, our integration test could also be affected by changes in how rustc lowers MIR into
+// LLVM-IR, which could cause additional noise and thus breakages. If that's the case, we should
+// reduce this test to only match the first lines and the ret instructions.
+
+#![feature(autodiff)]
+
+use std::autodiff::autodiff;
+
+#[autodiff(d_square3, Forward, Dual, DualOnly)]
+#[autodiff(d_square2, Forward, 4, Dual, DualOnly)]
+#[autodiff(d_square1, Forward, 4, Dual, Dual)]
+#[no_mangle]
+fn square(x: &f32) -> f32 {
+ x * x
+}
+
+// d_sqaure2
+// CHECK: define internal fastcc [4 x float] @fwddiffe4square(float %x.0.val, [4 x ptr] %"x'")
+// CHECK-NEXT: start:
+// CHECK-NEXT: %0 = extractvalue [4 x ptr] %"x'", 0
+// CHECK-NEXT: %"_2'ipl" = load float, ptr %0, align 4
+// CHECK-NEXT: %1 = extractvalue [4 x ptr] %"x'", 1
+// CHECK-NEXT: %"_2'ipl1" = load float, ptr %1, align 4
+// CHECK-NEXT: %2 = extractvalue [4 x ptr] %"x'", 2
+// CHECK-NEXT: %"_2'ipl2" = load float, ptr %2, align 4
+// CHECK-NEXT: %3 = extractvalue [4 x ptr] %"x'", 3
+// CHECK-NEXT: %"_2'ipl3" = load float, ptr %3, align 4
+// CHECK-NEXT: %4 = insertelement <4 x float> poison, float %"_2'ipl", i64 0
+// CHECK-NEXT: %5 = insertelement <4 x float> %4, float %"_2'ipl1", i64 1
+// CHECK-NEXT: %6 = insertelement <4 x float> %5, float %"_2'ipl2", i64 2
+// CHECK-NEXT: %7 = insertelement <4 x float> %6, float %"_2'ipl3", i64 3
+// CHECK-NEXT: %8 = fadd fast <4 x float> %7, %7
+// CHECK-NEXT: %9 = insertelement <4 x float> poison, float %x.0.val, i64 0
+// CHECK-NEXT: %10 = shufflevector <4 x float> %9, <4 x float> poison, <4 x i32> zeroinitializer
+// CHECK-NEXT: %11 = fmul fast <4 x float> %8, %10
+// CHECK-NEXT: %12 = extractelement <4 x float> %11, i64 0
+// CHECK-NEXT: %13 = insertvalue [4 x float] undef, float %12, 0
+// CHECK-NEXT: %14 = extractelement <4 x float> %11, i64 1
+// CHECK-NEXT: %15 = insertvalue [4 x float] %13, float %14, 1
+// CHECK-NEXT: %16 = extractelement <4 x float> %11, i64 2
+// CHECK-NEXT: %17 = insertvalue [4 x float] %15, float %16, 2
+// CHECK-NEXT: %18 = extractelement <4 x float> %11, i64 3
+// CHECK-NEXT: %19 = insertvalue [4 x float] %17, float %18, 3
+// CHECK-NEXT: ret [4 x float] %19
+// CHECK-NEXT: }
+
+// d_square3, the extra float is the original return value (x * x)
+// CHECK: define internal fastcc { float, [4 x float] } @fwddiffe4square.1(float %x.0.val, [4 x ptr] %"x'")
+// CHECK-NEXT: start:
+// CHECK-NEXT: %0 = extractvalue [4 x ptr] %"x'", 0
+// CHECK-NEXT: %"_2'ipl" = load float, ptr %0, align 4
+// CHECK-NEXT: %1 = extractvalue [4 x ptr] %"x'", 1
+// CHECK-NEXT: %"_2'ipl1" = load float, ptr %1, align 4
+// CHECK-NEXT: %2 = extractvalue [4 x ptr] %"x'", 2
+// CHECK-NEXT: %"_2'ipl2" = load float, ptr %2, align 4
+// CHECK-NEXT: %3 = extractvalue [4 x ptr] %"x'", 3
+// CHECK-NEXT: %"_2'ipl3" = load float, ptr %3, align 4
+// CHECK-NEXT: %_0 = fmul float %x.0.val, %x.0.val
+// CHECK-NEXT: %4 = insertelement <4 x float> poison, float %"_2'ipl", i64 0
+// CHECK-NEXT: %5 = insertelement <4 x float> %4, float %"_2'ipl1", i64 1
+// CHECK-NEXT: %6 = insertelement <4 x float> %5, float %"_2'ipl2", i64 2
+// CHECK-NEXT: %7 = insertelement <4 x float> %6, float %"_2'ipl3", i64 3
+// CHECK-NEXT: %8 = fadd fast <4 x float> %7, %7
+// CHECK-NEXT: %9 = insertelement <4 x float> poison, float %x.0.val, i64 0
+// CHECK-NEXT: %10 = shufflevector <4 x float> %9, <4 x float> poison, <4 x i32> zeroinitializer
+// CHECK-NEXT: %11 = fmul fast <4 x float> %8, %10
+// CHECK-NEXT: %12 = extractelement <4 x float> %11, i64 0
+// CHECK-NEXT: %13 = insertvalue [4 x float] undef, float %12, 0
+// CHECK-NEXT: %14 = extractelement <4 x float> %11, i64 1
+// CHECK-NEXT: %15 = insertvalue [4 x float] %13, float %14, 1
+// CHECK-NEXT: %16 = extractelement <4 x float> %11, i64 2
+// CHECK-NEXT: %17 = insertvalue [4 x float] %15, float %16, 2
+// CHECK-NEXT: %18 = extractelement <4 x float> %11, i64 3
+// CHECK-NEXT: %19 = insertvalue [4 x float] %17, float %18, 3
+// CHECK-NEXT: %20 = insertvalue { float, [4 x float] } undef, float %_0, 0
+// CHECK-NEXT: %21 = insertvalue { float, [4 x float] } %20, [4 x float] %19, 1
+// CHECK-NEXT: ret { float, [4 x float] } %21
+// CHECK-NEXT: }
+
+fn main() {
+ let x = std::hint::black_box(3.0);
+ let output = square(&x);
+ dbg!(&output);
+ assert_eq!(9.0, output);
+ dbg!(square(&x));
+
+ let mut df_dx1 = 1.0;
+ let mut df_dx2 = 2.0;
+ let mut df_dx3 = 3.0;
+ let mut df_dx4 = 0.0;
+ let [o1, o2, o3, o4] = d_square2(&x, &mut df_dx1, &mut df_dx2, &mut df_dx3, &mut df_dx4);
+ dbg!(o1, o2, o3, o4);
+ let [output2, o1, o2, o3, o4] =
+ d_square1(&x, &mut df_dx1, &mut df_dx2, &mut df_dx3, &mut df_dx4);
+ dbg!(o1, o2, o3, o4);
+ assert_eq!(output, output2);
+ assert!((6.0 - o1).abs() < 1e-10);
+ assert!((12.0 - o2).abs() < 1e-10);
+ assert!((18.0 - o3).abs() < 1e-10);
+ assert!((0.0 - o4).abs() < 1e-10);
+ assert_eq!(1.0, df_dx1);
+ assert_eq!(2.0, df_dx2);
+ assert_eq!(3.0, df_dx3);
+ assert_eq!(0.0, df_dx4);
+ assert_eq!(d_square3(&x, &mut df_dx1), 2.0 * o1);
+ assert_eq!(d_square3(&x, &mut df_dx2), 2.0 * o2);
+ assert_eq!(d_square3(&x, &mut df_dx3), 2.0 * o3);
+ assert_eq!(d_square3(&x, &mut df_dx4), 2.0 * o4);
+}
diff --git a/tests/pretty/autodiff_forward.pp b/tests/pretty/autodiff_forward.pp
index dc7a2712f4231..4b2fb6166ff7e 100644
--- a/tests/pretty/autodiff_forward.pp
+++ b/tests/pretty/autodiff_forward.pp
@@ -25,27 +25,31 @@
// We want to be sure that the same function can be differentiated in different ways
+
+ // Make sure, that we add the None for the default return.
+
+
::core::panicking::panic("not implemented")
}
-#[rustc_autodiff(Forward, Dual, Const, Dual,)]
+#[rustc_autodiff(Forward, 1, Dual, Const, Dual)]
#[inline(never)]
-pub fn df1(x: &[f64], bx: &[f64], y: f64) -> (f64, f64) {
+pub fn df1(x: &[f64], bx_0: &[f64], y: f64) -> (f64, f64) {
unsafe { asm!("NOP", options(pure, nomem)); };
::core::hint::black_box(f1(x, y));
- ::core::hint::black_box((bx,));
- ::core::hint::black_box((f1(x, y), f64::default()))
+ ::core::hint::black_box((bx_0,));
+ ::core::hint::black_box(<(f64, f64)>::default())
}
#[rustc_autodiff]
#[inline(never)]
pub fn f2(x: &[f64], y: f64) -> f64 {
::core::panicking::panic("not implemented")
}
-#[rustc_autodiff(Forward, Dual, Const, Const,)]
+#[rustc_autodiff(Forward, 1, Dual, Const, Const)]
#[inline(never)]
-pub fn df2(x: &[f64], bx: &[f64], y: f64) -> f64 {
+pub fn df2(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
unsafe { asm!("NOP", options(pure, nomem)); };
::core::hint::black_box(f2(x, y));
- ::core::hint::black_box((bx,));
+ ::core::hint::black_box((bx_0,));
::core::hint::black_box(f2(x, y))
}
#[rustc_autodiff]
@@ -53,20 +57,20 @@
pub fn f3(x: &[f64], y: f64) -> f64 {
::core::panicking::panic("not implemented")
}
-#[rustc_autodiff(Forward, Dual, Const, Const,)]
+#[rustc_autodiff(Forward, 1, Dual, Const, Const)]
#[inline(never)]
-pub fn df3(x: &[f64], bx: &[f64], y: f64) -> f64 {
+pub fn df3(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
unsafe { asm!("NOP", options(pure, nomem)); };
::core::hint::black_box(f3(x, y));
- ::core::hint::black_box((bx,));
+ ::core::hint::black_box((bx_0,));
::core::hint::black_box(f3(x, y))
}
#[rustc_autodiff]
#[inline(never)]
pub fn f4() {}
-#[rustc_autodiff(Forward, None)]
+#[rustc_autodiff(Forward, 1, None)]
#[inline(never)]
-pub fn df4() {
+pub fn df4() -> () {
unsafe { asm!("NOP", options(pure, nomem)); };
::core::hint::black_box(f4());
::core::hint::black_box(());
@@ -76,28 +80,82 @@
pub fn f5(x: &[f64], y: f64) -> f64 {
::core::panicking::panic("not implemented")
}
-#[rustc_autodiff(Forward, Const, Dual, Const,)]
+#[rustc_autodiff(Forward, 1, Const, Dual, Const)]
#[inline(never)]
-pub fn df5_y(x: &[f64], y: f64, by: f64) -> f64 {
+pub fn df5_y(x: &[f64], y: f64, by_0: f64) -> f64 {
unsafe { asm!("NOP", options(pure, nomem)); };
::core::hint::black_box(f5(x, y));
- ::core::hint::black_box((by,));
+ ::core::hint::black_box((by_0,));
::core::hint::black_box(f5(x, y))
}
-#[rustc_autodiff(Forward, Dual, Const, Const,)]
+#[rustc_autodiff(Forward, 1, Dual, Const, Const)]
#[inline(never)]
-pub fn df5_x(x: &[f64], bx: &[f64], y: f64) -> f64 {
+pub fn df5_x(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
unsafe { asm!("NOP", options(pure, nomem)); };
::core::hint::black_box(f5(x, y));
- ::core::hint::black_box((bx,));
+ ::core::hint::black_box((bx_0,));
::core::hint::black_box(f5(x, y))
}
-#[rustc_autodiff(Reverse, Duplicated, Const, Active,)]
+#[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
#[inline(never)]
-pub fn df5_rev(x: &[f64], dx: &mut [f64], y: f64, dret: f64) -> f64 {
+pub fn df5_rev(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
unsafe { asm!("NOP", options(pure, nomem)); };
::core::hint::black_box(f5(x, y));
- ::core::hint::black_box((dx, dret));
+ ::core::hint::black_box((dx_0, dret));
::core::hint::black_box(f5(x, y))
}
+struct DoesNotImplDefault;
+#[rustc_autodiff]
+#[inline(never)]
+pub fn f6() -> DoesNotImplDefault {
+ ::core::panicking::panic("not implemented")
+}
+#[rustc_autodiff(Forward, 1, Const)]
+#[inline(never)]
+pub fn df6() -> DoesNotImplDefault {
+ unsafe { asm!("NOP", options(pure, nomem)); };
+ ::core::hint::black_box(f6());
+ ::core::hint::black_box(());
+ ::core::hint::black_box(f6())
+}
+#[rustc_autodiff]
+#[inline(never)]
+pub fn f7(x: f32) -> () {}
+#[rustc_autodiff(Forward, 1, Const, None)]
+#[inline(never)]
+pub fn df7(x: f32) -> () {
+ unsafe { asm!("NOP", options(pure, nomem)); };
+ ::core::hint::black_box(f7(x));
+ ::core::hint::black_box(());
+}
+#[no_mangle]
+#[rustc_autodiff]
+#[inline(never)]
+fn f8(x: &f32) -> f32 { ::core::panicking::panic("not implemented") }
+#[rustc_autodiff(Forward, 4, Dual, Dual)]
+#[inline(never)]
+fn f8_3(x: &f32, bx_0: &f32, bx_1: &f32, bx_2: &f32, bx_3: &f32)
+ -> [f32; 5usize] {
+ unsafe { asm!("NOP", options(pure, nomem)); };
+ ::core::hint::black_box(f8(x));
+ ::core::hint::black_box((bx_0, bx_1, bx_2, bx_3));
+ ::core::hint::black_box(<[f32; 5usize]>::default())
+}
+#[rustc_autodiff(Forward, 4, Dual, DualOnly)]
+#[inline(never)]
+fn f8_2(x: &f32, bx_0: &f32, bx_1: &f32, bx_2: &f32, bx_3: &f32)
+ -> [f32; 4usize] {
+ unsafe { asm!("NOP", options(pure, nomem)); };
+ ::core::hint::black_box(f8(x));
+ ::core::hint::black_box((bx_0, bx_1, bx_2, bx_3));
+ ::core::hint::black_box(<[f32; 4usize]>::default())
+}
+#[rustc_autodiff(Forward, 1, Dual, DualOnly)]
+#[inline(never)]
+fn f8_1(x: &f32, bx_0: &f32) -> f32 {
+ unsafe { asm!("NOP", options(pure, nomem)); };
+ ::core::hint::black_box(f8(x));
+ ::core::hint::black_box((bx_0,));
+ ::core::hint::black_box(<f32>::default())
+}
fn main() {}
diff --git a/tests/pretty/autodiff_forward.rs b/tests/pretty/autodiff_forward.rs
index bc5582116322b..a765738c2a815 100644
--- a/tests/pretty/autodiff_forward.rs
+++ b/tests/pretty/autodiff_forward.rs
@@ -36,4 +36,22 @@ pub fn f5(x: &[f64], y: f64) -> f64 {
unimplemented!()
}
+struct DoesNotImplDefault;
+#[autodiff(df6, Forward, Const)]
+pub fn f6() -> DoesNotImplDefault {
+ unimplemented!()
+}
+
+// Make sure, that we add the None for the default return.
+#[autodiff(df7, Forward, Const)]
+pub fn f7(x: f32) -> () {}
+
+#[autodiff(f8_1, Forward, Dual, DualOnly)]
+#[autodiff(f8_2, Forward, 4, Dual, DualOnly)]
+#[autodiff(f8_3, Forward, 4, Dual, Dual)]
+#[no_mangle]
+fn f8(x: &f32) -> f32 {
+ unimplemented!()
+}
+
fn main() {}
diff --git a/tests/pretty/autodiff_reverse.pp b/tests/pretty/autodiff_reverse.pp
index b2cf0244af4c6..31920694a3ad5 100644
--- a/tests/pretty/autodiff_reverse.pp
+++ b/tests/pretty/autodiff_reverse.pp
@@ -28,18 +28,18 @@
::core::panicking::panic("not implemented")
}
-#[rustc_autodiff(Reverse, Duplicated, Const, Active,)]
+#[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
#[inline(never)]
-pub fn df1(x: &[f64], dx: &mut [f64], y: f64, dret: f64) -> f64 {
+pub fn df1(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
unsafe { asm!("NOP", options(pure, nomem)); };
::core::hint::black_box(f1(x, y));
- ::core::hint::black_box((dx, dret));
+ ::core::hint::black_box((dx_0, dret));
::core::hint::black_box(f1(x, y))
}
#[rustc_autodiff]
#[inline(never)]
pub fn f2() {}
-#[rustc_autodiff(Reverse, None)]
+#[rustc_autodiff(Reverse, 1, None)]
#[inline(never)]
pub fn df2() {
unsafe { asm!("NOP", options(pure, nomem)); };
@@ -51,12 +51,12 @@
pub fn f3(x: &[f64], y: f64) -> f64 {
::core::panicking::panic("not implemented")
}
-#[rustc_autodiff(Reverse, Duplicated, Const, Active,)]
+#[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
#[inline(never)]
-pub fn df3(x: &[f64], dx: &mut [f64], y: f64, dret: f64) -> f64 {
+pub fn df3(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
unsafe { asm!("NOP", options(pure, nomem)); };
::core::hint::black_box(f3(x, y));
- ::core::hint::black_box((dx, dret));
+ ::core::hint::black_box((dx_0, dret));
::core::hint::black_box(f3(x, y))
}
enum Foo { Reverse, }
@@ -64,7 +64,7 @@
#[rustc_autodiff]
#[inline(never)]
pub fn f4(x: f32) { ::core::panicking::panic("not implemented") }
-#[rustc_autodiff(Reverse, Const, None)]
+#[rustc_autodiff(Reverse, 1, Const, None)]
#[inline(never)]
pub fn df4(x: f32) {
unsafe { asm!("NOP", options(pure, nomem)); };
@@ -76,11 +76,11 @@
pub fn f5(x: *const f32, y: &f32) {
::core::panicking::panic("not implemented")
}
-#[rustc_autodiff(Reverse, DuplicatedOnly, Duplicated, None)]
+#[rustc_autodiff(Reverse, 1, DuplicatedOnly, Duplicated, None)]
#[inline(never)]
-pub unsafe fn df5(x: *const f32, dx: *mut f32, y: &f32, dy: &mut f32) {
+pub unsafe fn df5(x: *const f32, dx_0: *mut f32, y: &f32, dy_0: &mut f32) {
unsafe { asm!("NOP", options(pure, nomem)); };
::core::hint::black_box(f5(x, y));
- ::core::hint::black_box((dx, dy));
+ ::core::hint::black_box((dx_0, dy_0));
}
fn main() {}
diff --git a/tests/ui/autodiff/autodiff_illegal.rs b/tests/ui/autodiff/autodiff_illegal.rs
index e810b9ba565ba..2f2cd8d93532f 100644
--- a/tests/ui/autodiff/autodiff_illegal.rs
+++ b/tests/ui/autodiff/autodiff_illegal.rs
@@ -177,4 +177,11 @@ fn f21(x: f32) -> f32 {
unimplemented!()
}
+struct DoesNotImplDefault;
+#[autodiff(df22, Forward, Dual)]
+pub fn f22() -> DoesNotImplDefault {
+ //~^^ ERROR the function or associated item `default` exists for tuple `(DoesNotImplDefault, DoesNotImplDefault)`, but its trait bounds were not satisfied
+ unimplemented!()
+}
+
fn main() {}
diff --git a/tests/ui/autodiff/autodiff_illegal.stderr b/tests/ui/autodiff/autodiff_illegal.stderr
index 47d53492700ba..3752b27e7dd1b 100644
--- a/tests/ui/autodiff/autodiff_illegal.stderr
+++ b/tests/ui/autodiff/autodiff_illegal.stderr
@@ -19,32 +19,24 @@ error: expected 1 activities, but found 2
|
LL | #[autodiff(df3, Reverse, Duplicated, Const)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error: expected 1 activities, but found 0
--> $DIR/autodiff_illegal.rs:27:1
|
LL | #[autodiff(df4, Reverse)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error: Dual can not be used in Reverse Mode
--> $DIR/autodiff_illegal.rs:34:1
|
LL | #[autodiff(df5, Reverse, Dual)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error: Duplicated can not be used in Forward Mode
--> $DIR/autodiff_illegal.rs:41:1
|
LL | #[autodiff(df6, Forward, Duplicated)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error: Duplicated can not be used for this type
--> $DIR/autodiff_illegal.rs:42:14
@@ -107,7 +99,6 @@ LL | #[autodiff(fn_exists, Reverse, Active)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `fn_exists` redefined here
|
= note: `fn_exists` must be defined only once in the value namespace of this module
- = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error: autodiff requires at least a name and mode
--> $DIR/autodiff_illegal.rs:95:1
@@ -135,42 +126,49 @@ error: invalid return activity Active in Forward Mode
|
LL | #[autodiff(df19, Forward, Dual, Active)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error: invalid return activity Dual in Reverse Mode
--> $DIR/autodiff_illegal.rs:167:1
|
LL | #[autodiff(df20, Reverse, Active, Dual)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error: invalid return activity Duplicated in Reverse Mode
--> $DIR/autodiff_illegal.rs:174:1
|
LL | #[autodiff(df21, Reverse, Active, Duplicated)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0433]: failed to resolve: use of undeclared type `MyFloat`
--> $DIR/autodiff_illegal.rs:130:1
|
LL | #[autodiff(df15, Reverse, Active, Active)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use of undeclared type `MyFloat`
- |
- = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0433]: failed to resolve: use of undeclared type `F64Trans`
--> $DIR/autodiff_illegal.rs:154:1
|
LL | #[autodiff(df18, Reverse, Active, Active)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use of undeclared type `F64Trans`
+
+error[E0599]: the function or associated item `default` exists for tuple `(DoesNotImplDefault, DoesNotImplDefault)`, but its trait bounds were not satisfied
+ --> $DIR/autodiff_illegal.rs:181:1
+ |
+LL | struct DoesNotImplDefault;
+ | ------------------------- doesn't satisfy `DoesNotImplDefault: Default`
+LL | #[autodiff(df22, Forward, Dual)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function or associated item cannot be called on `(DoesNotImplDefault, DoesNotImplDefault)` due to unsatisfied trait bounds
+ |
+ = note: the following trait bounds were not satisfied:
+ `DoesNotImplDefault: Default`
+ which is required by `(DoesNotImplDefault, DoesNotImplDefault): Default`
+help: consider annotating `DoesNotImplDefault` with `#[derive(Default)]`
+ |
+LL + #[derive(Default)]
+LL | struct DoesNotImplDefault;
|
- = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: aborting due to 22 previous errors
+error: aborting due to 23 previous errors
-Some errors have detailed explanations: E0428, E0433, E0658.
+Some errors have detailed explanations: E0428, E0433, E0599, E0658.
For more information about an error, try `rustc --explain E0428`.
From 2898b90360aa3be23fb37605d9273192a8925be4 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Thu, 3 Apr 2025 17:23:45 -0400
Subject: [PATCH 32/33] add new flag to print the module post-AD, before opts
---
compiler/rustc_codegen_llvm/src/back/lto.rs | 12 ++++++++++--
compiler/rustc_session/src/config.rs | 6 ++++--
compiler/rustc_session/src/options.rs | 4 +++-
3 files changed, 17 insertions(+), 5 deletions(-)
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index 668795191a29a..158275a559bec 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -610,6 +610,8 @@ fn enable_autodiff_settings(ad: &[config::AutoDiff], module: &mut ModuleCodegen<
}
// We handle this below
config::AutoDiff::PrintModAfter => {}
+ // We handle this below
+ config::AutoDiff::PrintModFinal => {}
// This is required and already checked
config::AutoDiff::Enable => {}
}
@@ -657,14 +659,20 @@ pub(crate) fn run_pass_manager(
}
if cfg!(llvm_enzyme) && enable_ad {
+ // This is the post-autodiff IR, mainly used for testing and educational purposes.
+ if config.autodiff.contains(&config::AutoDiff::PrintModAfter) {
+ unsafe { llvm::LLVMDumpModule(module.module_llvm.llmod()) };
+ }
+
let opt_stage = llvm::OptStage::FatLTO;
let stage = write::AutodiffStage::PostAD;
unsafe {
write::llvm_optimize(cgcx, dcx, module, None, config, opt_level, opt_stage, stage)?;
}
- // This is the final IR, so people should be able to inspect the optimized autodiff output.
- if config.autodiff.contains(&config::AutoDiff::PrintModAfter) {
+ // This is the final IR, so people should be able to inspect the optimized autodiff output,
+ // for manual inspection.
+ if config.autodiff.contains(&config::AutoDiff::PrintModFinal) {
unsafe { llvm::LLVMDumpModule(module.module_llvm.llmod()) };
}
}
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 43b78423c727f..39d6a24d08171 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -235,10 +235,12 @@ pub enum AutoDiff {
PrintPerf,
/// Print intermediate IR generation steps
PrintSteps,
- /// Print the whole module, before running opts.
+ /// Print the module, before running autodiff.
PrintModBefore,
- /// Print the module after Enzyme differentiated everything.
+ /// Print the module after running autodiff.
PrintModAfter,
+ /// Print the module after running autodiff and optimizations.
+ PrintModFinal,
/// Enzyme's loose type debug helper (can cause incorrect gradients!!)
/// Usable in cases where Enzyme errors with `can not deduce type of X`.
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index b3be4b611f03f..45cce29799f0d 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -707,7 +707,7 @@ mod desc {
pub(crate) const parse_list: &str = "a space-separated list of strings";
pub(crate) const parse_list_with_polarity: &str =
"a comma-separated list of strings, with elements beginning with + or -";
- pub(crate) const parse_autodiff: &str = "a comma separated list of settings: `Enable`, `PrintSteps`, `PrintTA`, `PrintAA`, `PrintPerf`, `PrintModBefore`, `PrintModAfter`, `LooseTypes`, `Inline`";
+ pub(crate) const parse_autodiff: &str = "a comma separated list of settings: `Enable`, `PrintSteps`, `PrintTA`, `PrintAA`, `PrintPerf`, `PrintModBefore`, `PrintModAfter`, `PrintModFinal`, `LooseTypes`, `Inline`";
pub(crate) const parse_comma_list: &str = "a comma-separated list of strings";
pub(crate) const parse_opt_comma_list: &str = parse_comma_list;
pub(crate) const parse_number: &str = "a number";
@@ -1355,6 +1355,7 @@ pub mod parse {
"PrintSteps" => AutoDiff::PrintSteps,
"PrintModBefore" => AutoDiff::PrintModBefore,
"PrintModAfter" => AutoDiff::PrintModAfter,
+ "PrintModFinal" => AutoDiff::PrintModFinal,
"LooseTypes" => AutoDiff::LooseTypes,
"Inline" => AutoDiff::Inline,
_ => {
@@ -2088,6 +2089,7 @@ options! {
`=PrintSteps`
`=PrintModBefore`
`=PrintModAfter`
+ `=PrintModFinal`
`=LooseTypes`
`=Inline`
Multiple options can be combined with commas."),
From ad1fb1e2086d152a912a0be071584f15dac46470 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maja=20K=C4=85dzio=C5=82ka?= <maya@compilercrim.es>
Date: Fri, 4 Apr 2025 01:34:35 +0200
Subject: [PATCH 33/33] Add a mailmap entry for myself
---
.mailmap | 2 ++
1 file changed, 2 insertions(+)
diff --git a/.mailmap b/.mailmap
index a791daa681d47..f4c8dab5a6653 100644
--- a/.mailmap
+++ b/.mailmap
@@ -408,6 +408,8 @@ Luqman Aden <me@luqman.ca> <laden@mozilla.com>
Luqman Aden <me@luqman.ca> <rust@luqman.ca>
Lzu Tao <taolzu@gmail.com>
Maik Klein <maikklein@googlemail.com>
+Maja Kądziołka <maya@compilercrim.es> <github@compilercrim.es>
+Maja Kądziołka <maya@compilercrim.es> <kuba@kadziolka.net>
Malo Jaffré <jaffre.malo@gmail.com>
Manish Goregaokar <manishsmail@gmail.com>
Mara Bos <m-ou.se@m-ou.se>