Require annotating struct-tf functions explicitly.

Author: veluca93

compiler/rustc_codegen_ssa/messages.ftl

@@ -238,7 +238,7 @@ codegen_ssa_stripping_debug_info_failed = stripping debug info with `{$util}` fa
 
 codegen_ssa_symbol_file_write_failure = failed to write symbols file: {$error}
 
-codegen_ssa_target_feature_safe_trait = `#[target_feature(..)]` cannot be applied to safe trait method
+codegen_ssa_target_feature_safe_trait = `#[target_feature(enable = ..)]` cannot be applied to safe trait method
     .label = cannot be applied to safe trait method
     .label_def = not an `unsafe` function
 

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -1,12 +1,12 @@
-use rustc_ast::{ast, attr, MetaItemKind, NestedMetaItem};
-use rustc_attr::{list_contains_name, InlineAttr, InstructionSetAttr, OptimizeAttr};
+use rustc_ast::{MetaItemKind, NestedMetaItem, ast, attr};
+use rustc_attr::{InlineAttr, InstructionSetAttr, OptimizeAttr, list_contains_name};
 use rustc_errors::codes::*;
-use rustc_errors::{struct_span_code_err, DiagMessage, SubdiagMessage};
+use rustc_errors::{DiagMessage, SubdiagMessage, struct_span_code_err};
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
-use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE};
+use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::weak_lang_items::WEAK_LANG_ITEMS;
-use rustc_hir::{lang_items, LangItem};
+use rustc_hir::{LangItem, lang_items};
 use rustc_middle::middle::codegen_fn_attrs::{
     CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry, TargetFeature,
 };
@@ -16,8 +16,8 @@ use rustc_middle::ty::{self as ty, Ty, TyCtxt};
 use rustc_session::lint;
 use rustc_session::parse::feature_err;
 use rustc_span::symbol::Ident;
-use rustc_span::{sym, Span};
-use rustc_target::spec::{abi, SanitizerSet};
+use rustc_span::{Span, sym};
+use rustc_target::spec::{SanitizerSet, abi};
 
 use crate::errors;
 use crate::target_features::{check_target_feature_trait_unsafe, from_target_feature};
@@ -82,11 +82,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         use DefKind::*;
 
         let def_kind = tcx.def_kind(did);
-        if let Fn | AssocFn | Variant | Ctor(..) = def_kind {
-            Some(tcx.fn_sig(did))
-        } else {
-            None
-        }
+        if let Fn | AssocFn | Variant | Ctor(..) = def_kind { Some(tcx.fn_sig(did)) } else { None }
     };
 
     for attr in attrs.iter() {
@@ -253,7 +249,12 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                     && let Some(fn_sig) = fn_sig()
                     && fn_sig.skip_binder().safety() == hir::Safety::Safe
                 {
-                    if tcx.sess.target.is_like_wasm || tcx.sess.opts.actually_rustdoc {
+                    if attr.meta_item_list().is_some_and(|list| {
+                        list.len() == 1 && list[0].ident().is_some_and(|x| x.name == sym::from_args)
+                    }) {
+                        // #[target_feature(from_args)] can be applied to safe functions and safe
+                        // trait methods.
+                    } else 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
@@ -292,6 +293,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                     attr,
                     supported_target_features,
                     &mut codegen_fn_attrs.target_features,
+                    Some(&mut codegen_fn_attrs.target_features_from_args),
                 );
             }
             sym::linkage => {
@@ -602,7 +604,9 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         }
     }
 
