Rollup of 9 pull requests

Cargo.lock

@@ -561,9 +561,9 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cfg_aliases"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
 
 [[package]]
 name = "chacha20"
@@ -1400,10 +1400,11 @@ dependencies = [
 
 [[package]]
 name = "eyre"
-version = "0.6.12"
+version = "0.6.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cd915d99f24784cdc19fd37ef22b97e3ff0ae756c7e492e9fbfe897d61e2aec"
+checksum = "c08309dbcc659c5549a24ddb9b27027640641b282ef5768267c7e675558986a3"
 dependencies = [
+ "autocfg",
  "indenter",
  "once_cell",
 ]

compiler/rustc_codegen_ssa/src/diagnostics.rs

@@ -1193,6 +1193,12 @@ pub(crate) struct XcrunSdkPathWarning {
 #[diag("enabling the `neon` target feature on the current target is unsound due to ABI issues")]
 pub(crate) struct Aarch64SoftfloatNeon;
 
+#[derive(Diagnostic)]
+#[diag(
+    "enabling the `sse` target feature on the current target is unsupported due to LLVM backend issues"
+)]
+pub(crate) struct X86SoftfloatSse;
+
 #[derive(Diagnostic)]
 #[diag("ignoring feature with missing prefix in `-Ctarget-feature`: `{$feature}`")]
 #[note("features must begin with a `+` to enable or `-` to disable it")]

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -3,7 +3,7 @@ use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_hir::attrs::InstructionSetAttr;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
-use rustc_lint_defs::builtin::AARCH64_SOFTFLOAT_NEON;
+use rustc_lint_defs::builtin::{AARCH64_SOFTFLOAT_NEON, X86_SOFTFLOAT_SSE};
 use rustc_middle::middle::codegen_fn_attrs::{TargetFeature, TargetFeatureKind};
 use rustc_middle::query::Providers;
 use rustc_middle::ty::TyCtxt;
