Stabilize target_feature_11

Author: calebzulawski

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -278,10 +278,9 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 {
                     if tcx.sess.target.is_like_wasm || tcx.sess.opts.actually_rustdoc {
                         // The `#[target_feature]` attribute is allowed on
-                        // WebAssembly targets on all functions, including safe
-                        // ones. Other targets require that `#[target_feature]` is
-                        // only applied to unsafe functions (pending the
-                        // `target_feature_11` feature) because on most targets
+                        // WebAssembly targets on all functions. Prior to stabilizing
+                        // the `target_feature_11` feature, `#[target_feature]` was
+                        // only permitted on safe functions because on most targets
                         // execution of instructions that are not supported is
                         // considered undefined behavior. For WebAssembly which is a
                         // 100% safe target at execution time it's not possible to
@@ -295,17 +294,10 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                         // if a target is documenting some wasm-specific code then
                         // it's not spuriously denied.
                         //
-                        // This exception needs to be kept in sync with allowing
-                        // `#[target_feature]` on `main` and `start`.
-                    } else if !tcx.features().target_feature_11 {
-                        let mut err = feature_err(
-                            &tcx.sess.parse_sess,
-                            sym::target_feature_11,
-                            attr.span,
-                            "`#[target_feature(..)]` can only be applied to `unsafe` functions",
-                        );
-                        err.span_label(tcx.def_span(did), "not an `unsafe` function");
-                        err.emit();
+                        // Now that `#[target_feature]` is permitted on safe functions,
+                        // this exception must still exist for allowing the attribute on
+                        // `main`, `start`, and other functions that are not usually
+                        // allowed.
                     } else {
                         check_target_feature_trait_unsafe(tcx, did, attr.span);
                     }
@@ -535,10 +527,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
     // its parent function, which effectively inherits the features anyway. Boxing this closure
     // would result in this closure being compiled without the inherited target features, but this
     // is probably a poor usage of `#[inline(always)]` and easily avoided by not using the attribute.
-    if tcx.features().target_feature_11
-        && tcx.is_closure(did.to_def_id())
-        && codegen_fn_attrs.inline != InlineAttr::Always
-    {
+    if tcx.is_closure(did.to_def_id()) && codegen_fn_attrs.inline != InlineAttr::Always {
         let owner_id = tcx.parent(did.to_def_id());
         if tcx.def_kind(owner_id).has_codegen_attrs() {
             codegen_fn_attrs

compiler/rustc_feature/src/accepted.rs

@@ -322,6 +322,8 @@ declare_features! (
     (accepted, struct_variant, "1.0.0", None, None),
     /// Allows `#[target_feature(...)]`.
     (accepted, target_feature, "1.27.0", None, None),
+    /// Allows the use of `#[target_feature]` on safe functions.
+    (accepted, target_feature_11, "CURRENT_RUSTC_VERSION", Some(69098), None),
     /// Allows `fn main()` with return types which implements `Termination` (RFC 1937).
     (accepted, termination_trait, "1.26.0", Some(43301), None),
     /// Allows `#[test]` functions where the return type implements `Termination` (RFC 1937).

compiler/rustc_feature/src/active.rs

@@ -558,8 +558,6 @@ declare_features! (
     (active, strict_provenance, "1.61.0", Some(95228), None),
     /// Allows string patterns to dereference values to match them.
     (active, string_deref_patterns, "1.67.0", Some(87121), None),
-    /// Allows the use of `#[target_feature]` on safe functions.
-    (active, target_feature_11, "1.45.0", Some(69098), None),
     /// Allows using `#[thread_local]` on `static` items.
     (active, thread_local, "1.0.0", Some(29594), None),
     /// Allows defining `trait X = A + B;` alias items.

library/core/src/lib.rs

@@ -246,7 +246,6 @@
 #![feature(simd_ffi)]
 #![feature(staged_api)]
 #![feature(stmt_expr_attributes)]
-#![feature(target_feature_11)]
 #![feature(trait_alias)]
 #![feature(transparent_unions)]
 #![feature(try_blocks)]

tests/assembly/closure-inherit-target-feature.rs

@@ -3,7 +3,6 @@
 // make sure the feature is not enabled at compile-time
 // compile-flags: -C opt-level=3 -C target-feature=-sse4.1 -C llvm-args=-x86-asm-syntax=intel
 
-#![feature(target_feature_11)]
 #![crate_type = "rlib"]
 
 use std::arch::x86_64::{__m128, _mm_blend_ps};

tests/codegen/target-feature-inline-closure.rs

@@ -2,7 +2,6 @@
 // compile-flags: -Copt-level=3
 
 #![crate_type = "lib"]
-#![feature(target_feature_11)]
 
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;

tests/mir-opt/inline/inline_compatibility.rs

@@ -5,7 +5,6 @@
 
 #![crate_type = "lib"]
 #![feature(no_sanitize)]
-#![feature(target_feature_11)]
 #![feature(c_variadic)]
 
 // EMIT_MIR inline_compatibility.inlined_target_feature.Inline.diff

tests/ui/asm/x86_64/issue-89875.rs

@@ -2,8 +2,6 @@
 // needs-asm-support
 // only-x86_64
 
-#![feature(target_feature_11)]
-
 use std::arch::asm;
 
 #[target_feature(enable = "avx")]

tests/ui/lang-items/start_lang_item_with_target_feature.rs

@@ -1,7 +1,7 @@
 // only-x86_64
 // check-fail
 
-#![feature(lang_items, no_core, target_feature_11)]
+#![feature(lang_items, no_core)]
 #![no_core]
 
 #[lang = "copy"]

tests/ui/panic-handler/panic-handler-with-target-feature.rs

@@ -1,7 +1,6 @@
 // compile-flags:-C panic=abort
 // only-x86_64
 
-#![feature(target_feature_11)]
 #![no_std]
 #![no_main]