-    if let Some(sig) = fn_sig_outer() {
+    if let Some(sig) = fn_sig_outer()
+        && codegen_fn_attrs.target_features_from_args
+    {
         let mut additional_tf = vec![];
         for ty in sig.skip_binder().inputs().skip_binder() {
             extend_with_struct_target_features(
@@ -769,7 +773,7 @@ fn struct_target_features(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &[TargetFeatur
     let mut features = vec![];
     let supported_features = tcx.supported_target_features(LOCAL_CRATE);
     for attr in tcx.get_attrs(def_id, sym::target_feature) {
-        from_target_feature(tcx, attr, supported_features, &mut features);
+        from_target_feature(tcx, attr, supported_features, &mut features, None);
     }
     tcx.arena.alloc_slice(&features)
 }

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -20,6 +20,7 @@ pub(crate) fn from_target_feature(
     attr: &ast::Attribute,
     supported_target_features: &UnordMap<String, Option<Symbol>>,
     target_features: &mut Vec<TargetFeature>,
+    mut features_from_args: Option<&mut bool>,
 ) {
     let Some(list) = attr.meta_item_list() else { return };
     let bad_item = |span| {
@@ -33,6 +34,14 @@ pub(crate) fn from_target_feature(
     let rust_features = tcx.features();
     let mut added_target_features = Vec::new();
     for item in list {
+        if let Some(ref mut from_args) = features_from_args
+            && item.ident().is_some_and(|x| x.name == sym::from_args)
+            && tcx.features().struct_target_features
+        {
+            **from_args = true;
+            continue;
+        }
+
         // Only `enable = ...` is accepted in the meta-item list.
         if !item.has_name(sym::enable) {
             bad_item(item.span());
@@ -144,7 +153,7 @@ fn asm_target_features(tcx: TyCtxt<'_>, did: DefId) -> &FxIndexSet<Symbol> {
     tcx.arena.alloc(target_features)
 }
 
-/// Checks the function annotated with `#[target_feature]` is not a safe
+/// Checks the function annotated with `#[target_feature(enable = ...)]` is not a safe
 /// trait method implementation, reporting an error if it is.
 pub(crate) fn check_target_feature_trait_unsafe(tcx: TyCtxt<'_>, id: LocalDefId, attr_span: Span) {
     if let DefKind::AssocFn = tcx.def_kind(id) {

compiler/rustc_middle/src/middle/codegen_fn_attrs.rs

@@ -49,6 +49,8 @@ pub struct CodegenFnAttrs {
     /// The `#[patchable_function_entry(...)]` attribute. Indicates how many nops should be around
     /// the function entry.
     pub patchable_function_entry: Option<PatchableFunctionEntry>,
+    /// Whether the target features can be extended through the arguments of the function.
+    pub target_features_from_args: bool,
 }
 
 #[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)]
@@ -156,6 +158,7 @@ impl CodegenFnAttrs {
             instruction_set: None,
             alignment: None,
             patchable_function_entry: None,
+            target_features_from_args: false,
         }
     }
 

compiler/rustc_mir_build/src/check_unsafety.rs

@@ -589,14 +589,11 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                             .copied()
                             .filter(|feature| missing.contains(feature))
                             .collect();
-                        self.requires_unsafe(
-                            expr.span,
-                            ConstructingTargetFeaturesTypeWith {
-                                adt: adt_def.did(),
-                                missing,
-                                build_enabled,
-                            },
-                        );
+                        self.requires_unsafe(expr.span, ConstructingTargetFeaturesTypeWith {
+                            adt: adt_def.did(),
+                            missing,
+                            build_enabled,
+                        });
                     }
                 }
             }

compiler/rustc_span/src/symbol.rs

@@ -941,6 +941,7 @@ symbols! {
         frem_algebraic,
         frem_fast,
         from,
+        from_args,
         from_desugaring,
         from_fn,
         from_iter,

tests/assembly/struct-target-features.rs

@@ -15,12 +15,20 @@ struct Avx {}
 #[target_feature(enable = "fma")]
 struct Fma {}
 
+#[target_feature(from_args)]
 pub fn add_simple(_: Avx, v: __m256) -> __m256 {
     // CHECK-NOT: call
     // CHECK: vaddps
     unsafe { _mm256_add_ps(v, v) }
 }
 
+// Test that the features don't get inherited from the arguments without the attribute.
+pub fn add_simple_noattr(_: Avx, v: __m256) -> __m256 {
+    // CHECK: call
+    unsafe { _mm256_add_ps(v, v) }
+}
+
+#[target_feature(from_args)]
 pub fn add_fma_combined(_: &Avx, _: &Fma, v: __m256) -> (__m256, __m256) {
     // CHECK-NOT: call
     // CHECK-DAG: vaddps

tests/ui/rfcs/rfc-2396-target_feature-11/trait-impl.stderr

@@ -1,4 +1,4 @@
-error: `#[target_feature(..)]` cannot be applied to safe trait method
+error: `#[target_feature(enable = ..)]` cannot be applied to safe trait method
   --> $DIR/trait-impl.rs:13:5
    |
 LL |     #[target_feature(enable = "sse2")]
@@ -7,7 +7,7 @@ LL |
 LL |     fn foo(&self) {}
    |     ------------- not an `unsafe` function
 
-error: `#[target_feature(..)]` cannot be applied to safe trait method
+error: `#[target_feature(enable = ..)]` cannot be applied to safe trait method
   --> $DIR/trait-impl.rs:22:5
    |
 LL |     #[target_feature(enable = "sse2")]

tests/ui/target-feature/struct-target-features-crate.rs

@@ -2,12 +2,15 @@
 //@ aux-build: struct-target-features-crate-dep.rs
 //@ check-pass
 #![feature(target_feature_11)]
+#![feature(struct_target_features)]
+//~^ WARNING the feature `struct_target_features` is incomplete and may not be safe to use and/or cause compiler crashes
 
 extern crate struct_target_features_crate_dep;
 
 #[target_feature(enable = "avx")]
 fn avx() {}
 
+#[target_feature(from_args)]
 fn f(_: struct_target_features_crate_dep::Avx) {
     avx();
 }

tests/ui/target-feature/struct-target-features-crate.stderr

@@ -0,0 +1,11 @@
+warning: the feature `struct_target_features` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/struct-target-features-crate.rs:5:12
+   |
+LL | #![feature(struct_target_features)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #129107 <https://github.com/rust-lang/rust/issues/129107> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: 1 warning emitted
+