@@ -99,13 +99,24 @@ pub(crate) fn from_target_feature_attr(
                     if abi_feature_constraints.incompatible.contains(&name.as_str()) {
                         // For "neon" specifically, we emit an FCW instead of a hard error.
                         // See <https://github.com/rust-lang/rust/issues/134375>.
+                        // Similar for "sse" on x86.
+                        // See <https://github.com/rust-lang/rust/issues/117938>.
                         if tcx.sess.target.arch == Arch::AArch64 && name.as_str() == "neon" {
                             tcx.emit_node_span_lint(
                                 AARCH64_SOFTFLOAT_NEON,
                                 tcx.local_def_id_to_hir_id(did),
                                 feature_span,
                                 diagnostics::Aarch64SoftfloatNeon,
                             );
+                        } else if matches!(tcx.sess.target.arch, Arch::X86 | Arch::X86_64)
+                            && name.as_str() == "sse"
+                        {
+                            tcx.emit_node_span_lint(
+                                X86_SOFTFLOAT_SSE,
+                                tcx.local_def_id_to_hir_id(did),
+                                feature_span,
+                                diagnostics::X86SoftfloatSse,
+                            );
                         } else {
                             tcx.dcx().emit_err(diagnostics::InternalOnlyTargetFeatureAttr {
                                 span: feature_span,

compiler/rustc_lint_defs/src/builtin.rs

@@ -157,6 +157,7 @@ pub mod hardwired {
             USELESS_DEPRECATED,
             VARARGS_WITHOUT_PATTERN,
             WARNINGS,
+            X86_SOFTFLOAT_SSE,
             // tidy-alphabetical-end
         ]
     }
@@ -5367,14 +5368,53 @@ declare_lint! {
     /// on this target due to this issue, but the problem was not known at the time of
     /// stabilization.
     pub AARCH64_SOFTFLOAT_NEON,
-    Warn,
+    Deny,
     "detects code that could be affected by ABI issues on aarch64 softfloat targets",
     @future_incompatible = FutureIncompatibleInfo {
         reason: fcw!(FutureReleaseError #134375),
         report_in_deps: true,
     };
 }
 
+declare_lint! {
+    /// The `x86_softfloat_sse` lint detects usage of `#[target_feature(enable = "sse")]` or target
+    /// features that imply SSE on softfloat x86 and x86-64 targets. Enabling this target feature
+    /// in a soft-float configuration is not supported by LLVM and can lead to crashes.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,ignore (needs x86_64-unknown-none)
+    /// #[target_feature(enable = "avx")]
+    /// fn with_avx() {}
+    /// ```
+    ///
+    /// This will produce:
+    ///
+    /// ```text
+    /// error: enabling the `sse` target feature on the current target is unsupported due to LLVM backend issues
+    ///   --> $DIR/abi-incompatible-target-feature-attribute-fcw.rs:11:18
+    ///    |
+    ///    | #[target_feature(enable = "avx")]
+    ///    |                  ^^^^^^^^^^^^^^^
+    ///    |
+    ///    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    ///    = note: for more information, see issue #117938 <https://github.com/rust-lang/rust/issues/117938>
+    /// ```
+    ///
+    /// ### Explanation
+    ///
+    /// LLVM does not support combining the `soft-float` target feature (which is implicitly enabled
+    /// on these targets) with `sse`. This can lead to crashes of the backend. To prevent that,
+    /// Rust is turning that combination into an error.
+    pub X86_SOFTFLOAT_SSE,
+    Deny,
+    "detects code that could be affected by LLVM backend issues on x86 softfloat targets",
+    @future_incompatible = FutureIncompatibleInfo {
+        reason: fcw!(FutureReleaseError #117938),
+        report_in_deps: true,
+    };
+}
+
 declare_lint! {
     /// The `tail_call_track_caller` lint detects usage of `become` attempting to tail call
     /// a function marked with `#[track_caller]`.

compiler/rustc_parse/src/diagnostics.rs

@@ -1118,6 +1118,27 @@ pub(crate) struct ArrayBracketsInsteadOfBracesSugg {
     pub right: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("attributes are not allowed inside imports")]
+pub(crate) struct AttrInUseTree {
+    #[primary_span]
+    pub attr_span: Span,
+    #[subdiagnostic]
+    pub sub: Option<AttrInUseTreeSugg>,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion("move the import to its own item", style = "verbose")]
+pub(crate) struct AttrInUseTreeSugg {
+    #[suggestion_part(code = "{code}")]
+    pub use_lo: Span,
+    #[suggestion_part(code = "")]
+    pub attr_span: Span,
+    #[suggestion_part(code = "")]
+    pub tree_span: Span,
+    pub code: String,
+}
+
 #[derive(Diagnostic)]
 #[diag("`match` arm body without braces")]
 pub(crate) struct MatchArmBodyWithoutBraces {

compiler/rustc_parse/src/parser/attr.rs

@@ -310,11 +310,15 @@ impl<'a> Parser<'a> {
     /// Parses an inner part of an attribute (the path and following tokens).
     /// The tokens must be either a delimited token stream, or empty token stream,
     /// or the "legacy" key-value form.
-    ///     PATH `(` TOKEN_STREAM `)`
-    ///     PATH `[` TOKEN_STREAM `]`
-    ///     PATH `{` TOKEN_STREAM `}`
-    ///     PATH
-    ///     PATH `=` UNSUFFIXED_LIT
+    ///
+    /// ```text
+    /// PATH `(` TOKEN_STREAM `)`
+    /// PATH `[` TOKEN_STREAM `]`
+    /// PATH `{` TOKEN_STREAM `}`
+    /// PATH
+    /// PATH `=` UNSUFFIXED_LIT
+    /// ```
+    ///
     /// The delimiters or `=` are still put into the resulting token stream.
     pub fn parse_attr_item(
         &mut self,

compiler/rustc_parse/src/parser/item.rs

@@ -434,7 +434,8 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_use_item(&mut self) -> PResult<'a, ItemKind> {
-        let tree = self.parse_use_tree()?;
+        let use_token_span = self.prev_token.span;
+        let tree = self.parse_use_tree(use_token_span, None)?;
         if let Err(mut e) = self.expect_semi() {
             match tree.kind {
                 UseTreeKind::Glob(_) => {
@@ -1317,7 +1318,11 @@ impl<'a> Parser<'a> {
     ///            PATH `::` `{` USE_TREE_LIST `}` |
     ///            PATH [`as` IDENT]
     /// ```
-    fn parse_use_tree(&mut self) -> PResult<'a, UseTree> {
+    fn parse_use_tree<'b>(
+        &mut self,
+        use_token_span: Span,
+        use_path: Option<&'b UsePathList<'b>>,
+    ) -> PResult<'a, UseTree> {
         let lo = self.token.span;
 
         let mut prefix = ast::Path { segments: ThinVec::new(), span: lo.shrink_to_lo() };
@@ -1331,13 +1336,14 @@ impl<'a> Parser<'a> {
                         .push(PathSegment::path_root(lo.shrink_to_lo().with_ctxt(mod_sep_ctxt)));
                 }
 
-                self.parse_use_tree_glob_or_nested()?
+                self.parse_use_tree_glob_or_nested(use_token_span, use_path)?
             } else {
                 // `use path::*;` or `use path::{...};` or `use path;` or `use path as bar;`
                 prefix = self.parse_path(PathStyle::Mod)?;
 
                 if self.eat_path_sep() {
-                    self.parse_use_tree_glob_or_nested()?
+                    let use_path = UsePathList { elements: &prefix.segments, prev: use_path };
+                    self.parse_use_tree_glob_or_nested(use_token_span, Some(&use_path))?
                 } else {
                     // Recover from using a colon as path separator.
                     while self.eat_noexpect(&token::Colon) {
@@ -1358,13 +1364,17 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses `*` or `{...}`.
-    fn parse_use_tree_glob_or_nested(&mut self) -> PResult<'a, UseTreeKind> {
+    fn parse_use_tree_glob_or_nested<'b>(
+        &mut self,
+        use_token_span: Span,
+        use_path: Option<&'b UsePathList<'b>>,
+    ) -> PResult<'a, UseTreeKind> {
         Ok(if self.eat(exp!(Star)) {
             UseTreeKind::Glob(self.prev_token.span)
         } else {
             let lo = self.token.span;
             UseTreeKind::Nested {
-                items: self.parse_use_tree_list()?,
+                items: self.parse_use_tree_list(use_token_span, use_path)?,
                 span: lo.to(self.prev_token.span),
             }
         })
@@ -1375,14 +1385,85 @@ impl<'a> Parser<'a> {
     /// ```text
     /// USE_TREE_LIST = ∅ | (USE_TREE `,`)* USE_TREE [`,`]
     /// ```
-    fn parse_use_tree_list(&mut self) -> PResult<'a, ThinVec<(UseTree, ast::NodeId)>> {
+    fn parse_use_tree_list<'b>(
+        &mut self,
+        use_token_span: Span,
+        prefix: Option<&'b UsePathList<'b>>,
+    ) -> PResult<'a, ThinVec<(UseTree, ast::NodeId)>> {
         self.parse_delim_comma_seq(exp!(OpenBrace), exp!(CloseBrace), |p| {
             p.recover_vcs_conflict_marker();
-            Ok((p.parse_use_tree()?, DUMMY_NODE_ID))
+
+            let mut attr_span = None;
+            let attrs = p.parse_outer_attributes()?;
+            if !attrs.is_empty() {
+                let raw_attrs = attrs.take_for_recovery(&p.psess);
+                attr_span =
+                    Some(raw_attrs.first().unwrap().span.to(raw_attrs.last().unwrap().span));
+            }
+
+            let use_tree = p.parse_use_tree(use_token_span, prefix)?;
+
+            if let Some(attr_span) = attr_span {
+                p.emit_error_attr_in_use_tree(use_token_span, prefix, use_tree.span(), attr_span);
+            }
+
+            Ok((use_tree, DUMMY_NODE_ID))
         })
         .map(|(r, _)| r)
     }
 
+    fn emit_error_attr_in_use_tree(
+        &self,
+        use_token_span: Span,
+        mut prefix: Option<&UsePathList<'_>>,
+        use_tree_span: Span,
+        attr_span: Span,
+    ) {
+        let Ok(attr) = self.psess.source_map().span_to_snippet(attr_span) else { return };
+
+        let prefix: Vec<_> = {
+            let mut tmp = Vec::new();
+            while let Some(prefix_) = prefix {
+                tmp.push(prefix_.elements);
+                prefix = prefix_.prev;
+            }
+            tmp.reverse();
+            tmp.into_iter().flatten().collect()
+        };
+
+        let prefix: String = prefix
+            .iter()
+            .map(|seg| if seg.ident.name == kw::PathRoot { "" } else { seg.ident.as_str() })
+            .intersperse("::")
+            .collect();
+
+        let mut comma_reached = false;
+        let Ok(tree_span) = self.psess.source_map().span_extend_while(use_tree_span, |c| {
+            if comma_reached {
+                return false;
+            }
+            comma_reached = c == ',';
+            c.is_whitespace() || comma_reached
+        }) else {
+            return;
+        };
+
+        let Ok(use_tree) = self.psess.source_map().span_to_snippet(use_tree_span) else { return };
+
+        // FIXME: duplicate the attributes that are at the root of the initial use-item.
+        let code = format!("{attr}\nuse {prefix}::{use_tree};\n");
+
+        self.dcx().emit_err(crate::diagnostics::AttrInUseTree {
+            attr_span,
+            sub: Some(crate::diagnostics::AttrInUseTreeSugg {
+                use_lo: use_token_span.shrink_to_lo(),
+                attr_span,
+                tree_span,
+                code,
+            }),
+        });
+    }
+
     fn parse_rename(&mut self) -> PResult<'a, Option<Ident>> {
         if self.eat_keyword(exp!(As)) {
             self.parse_ident_or_underscore().map(Some)
@@ -2737,7 +2818,13 @@ impl<'a> Parser<'a> {
         }
     }
 }
+
 enum IsMacroRulesItem {
     Yes { has_bang: bool },
     No,
 }
+
+struct UsePathList<'a> {
+    elements: &'a [ast::PathSegment],
+    prev: Option<&'a Self>,
+}

compiler/rustc_span/src/source_map.rs

@@ -596,9 +596,13 @@ impl SourceMap {
     /// Extracts the source surrounding the given `Span` using the `extract_source` function. The
     /// extract function takes three arguments: a string slice containing the source, an index in
     /// the slice for the beginning of the span and an index in the slice for the end of the span.
-    pub fn span_to_source<F, T>(&self, sp: Span, extract_source: F) -> Result<T, SpanSnippetError>
+    pub fn span_to_source<F, T>(
+        &self,
+        sp: Span,
+        mut extract_source: F,
+    ) -> Result<T, SpanSnippetError>
     where
-        F: Fn(&str, usize, usize) -> Result<T, SpanSnippetError>,
+        F: FnMut(&str, usize, usize) -> Result<T, SpanSnippetError>,
     {
         let local_begin = self.lookup_byte_offset(sp.lo());
         let local_end = self.lookup_byte_offset(sp.hi());
@@ -753,7 +757,7 @@ impl SourceMap {
     pub fn span_extend_while(
         &self,
         span: Span,
-        f: impl Fn(char) -> bool,
+        mut f: impl FnMut(char) -> bool,
     ) -> Result<Span, SpanSnippetError> {
         self.span_to_source(span, |s, _start, end| {
             let n = s[end..].char_indices().find(|&(_, c)| !f(c)).map_or(s.len() - end, |(i, _)| i);

compiler/rustc_target/src/target_features.rs

@@ -1293,7 +1293,9 @@ impl Target {
                         // `x87` and all other FPU features so those do not matter.
                         // Note that this one requirement is the entire implementation of the ABI!
                         // LLVM handles the rest.
-                        FeatureConstraints { required: &["soft-float"], incompatible: &[] }
+                        // We mark "sse" as incompatible since LLVM likes to crash when both
+                        // "soft-float" and "sse" are enabled.
+                        FeatureConstraints { required: &["soft-float"], incompatible: &["sse"] }
                     }
                     _ => unreachable!(),
                 }
@@ -1314,7 +1316,9 @@ impl Target {
                         // `x87` and all other FPU features so those do not matter.
                         // Note that this one requirement is the entire implementation of the ABI!
                         // LLVM handles the rest.
-                        FeatureConstraints { required: &["soft-float"], incompatible: &[] }
+                        // We mark "sse" as incompatible since LLVM likes to crash when both
+                        // "soft-float" and "sse" are enabled.
+                        FeatureConstraints { required: &["soft-float"], incompatible: &["sse"] }
                     }
                     _ => unreachable!(),
                 }