Rollup of 11 pull requests

Cargo.lock

@@ -4430,6 +4430,7 @@ dependencies = [
  "rustc_arena",
  "rustc_ast",
  "rustc_ast_ir",
+ "rustc_attr_ir",
  "rustc_crate_store",
  "rustc_data_structures",
  "rustc_errors",

compiler/rustc_attr_ir/src/data_structures.rs

@@ -1420,9 +1420,6 @@ pub enum AttributeKind {
     /// Represents `#[rustc_strict_coherence]`.
     RustcStrictCoherence(Span),
 
-    /// Represents `#[rustc_test_entrypoint_marker]`
-    RustcTestEntrypointMarker,
-
     /// Represents `#[rustc_test_marker]`
     RustcTestMarker(Symbol),
 

compiler/rustc_attr_ir/src/encode_cross_crate.rs

@@ -191,7 +191,6 @@ impl AttributeKind {
             RustcSpecializationTrait => No,
             RustcStdInternalSymbol => No,
             RustcStrictCoherence(..) => Yes,
-            RustcTestEntrypointMarker => No,
             RustcTestMarker(..) => No,
             RustcThenThisWouldNeed(..) => No,
             RustcTrivialFieldReads => Yes,

compiler/rustc_attr_ir/src/lib.rs

@@ -1,7 +1,7 @@
 //! Data structures for representing parsed attributes in the Rust compiler.
 //!
 //! For detailed documentation about attribute processing,
-//! see [rustc_attr_parsing](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_attr_parsing/index.html).
+//! see [rustc_attr_parsing](../rustc_attr_parsing/index.html).
 
 // tidy-alphabetical-start
 #![feature(const_default)]
@@ -20,7 +20,6 @@ pub use lang_items::*;
 pub use pretty_printing::PrintAttribute;
 pub use stability::*;
 
-// FIXME remove pub on some of these modules? It's fairly inconsistent.
 mod attr;
 mod canonical_symbols;
 mod data_structures;
@@ -35,40 +34,38 @@ pub mod weak_lang_items;
 
 /// A trait for types that can provide a list of attributes given a `TyCtxt`.
 ///
-/// It allows `find_attr!` to accept either a `DefId`, `LocalDefId`, `OwnerId`, or `HirId`.
-/// It is defined here with a generic `Tcx` because `rustc_hir` can't depend on `rustc_middle`.
-/// The concrete implementations are in `rustc_middle`.
+/// It is an implementation detail of the [`find_attr!`] macro to be able to accept either a
+/// [`DefId`], [`LocalDefId`], [`OwnerId`], or [`HirId`]. It is defined here with a generic `Tcx`
+/// because this crate can't depend on `rustc_middle`. The concrete implementations are in
+/// `rustc_middle`.
+///
+/// Not to be confused with [`rustc_ast::ast_traits::HasAttrs`].
+///
+/// [`DefId`]: rustc_span::def_id::DefId
+/// [`LocalDefId`]: rustc_span::def_id::LocalDefId
+/// [`OwnerId`]: ../rustc_hir/struct.OwnerId.html
+/// [`HirId`]: ../rustc_hir/struct.HirId.html
 pub trait HasAttrs<'tcx, Tcx> {
-    fn get_attrs(self, tcx: &Tcx) -> &'tcx [crate::attr::Attribute];
+    fn get_attrs(self, tcx: &Tcx) -> &'tcx [crate::Attribute];
 }
 
-/// Finds attributes in sequences of attributes by pattern matching.
+/// Finds attributes by pattern matching.
 ///
 /// A little like `matches` but for attributes.
 ///
-/// ```rust,ignore (illustrative)
-/// // finds the repr attribute
-/// if let Some(r) = find_attr!(attrs, AttributeKind::Repr(r) => r) {
-///
-/// }
-///
-/// // checks if one has matched
-/// if find_attr!(attrs, AttributeKind::Repr(_)) {
-///
-/// }
-/// ```
+/// Note that this macro accepts several "id" types: [`DefId`], [`LocalDefId`], [`OwnerId`] and
+/// [`HirId`].
 ///
-/// Often this requires you to first end up with a list of attributes.
-/// Often these are available through the `tcx`.
+/// # Examples
 ///
-/// As a convenience, this macro can do that for you!
+/// It is most commonly used to check whether something has an attribute or to get its contents
+/// if it is present:
+/// ```rust,ignore (illustrative)
+/// let is_naked: bool = find_attr!(tcx, def_id, Naked(..));
 ///
-/// Instead of providing an attribute list, provide the `tcx` and an id
-/// (a `DefId`, `LocalDefId`, `OwnerId` or `HirId`).
+/// let is_visible: bool = find_attr!(tcx, def_id, Doc(doc) if doc.hidden.is_none());
 ///
-/// ```rust,ignore (illustrative)
-/// find_attr!(tcx, def_id, <pattern>)
-/// find_attr!(tcx, hir_id, <pattern>)
+/// let link_name: Option<Symbol> = find_attr!(tcx, def_id, LinkName { name, .. } => *name);
 /// ```
 ///
 /// Another common case is finding attributes applied to the root of the current crate.
@@ -77,6 +74,27 @@ pub trait HasAttrs<'tcx, Tcx> {
 /// ```rust, ignore (illustrative)
 /// find_attr!(tcx, crate, <pattern>)
 /// ```
+///
+/// If you already have a list of attributes in scope, you can also use that:
+///
+/// ```rust,ignore (illustrative)
+/// let attrs = <list of attributes>;
+///
+/// // finds the repr attribute
+/// if let Some(r) = find_attr!(attrs, Repr(r) => r) {
+///
+/// }
+///
+/// // checks if one has matched
+/// if find_attr!(attrs, Repr(_)) {
+///
+/// }
+/// ```
+///
+/// [`DefId`]: rustc_span::def_id::DefId
+/// [`LocalDefId`]: rustc_span::def_id::LocalDefId
+/// [`OwnerId`]: ../rustc_hir/struct.OwnerId.html
+/// [`HirId`]: ../rustc_hir/struct.HirId.html
 #[macro_export]
 macro_rules! find_attr {
     ($tcx: expr, crate, $pattern: pat $(if $guard: expr)?) => {
@@ -89,14 +107,14 @@ macro_rules! find_attr {
     ($tcx: expr, $id: expr, $pattern: pat $(if $guard: expr)?) => {
         $crate::find_attr!($tcx, $id, $pattern $(if $guard)? => ()).is_some()
     };
+
     ($tcx: expr, $id: expr, $pattern: pat $(if $guard: expr)? => $e: expr) => {{
         $crate::find_attr!(
             $crate::HasAttrs::get_attrs($id, &$tcx),
             $pattern $(if $guard)? => $e
         )
     }};
 
-
     ($attributes_list: expr, $pattern: pat $(if $guard: expr)?) => {{
         $crate::find_attr!($attributes_list, $pattern $(if $guard)? => ()).is_some()
     }};

compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs

@@ -361,7 +361,7 @@ fn parse_directive_items<'p>(
                         WrappedParserError {
                             description: e.description,
                             label: e.label,
-                            span: slice_span(input.span, e.span.clone(), is_snippet),
+                            span: slice_span(input.span, e.span, is_snippet),
                         },
                         input.span,
                     );

compiler/rustc_attr_parsing/src/attributes/test_attrs.rs

@@ -214,14 +214,3 @@ impl SingleAttributeParser for RustcTestMarkerParser {
         Some(AttributeKind::RustcTestMarker(value_str))
     }
 }
-
-pub(crate) struct RustcTestEntrypointMarkerParser;
-
-impl NoArgsAttributeParser for RustcTestEntrypointMarkerParser {
-    const PATH: &[Symbol] = &[sym::rustc_test_entrypoint_marker];
-    const ALLOWED_TARGETS: AllowedTargets<'_> =
-        AllowedTargets::AllowList(&[Allow(Target::Fn), Allow(Target::Closure)]);
-    const ON_DUPLICATE: OnDuplicate = OnDuplicate::Warn;
-    const STABILITY: AttributeStability = unstable!(rustc_attrs);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcTestEntrypointMarker;
-}

compiler/rustc_attr_parsing/src/context.rs

@@ -353,7 +353,6 @@ attribute_parsers!(
         Single<WithoutArgs<RustcSpecializationTraitParser>>,
         Single<WithoutArgs<RustcStdInternalSymbolParser>>,
         Single<WithoutArgs<RustcStrictCoherenceParser>>,
-        Single<WithoutArgs<RustcTestEntrypointMarkerParser>>,
         Single<WithoutArgs<RustcTrivialFieldReadsParser>>,
         Single<WithoutArgs<SplatParser>>,
         Single<WithoutArgs<ThreadLocalParser>>,

compiler/rustc_builtin_macros/src/env.rs

@@ -40,7 +40,7 @@ pub(crate) fn expand_option_env<'cx>(
         Err(guar) => return ExpandResult::Ready(DummyResult::any(sp, guar)),
     };
     let ExpandResult::Ready(mac) =
-        expr_to_string(cx, var_expr.clone(), "argument must be a string literal")
+        expr_to_string(cx, var_expr, "argument must be a string literal")
     else {
         return ExpandResult::Retry(());
     };

compiler/rustc_builtin_macros/src/offload.rs

@@ -134,9 +134,9 @@ pub(crate) fn expand_kernel(
     // host function
     let mut host_fn = Box::new(ast::Fn {
         defaultness: ast::Defaultness::Implicit,
-        sig: sig.clone(),
+        sig,
         ident,
-        generics: generics.clone(),
+        generics,
         contract: None,
         body: Some(body),
         define_opaque: None,
@@ -176,7 +176,7 @@ pub(crate) fn expand_kernel(
             thin_vec![rustc_offload_kernel, inline_never],
             ast::ItemKind::Fn(host_fn),
         );
-        item.vis = vis.clone();
+        item.vis = vis;
         Annotatable::Item(item)
     };
 

compiler/rustc_builtin_macros/src/test.rs

@@ -23,9 +23,6 @@ use crate::util::{check_builtin_macro_attribute, warn_on_duplicate_attribute};
 ///
 /// We mark item with an inert attribute "rustc_test_marker" which the test generation
 /// logic will pick up on.
-///
-/// The test function also gains a `#[rustc_test_entrypoint_marker]` attribute for tools to pick up
-/// on. This behavior is *unstable*.
 pub(crate) fn expand_test_case(
     ecx: &mut ExtCtxt<'_>,
     attr_sp: Span,
@@ -380,12 +377,6 @@ pub(crate) fn expand_test_or_bench(
     let test_extern =
         cx.item(sp, ast::AttrVec::new(), ast::ItemKind::ExternCrate(None, test_ident));
 
-    let item = {
-        let mut item = item;
-        item.attrs.push(cx.attr_word(sym::rustc_test_entrypoint_marker, attr_sp));
-        item
-    };
-
     debug!("synthetic test item:\n{}\n", pprust::item_to_string(&test_const));
 
     if is_stmt {

compiler/rustc_codegen_cranelift/src/global_asm.rs

@@ -30,6 +30,7 @@ impl<'tcx> AsmCodegenMethods<'tcx> for GlobalAsmContext<'_, 'tcx> {
         operands: &[GlobalAsmOperandRef<'tcx>],
         options: InlineAsmOptions,
         _line_spans: &[Span],
+        _target_features: &[String],
     ) {
         codegen_global_asm_inner(self.tcx, self.global_asm, template, operands, options);
     }

compiler/rustc_codegen_gcc/src/asm.rs

@@ -929,6 +929,7 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         operands: &[GlobalAsmOperandRef<'tcx>],
         options: InlineAsmOptions,
         line_spans: &[Span],
+        _target_features: &[String],
     ) {
         let asm_arch = self.tcx.sess.asm_arch.unwrap();
 

compiler/rustc_codegen_llvm/src/asm.rs

@@ -414,6 +414,7 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
         operands: &[GlobalAsmOperandRef<'tcx>],
         options: InlineAsmOptions,
         _line_spans: &[Span],
+        target_features: &[String],
     ) {
         let asm_arch = self.tcx.sess.asm_arch.unwrap();
 
@@ -499,14 +500,11 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
             template_str.push_str("\n.att_syntax\n");
         }
 
-        let target_features = self.tcx.global_backend_features(()).join(",");
-        let target_cpu = llvm_util::target_cpu(self.tcx.sess);
-
         llvm::append_module_inline_asm(
             self.llmod,
             template_str.as_bytes(),
-            &target_features,
-            target_cpu,
+            &target_features.join(","),
+            llvm_util::target_cpu(self.tcx.sess),
         );
     }
 

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -894,6 +894,8 @@ unsafe extern "C" {
         SLen: c_uint,
     ) -> MetadataKindId;
 
+    pub(crate) fn LLVMGetVersion(major: &mut c_uint, minor: &mut c_uint, patch: &mut c_uint);
+
     pub(crate) fn LLVMDisposeTargetMachine(T: ptr::NonNull<TargetMachine>);
 
     // Create modules.

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -48,6 +48,31 @@ unsafe fn configure_llvm(sess: &Session) {
     let mut llvm_c_strs = Vec::with_capacity(n_args + 1);
     let mut llvm_args = Vec::with_capacity(n_args + 1);
 
+    // Check to ensure we're running against the correct LLVM version.
+    unsafe {
+        let mut llvm_major = 0;
+        let mut llvm_minor = 0;
+        let mut llvm_patch = 0;
+        llvm::LLVMGetVersion(&mut llvm_major, &mut llvm_minor, &mut llvm_patch);
+        let expected_version = llvm::LLVMRustVersionMajor();
+        if llvm_major != expected_version {
+            panic!(
+                concat!(
+                    "LLVM version mismatch: this compiler was built for LLVM {}, ",
+                    "but LLVM {}.{}.{} was found{}"
+                ),
+                expected_version,
+                llvm_major,
+                llvm_minor,
+                llvm_patch,
+                match rustc_session::filesearch::dll_path(llvm::LLVMGetVersion as *mut _) {
+                    Ok(path) => format!(" at {}", path.display()),
+                    Err(_) => String::new(),
+                }
+            );
+        }
+    }
+
     unsafe {
         llvm::LLVMRustInstallErrorHandlers();
     }

compiler/rustc_codegen_ssa/src/base.rs

@@ -490,7 +490,14 @@ where
             })
             .collect();
 
-        cx.codegen_global_asm(asm.template, &operands, asm.options, asm.line_spans);
+        let target_features = cx.tcx().global_backend_features(());
+        cx.codegen_global_asm(
+            asm.template,
+            &operands,
+            asm.options,
+            asm.line_spans,
+            &target_features,
+        );
     } else {
         span_bug!(item.span, "Mismatch between hir::Item type and MonoItem type")
     }

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -54,7 +54,9 @@ pub fn codegen_naked_asm<
     template_vec.extend(template.iter().cloned());
     template_vec.push(rustc_ast::ast::InlineAsmTemplatePiece::String(end.into()));
 
-    cx.codegen_global_asm(&template_vec, &operands, options, line_spans);
+    let target_features: Vec<_> =
+        cx.tcx().asm_target_features(instance.def_id()).iter().map(|s| format!("+{s}")).collect();
+    cx.codegen_global_asm(&template_vec, &operands, options, line_spans, &target_features);
 }
 
 fn inline_to_global_operand<'a, 'tcx, Cx: LayoutOf<'tcx, LayoutOfResult = TyAndLayout<'tcx>>>(

compiler/rustc_codegen_ssa/src/traits/asm.rs

@@ -72,6 +72,7 @@ pub trait AsmCodegenMethods<'tcx> {
         operands: &[GlobalAsmOperandRef<'tcx>],
         options: InlineAsmOptions,
         line_spans: &[Span],
+        target_features: &[String],
     );
 
     /// The mangled name of this instance

compiler/rustc_feature/src/builtin_attrs.rs

@@ -362,7 +362,6 @@ pub static BUILTIN_ATTRIBUTES: &[Symbol] = &[
     sym::prelude_import,
     sym::rustc_paren_sugar,
     sym::rustc_inherit_overflow_checks,
-    sym::rustc_test_entrypoint_marker,
     sym::rustc_test_marker,
     sym::rustc_allow_lifetime_dependent_specialization,
     sym::rustc_specialization_trait,

compiler/rustc_lint_defs/src/builtin.rs

@@ -3657,7 +3657,7 @@ declare_lint! {
     Allow,
     "identifiers that will be parsed as a prefix in Rust 2021",
     @future_incompatible = FutureIncompatibleInfo {
-        reason: fcw!(EditionError 2021 "reserving-syntax"),
+        reason: fcw!(EditionSemanticsChange 2021 "reserving-syntax"),
     };
     crate_level_only
 }

compiler/rustc_middle/Cargo.toml

@@ -15,6 +15,7 @@ rustc_apfloat = "0.2.0"
 rustc_arena = { path = "../rustc_arena" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_ir = { path = "../rustc_ast_ir" }
+rustc_attr_ir = { path = "../rustc_attr_ir" }
 rustc_crate_store = { path = "../rustc_crate_store" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }