Rollup of 14 pull requests

compiler/rustc_arena/src/lib.rs

@@ -21,7 +21,6 @@
 #![feature(decl_macro)]
 #![feature(dropck_eyepatch)]
 #![feature(maybe_uninit_slice)]
-#![feature(new_uninit)]
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
 #![feature(strict_provenance)]

compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs

@@ -11,7 +11,6 @@ use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_span::symbol::{sym, Ident};
 use rustc_span::{Span, Symbol};
-use smallvec::{smallvec, SmallVec};
 use thin_vec::{thin_vec, ThinVec};
 
 macro_rules! path {
@@ -68,43 +67,63 @@ pub(crate) fn expand_deriving_smart_ptr(
  };
 
  // Convert generic parameters (from the struct) into generic args.
- let mut pointee_param = None;
- let mut multiple_pointee_diag: SmallVec<[_; 2]> = smallvec![];
- let self_params = generics
+ let self_params: Vec<_> = generics
  .params
  .iter()
- .enumerate()
- .map(|(idx, p)| match p.kind {
+ .map(|p| match p.kind {
  GenericParamKind::Lifetime => GenericArg::Lifetime(cx.lifetime(p.span(), p.ident)),
- GenericParamKind::Type { .. } => {
- if p.attrs().iter().any(|attr| attr.has_name(sym::pointee)) {
- if pointee_param.is_some() {
- multiple_pointee_diag.push(cx.dcx().struct_span_err(
- p.span(),
- "`SmartPointer` can only admit one type as pointee",
- ));
- } else {
- pointee_param = Some(idx);
- }
- }
- GenericArg::Type(cx.ty_ident(p.span(), p.ident))
- }
+ GenericParamKind::Type { .. } => GenericArg::Type(cx.ty_ident(p.span(), p.ident)),
  GenericParamKind::Const { .. } => GenericArg::Const(cx.const_ident(p.span(), p.ident)),
  })
- .collect::<Vec<_>>();
- let Some(pointee_param_idx) = pointee_param else {
+ .collect();
+ let type_params: Vec<_> = generics
+ .params
+ .iter()
+ .enumerate()
+ .filter_map(|(idx, p)| {
+ if let GenericParamKind::Type { .. } = p.kind {
+ Some((idx, p.span(), p.attrs().iter().any(|attr| attr.has_name(sym::pointee))))
+ } else {
+ None
+ }
+ })
+ .collect();
+
+ let pointee_param_idx = if type_params.is_empty() {
+ // `#[derive(SmartPointer)]` requires at least one generic type on the target `struct`
  cx.dcx().struct_span_err(
  span,
- "At least one generic type should be designated as `#[pointee]` in order to derive `SmartPointer` traits",
+ "`SmartPointer` can only be derived on `struct`s that are generic over at least one type",
  ).emit();
  return;
- };
- if !multiple_pointee_diag.is_empty() {
- for diag in multiple_pointee_diag {
- diag.emit();
+ } else if type_params.len() == 1 {
+ // Regardless of the only type param being designed as `#[pointee]` or not, we can just use it as such
+ type_params[0].0
+ } else {
+ let mut pointees = type_params
+ .iter()
+ .filter_map(|&(idx, span, is_pointee)| is_pointee.then_some((idx, span)))
+ .fuse();
+ match (pointees.next(), pointees.next()) {
+ (Some((idx, _span)), None) => idx,
+ (None, _) => {
+ cx.dcx().struct_span_err(
+ span,
+ "exactly one generic type parameter must be marked as #[pointee] to derive SmartPointer traits",
+ ).emit();
+ return;
+ }
+ (Some((_, one)), Some((_, another))) => {
+ cx.dcx()
+ .struct_span_err(
+ vec![one, another],
+ "only one type parameter can be marked as `#[pointee]` when deriving SmartPointer traits",
+ )
+ .emit();
+ return;
+ }
  }
- return;
- }
+ };
 
  // Create the type of `self`.
  let path = cx.path_all(span, false, vec![name_ident], self_params.clone());

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -521,13 +521,20 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
 
  let function_features = function_features
  .iter()
- .flat_map(|feat| {
- llvm_util::to_llvm_features(cx.tcx.sess, feat).into_iter().map(|f| format!("+{f}"))
- })
+ // Convert to LLVMFeatures and filter out unavailable ones
+ .flat_map(|feat| llvm_util::to_llvm_features(cx.tcx.sess, feat))
+ // Convert LLVMFeatures & dependencies to +<feats>s
+ .flat_map(|feat| feat.into_iter().map(|f| format!("+{f}")))
  .chain(codegen_fn_attrs.instruction_set.iter().map(|x| match x {
  InstructionSetAttr::ArmA32 => "-thumb-mode".to_string(),
  InstructionSetAttr::ArmT32 => "+thumb-mode".to_string(),
  }))
+ // HACK: LLVM versions 19+ do not have the FPMR feature and treat it as always enabled
+ // It only exists as a feature in LLVM 18, cannot be passed down for any other version
+ .chain(match &*cx.tcx.sess.target.arch {
+ "aarch64" if llvm_util::get_version().0 == 18 => vec!["+fpmr".to_string()],
+ _ => vec![],
+ })
  .collect::<Vec<String>>();
 
  if cx.tcx.sess.target.is_like_wasm {

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -209,7 +209,7 @@ impl<'a> IntoIterator for LLVMFeature<'a> {
 // Though note that Rust can also be build with an external precompiled version of LLVM
 // which might lead to failures if the oldest tested / supported LLVM version
 // doesn't yet support the relevant intrinsics
-pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a> {
+pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFeature<'a>> {
  let arch = if sess.target.arch == "x86_64" {
  "x86"
  } else if sess.target.arch == "arm64ec" {
@@ -218,40 +218,59 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a
  &*sess.target.arch
  };
  match (arch, s) {
- ("x86", "sse4.2") => {
- LLVMFeature::with_dependency("sse4.2", TargetFeatureFoldStrength::EnableOnly("crc32"))
- }
- ("x86", "pclmulqdq") => LLVMFeature::new("pclmul"),
- ("x86", "rdrand") => LLVMFeature::new("rdrnd"),
- ("x86", "bmi1") => LLVMFeature::new("bmi"),
- ("x86", "cmpxchg16b") => LLVMFeature::new("cx16"),
- ("x86", "lahfsahf") => LLVMFeature::new("sahf"),
- ("aarch64", "rcpc2") => LLVMFeature::new("rcpc-immo"),
- ("aarch64", "dpb") => LLVMFeature::new("ccpp"),
- ("aarch64", "dpb2") => LLVMFeature::new("ccdp"),
- ("aarch64", "frintts") => LLVMFeature::new("fptoint"),
- ("aarch64", "fcma") => LLVMFeature::new("complxnum"),
- ("aarch64", "pmuv3") => LLVMFeature::new("perfmon"),
- ("aarch64", "paca") => LLVMFeature::new("pauth"),
- ("aarch64", "pacg") => LLVMFeature::new("pauth"),
+ ("x86", "sse4.2") => Some(LLVMFeature::with_dependency(
+ "sse4.2",
+ TargetFeatureFoldStrength::EnableOnly("crc32"),
+ )),
+ ("x86", "pclmulqdq") => Some(LLVMFeature::new("pclmul")),
+ ("x86", "rdrand") => Some(LLVMFeature::new("rdrnd")),
+ ("x86", "bmi1") => Some(LLVMFeature::new("bmi")),
+ ("x86", "cmpxchg16b") => Some(LLVMFeature::new("cx16")),
+ ("x86", "lahfsahf") => Some(LLVMFeature::new("sahf")),
+ ("aarch64", "rcpc2") => Some(LLVMFeature::new("rcpc-immo")),
+ ("aarch64", "dpb") => Some(LLVMFeature::new("ccpp")),
+ ("aarch64", "dpb2") => Some(LLVMFeature::new("ccdp")),
+ ("aarch64", "frintts") => Some(LLVMFeature::new("fptoint")),
+ ("aarch64", "fcma") => Some(LLVMFeature::new("complxnum")),
+ ("aarch64", "pmuv3") => Some(LLVMFeature::new("perfmon")),
+ ("aarch64", "paca") => Some(LLVMFeature::new("pauth")),
+ ("aarch64", "pacg") => Some(LLVMFeature::new("pauth")),
+ ("aarch64", "sve-b16b16") => Some(LLVMFeature::new("b16b16")),
+ ("aarch64", "flagm2") => Some(LLVMFeature::new("altnzcv")),
  // Rust ties fp and neon together.
  ("aarch64", "neon") => {
- LLVMFeature::with_dependency("neon", TargetFeatureFoldStrength::Both("fp-armv8"))
+ Some(LLVMFeature::with_dependency("neon", TargetFeatureFoldStrength::Both("fp-armv8")))
  }
  // In LLVM neon implicitly enables fp, but we manually enable
  // neon when a feature only implicitly enables fp
- ("aarch64", "fhm") => LLVMFeature::new("fp16fml"),
- ("aarch64", "fp16") => LLVMFeature::new("fullfp16"),
+ ("aarch64", "fhm") => Some(LLVMFeature::new("fp16fml")),
+ ("aarch64", "fp16") => Some(LLVMFeature::new("fullfp16")),
+ // Filter out features that are not supported by the current LLVM version
+ ("aarch64", "faminmax") if get_version().0 < 18 => None,
+ ("aarch64", "fp8") if get_version().0 < 18 => None,
+ ("aarch64", "fp8dot2") if get_version().0 < 18 => None,
+ ("aarch64", "fp8dot4") if get_version().0 < 18 => None,
+ ("aarch64", "fp8fma") if get_version().0 < 18 => None,
+ ("aarch64", "fpmr") if get_version().0 != 18 => None,
+ ("aarch64", "lut") if get_version().0 < 18 => None,
+ ("aarch64", "sme-f8f16") if get_version().0 < 18 => None,
+ ("aarch64", "sme-f8f32") if get_version().0 < 18 => None,
+ ("aarch64", "sme-fa64") if get_version().0 < 18 => None,
+ ("aarch64", "sme-lutv2") if get_version().0 < 18 => None,
+ ("aarch64", "ssve-fp8dot2") if get_version().0 < 18 => None,
+ ("aarch64", "ssve-fp8dot4") if get_version().0 < 18 => None,
+ ("aarch64", "ssve-fp8fma") if get_version().0 < 18 => None,
+ ("aarch64", "v9.5a") if get_version().0 < 18 => None,
  // In LLVM 18, `unaligned-scalar-mem` was merged with `unaligned-vector-mem` into a single feature called
  // `fast-unaligned-access`. In LLVM 19, it was split back out.
  ("riscv32" | "riscv64", "unaligned-scalar-mem") if get_version().0 == 18 => {
- LLVMFeature::new("fast-unaligned-access")
+ Some(LLVMFeature::new("fast-unaligned-access"))
  }
  // For LLVM 18, enable the evex512 target feature if a avx512 target feature is enabled.
  ("x86", s) if get_version().0 >= 18 && s.starts_with("avx512") => {
- LLVMFeature::with_dependency(s, TargetFeatureFoldStrength::EnableOnly("evex512"))
+ Some(LLVMFeature::with_dependency(s, TargetFeatureFoldStrength::EnableOnly("evex512")))
  }
- (_, s) => LLVMFeature::new(s),
+ (_, s) => Some(LLVMFeature::new(s)),
  }
 }
 
@@ -291,13 +310,17 @@ pub fn target_features(sess: &Session, allow_unstable: bool) -> Vec<Symbol> {
  return true;
  }
  // check that all features in a given smallvec are enabled
- for llvm_feature in to_llvm_features(sess, feature) {
- let cstr = SmallCStr::new(llvm_feature);
- if !unsafe { llvm::LLVMRustHasFeature(&target_machine, cstr.as_ptr()) } {
- return false;
+ if let Some(feat) = to_llvm_features(sess, feature) {
+ for llvm_feature in feat {
+ let cstr = SmallCStr::new(llvm_feature);
+ if !unsafe { llvm::LLVMRustHasFeature(&target_machine, cstr.as_ptr()) } {
+ return false;
+ }
  }
+ true
+ } else {
+ false
  }
- true
  })
  .map(|(feature, _, _)| Symbol::intern(feature)),
  );
@@ -386,9 +409,9 @@ fn print_target_features(out: &mut String, sess: &Session, tm: &llvm::TargetMach
  .target
  .supported_target_features()
  .iter()
- .map(|(feature, _gate, _implied)| {
+ .filter_map(|(feature, _gate, _implied)| {
  // LLVM asserts that these are sorted. LLVM and Rust both use byte comparison for these strings.
- let llvm_feature = to_llvm_features(sess, *feature).llvm_feature_name;
+ let llvm_feature = to_llvm_features(sess, *feature)?.llvm_feature_name;
  let desc =
  match llvm_target_features.binary_search_by_key(&llvm_feature, |(f, _d)| f).ok() {
  Some(index) => {
@@ -398,7 +421,7 @@ fn print_target_features(out: &mut String, sess: &Session, tm: &llvm::TargetMach
  None => "",
  };
 
- (*feature, desc)
+ Some((*feature, desc))
  })
  .collect::<Vec<_>>();
 
@@ -595,7 +618,7 @@ pub(crate) fn global_llvm_features(
  if feature_state.is_none() {
  let rust_feature =
  supported_features.iter().find_map(|&(rust_feature, _, _)| {
- let llvm_features = to_llvm_features(sess, rust_feature);
+ let llvm_features = to_llvm_features(sess, rust_feature)?;
  if llvm_features.contains(feature)
  && !llvm_features.contains(rust_feature)
  {
@@ -641,7 +664,7 @@ pub(crate) fn global_llvm_features(
  // passing requests down to LLVM. This means that all in-language
  // features also work on the command line instead of having two
  // different names when the LLVM name and the Rust name differ.
- let llvm_feature = to_llvm_features(sess, feature);
+ let llvm_feature = to_llvm_features(sess, feature)?;
 
  Some(
  std::iter::once(format!(
@@ -691,6 +714,9 @@ fn backend_feature_name<'a>(sess: &Session, s: &'a str) -> Option<&'a str> {
  let feature = s
  .strip_prefix(&['+', '-'][..])
  .unwrap_or_else(|| sess.dcx().emit_fatal(InvalidTargetFeaturePrefix { feature: s }));
+ if s.is_empty() {
+ return None;
+ }
  // Rustc-specific feature requests like `+crt-static` or `-crt-static`
  // are not passed down to LLVM.
  if RUSTC_SPECIFIC_FEATURES.contains(&feature) {

compiler/rustc_feature/src/unstable.rs

@@ -302,6 +302,7 @@ declare_features! (
  // FIXME: Document these and merge with the list below.
 
  // Unstable `#[target_feature]` directives.
+ (unstable, aarch64_unstable_target_feature, "CURRENT_RUSTC_VERSION", Some(44839)),
  (unstable, aarch64_ver_target_feature, "1.27.0", Some(44839)),
  (unstable, arm_target_feature, "1.27.0", Some(44839)),
  (unstable, avx512_target_feature, "1.27.0", Some(44839)),

compiler/rustc_index/src/lib.rs

@@ -1,7 +1,7 @@
 // tidy-alphabetical-start
 #![cfg_attr(all(feature = "nightly", test), feature(stmt_expr_attributes))]
 #![cfg_attr(feature = "nightly", allow(internal_features))]
-#![cfg_attr(feature = "nightly", feature(extend_one, new_uninit, step_trait, test))]
+#![cfg_attr(feature = "nightly", feature(extend_one, step_trait, test))]
 #![cfg_attr(feature = "nightly", feature(new_zeroed_alloc))]
 #![warn(unreachable_pub)]
 // tidy-alphabetical-end

compiler/rustc_middle/src/lib.rs

@@ -53,7 +53,6 @@
 #![feature(min_specialization)]
 #![feature(negative_impls)]
 #![feature(never_type)]
-#![feature(new_uninit)]
 #![feature(ptr_alignment_type)]
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]

compiler/rustc_span/src/lib.rs

@@ -26,7 +26,6 @@
 #![feature(let_chains)]
 #![feature(min_specialization)]
 #![feature(negative_impls)]
-#![feature(new_uninit)]
 #![feature(read_buf)]
 #![feature(round_char_boundary)]
 #![feature(rustc_attrs)]

compiler/rustc_span/src/symbol.rs

@@ -356,6 +356,7 @@ symbols! {
  _task_context,
  a32,
  aarch64_target_feature,
+ aarch64_unstable_target_feature,
  aarch64_ver_target_feature,
  abi,
  abi_amdgpu_kernel,
@@ -1897,6 +1898,7 @@ symbols! {
  three_way_compare,
  thumb2,
  thumb_mode: "thumb-mode",
+ time,
  tmm_reg,
  to_owned_method,
  to_string,

compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs

@@ -7,7 +7,7 @@ pub fn target() -> Target {
  llvm_target: "aarch64-unknown-unknown-musl".into(),
  metadata: crate::spec::TargetMetadata {
  description: Some("ARM64 Trusty".into()),
- tier: Some(2),
+ tier: Some(3),
  host_tools: Some(false),
  std: Some(false),
  },

compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs

@@ -8,7 +8,7 @@ pub fn target() -> Target {
  llvm_target: "armv7-unknown-unknown-gnueabi".into(),
  metadata: crate::spec::TargetMetadata {
  description: Some("Armv7-A Trusty".into()),
- tier: Some(2),
+ tier: Some(3),
  host_tools: Some(false),
  std: Some(false),
  },