rustc_codegen_ssa/
codegen_attrs.rs

1use std::str::FromStr;
2
3use rustc_abi::{Align, ExternAbi};
4use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, DiffActivity, DiffMode};
5use rustc_ast::{LitKind, MetaItem, MetaItemInner, attr};
6use rustc_hir::attrs::{AttributeKind, InlineAttr, InstructionSetAttr, RtsanSetting, UsedBy};
7use rustc_hir::def::DefKind;
8use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
9use rustc_hir::{self as hir, Attribute, LangItem, find_attr, lang_items};
10use rustc_middle::middle::codegen_fn_attrs::{
11    CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry, SanitizerFnAttrs,
12};
13use rustc_middle::query::Providers;
14use rustc_middle::span_bug;
15use rustc_middle::ty::{self as ty, TyCtxt};
16use rustc_session::lint;
17use rustc_session::parse::feature_err;
18use rustc_span::{Ident, Span, sym};
19use rustc_target::spec::Os;
20
21use crate::errors;
22use crate::target_features::{
23    check_target_feature_trait_unsafe, check_tied_features, from_target_feature_attr,
24};
25
26/// In some cases, attributes are only valid on functions, but it's the `check_attr`
27/// pass that checks that they aren't used anywhere else, rather than this module.
28/// In these cases, we bail from performing further checks that are only meaningful for
29/// functions (such as calling `fn_sig`, which ICEs if given a non-function). We also
30/// report a delayed bug, just in case `check_attr` isn't doing its job.
31fn try_fn_sig<'tcx>(
32    tcx: TyCtxt<'tcx>,
33    did: LocalDefId,
34    attr_span: Span,
35) -> Option<ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>>> {
36    use DefKind::*;
37
38    let def_kind = tcx.def_kind(did);
39    if let Fn | AssocFn | Variant | Ctor(..) = def_kind {
40        Some(tcx.fn_sig(did))
41    } else {
42        tcx.dcx().span_delayed_bug(attr_span, "this attribute can only be applied to functions");
43        None
44    }
45}
46
47// FIXME(jdonszelmann): remove when instruction_set becomes a parsed attr
48fn parse_instruction_set_attr(tcx: TyCtxt<'_>, attr: &Attribute) -> Option<InstructionSetAttr> {
49    let list = attr.meta_item_list()?;
50
51    match &list[..] {
52        [MetaItemInner::MetaItem(set)] => {
53            let segments = set.path.segments.iter().map(|x| x.ident.name).collect::<Vec<_>>();
54            match segments.as_slice() {
55                [sym::arm, sym::a32 | sym::t32] if !tcx.sess.target.has_thumb_interworking => {
56                    tcx.dcx().emit_err(errors::UnsupportedInstructionSet { span: attr.span() });
57                    None
58                }
59                [sym::arm, sym::a32] => Some(InstructionSetAttr::ArmA32),
60                [sym::arm, sym::t32] => Some(InstructionSetAttr::ArmT32),
61                _ => {
62                    tcx.dcx().emit_err(errors::InvalidInstructionSet { span: attr.span() });
63                    None
64                }
65            }
66        }
67        [] => {
68            tcx.dcx().emit_err(errors::BareInstructionSet { span: attr.span() });
69            None
70        }
71        _ => {
72            tcx.dcx().emit_err(errors::MultipleInstructionSet { span: attr.span() });
73            None
74        }
75    }
76}
77
78// FIXME(jdonszelmann): remove when patchable_function_entry becomes a parsed attr
79fn parse_patchable_function_entry(
80    tcx: TyCtxt<'_>,
81    attr: &Attribute,
82) -> Option<PatchableFunctionEntry> {
83    attr.meta_item_list().and_then(|l| {
84        let mut prefix = None;
85        let mut entry = None;
86        for item in l {
87            let Some(meta_item) = item.meta_item() else {
88                tcx.dcx().emit_err(errors::ExpectedNameValuePair { span: item.span() });
89                continue;
90            };
91
92            let Some(name_value_lit) = meta_item.name_value_literal() else {
93                tcx.dcx().emit_err(errors::ExpectedNameValuePair { span: item.span() });
94                continue;
95            };
96
97            let attrib_to_write = match meta_item.name() {
98                Some(sym::prefix_nops) => &mut prefix,
99                Some(sym::entry_nops) => &mut entry,
100                _ => {
101                    tcx.dcx().emit_err(errors::UnexpectedParameterName {
102                        span: item.span(),
103                        prefix_nops: sym::prefix_nops,
104                        entry_nops: sym::entry_nops,
105                    });
106                    continue;
107                }
108            };
109
110            let rustc_ast::LitKind::Int(val, _) = name_value_lit.kind else {
111                tcx.dcx().emit_err(errors::InvalidLiteralValue { span: name_value_lit.span });
112                continue;
113            };
114
115            let Ok(val) = val.get().try_into() else {
116                tcx.dcx().emit_err(errors::OutOfRangeInteger { span: name_value_lit.span });
117                continue;
118            };
119
120            *attrib_to_write = Some(val);
121        }
122
123        if let (None, None) = (prefix, entry) {
124            tcx.dcx().span_err(attr.span(), "must specify at least one parameter");
125        }
126
127        Some(PatchableFunctionEntry::from_prefix_and_entry(prefix.unwrap_or(0), entry.unwrap_or(0)))
128    })
129}
130
131/// Spans that are collected when processing built-in attributes,
132/// that are useful for emitting diagnostics later.
133#[derive(Default)]
134struct InterestingAttributeDiagnosticSpans {
135    link_ordinal: Option<Span>,
136    sanitize: Option<Span>,
137    inline: Option<Span>,
138    no_mangle: Option<Span>,
139}
140
141/// Process the builtin attrs ([`hir::Attribute`]) on the item.
142/// Many of them directly translate to codegen attrs.
143fn process_builtin_attrs(
144    tcx: TyCtxt<'_>,
145    did: LocalDefId,
146    attrs: &[Attribute],
147    codegen_fn_attrs: &mut CodegenFnAttrs,
148) -> InterestingAttributeDiagnosticSpans {
149    let mut interesting_spans = InterestingAttributeDiagnosticSpans::default();
150    let rust_target_features = tcx.rust_target_features(LOCAL_CRATE);
151
152    for attr in attrs.iter() {
153        if let hir::Attribute::Parsed(p) = attr {
154            match p {
155                AttributeKind::Cold(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::COLD,
156                AttributeKind::ExportName { name, .. } => {
157                    codegen_fn_attrs.symbol_name = Some(*name)
158                }
159                AttributeKind::Inline(inline, span) => {
160                    codegen_fn_attrs.inline = *inline;
161                    interesting_spans.inline = Some(*span);
162                }
163                AttributeKind::Naked(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED,
164                AttributeKind::Align { align, .. } => codegen_fn_attrs.alignment = Some(*align),
165                AttributeKind::LinkName { name, .. } => {
166                    // FIXME Remove check for foreign functions once #[link_name] on non-foreign
167                    // functions is a hard error
168                    if tcx.is_foreign_item(did) {
169                        codegen_fn_attrs.symbol_name = Some(*name);
170                    }
171                }
172                AttributeKind::LinkOrdinal { ordinal, span } => {
173                    codegen_fn_attrs.link_ordinal = Some(*ordinal);
174                    interesting_spans.link_ordinal = Some(*span);
175                }
176                AttributeKind::LinkSection { name, .. } => {
177                    codegen_fn_attrs.link_section = Some(*name)
178                }
179                AttributeKind::NoMangle(attr_span) => {
180                    interesting_spans.no_mangle = Some(*attr_span);
181                    if tcx.opt_item_name(did.to_def_id()).is_some() {
182                        codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
183                    } else {
184                        tcx.dcx().span_delayed_bug(
185                            *attr_span,
186                            "no_mangle should be on a named function",
187                        );
188                    }
189                }
190                AttributeKind::Optimize(optimize, _) => codegen_fn_attrs.optimize = *optimize,
191                AttributeKind::TargetFeature { features, attr_span, was_forced } => {
192                    let Some(sig) = tcx.hir_node_by_def_id(did).fn_sig() else {
193                        tcx.dcx().span_delayed_bug(*attr_span, "target_feature applied to non-fn");
194                        continue;
195                    };
196                    let safe_target_features =
197                        matches!(sig.header.safety, hir::HeaderSafety::SafeTargetFeatures);
198                    codegen_fn_attrs.safe_target_features = safe_target_features;
199                    if safe_target_features && !was_forced {
200                        if tcx.sess.target.is_like_wasm || tcx.sess.opts.actually_rustdoc {
201                            // The `#[target_feature]` attribute is allowed on
202                            // WebAssembly targets on all functions. Prior to stabilizing
203                            // the `target_feature_11` feature, `#[target_feature]` was
204                            // only permitted on unsafe functions because on most targets
205                            // execution of instructions that are not supported is
206                            // considered undefined behavior. For WebAssembly which is a
207                            // 100% safe target at execution time it's not possible to
208                            // execute undefined instructions, and even if a future
209                            // feature was added in some form for this it would be a
210                            // deterministic trap. There is no undefined behavior when
211                            // executing WebAssembly so `#[target_feature]` is allowed
212                            // on safe functions (but again, only for WebAssembly)
213                            //
214                            // Note that this is also allowed if `actually_rustdoc` so
215                            // if a target is documenting some wasm-specific code then
216                            // it's not spuriously denied.
217                            //
218                            // Now that `#[target_feature]` is permitted on safe functions,
219                            // this exception must still exist for allowing the attribute on
220                            // `main`, `start`, and other functions that are not usually
221                            // allowed.
222                        } else {
223                            check_target_feature_trait_unsafe(tcx, did, *attr_span);
224                        }
225                    }
226                    from_target_feature_attr(
227                        tcx,
228                        did,
229                        features,
230                        *was_forced,
231                        rust_target_features,
232                        &mut codegen_fn_attrs.target_features,
233                    );
234                }
235                AttributeKind::TrackCaller(attr_span) => {
236                    let is_closure = tcx.is_closure_like(did.to_def_id());
237
238                    if !is_closure
239                        && let Some(fn_sig) = try_fn_sig(tcx, did, *attr_span)
240                        && fn_sig.skip_binder().abi() != ExternAbi::Rust
241                    {
242                        tcx.dcx().emit_err(errors::RequiresRustAbi { span: *attr_span });
243                    }
244                    if is_closure
245                        && !tcx.features().closure_track_caller()
246                        && !attr_span.allows_unstable(sym::closure_track_caller)
247                    {
248                        feature_err(
249                            &tcx.sess,
250                            sym::closure_track_caller,
251                            *attr_span,
252                            "`#[track_caller]` on closures is currently unstable",
253                        )
254                        .emit();
255                    }
256                    codegen_fn_attrs.flags |= CodegenFnAttrFlags::TRACK_CALLER
257                }
258                AttributeKind::Used { used_by, .. } => match used_by {
259                    UsedBy::Compiler => codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED_COMPILER,
260                    UsedBy::Linker => codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED_LINKER,
261                    UsedBy::Default => {
262                        let used_form = if tcx.sess.target.os == Os::Illumos {
263                            // illumos' `ld` doesn't support a section header that would represent
264                            // `#[used(linker)]`, see
265                            // https://github.com/rust-lang/rust/issues/146169. For that target,
266                            // downgrade as if `#[used(compiler)]` was requested and hope for the
267                            // best.
268                            CodegenFnAttrFlags::USED_COMPILER
269                        } else {
270                            CodegenFnAttrFlags::USED_LINKER
271                        };
272                        codegen_fn_attrs.flags |= used_form;
273                    }
274                },
275                AttributeKind::FfiConst(_) => {
276                    codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_CONST
277                }
278                AttributeKind::FfiPure(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_PURE,
279                AttributeKind::StdInternalSymbol(_) => {
280                    codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL
281                }
282                AttributeKind::Linkage(linkage, span) => {
283                    let linkage = Some(*linkage);
284
285                    if tcx.is_foreign_item(did) {
286                        codegen_fn_attrs.import_linkage = linkage;
287
288                        if tcx.is_mutable_static(did.into()) {
289                            let mut diag = tcx.dcx().struct_span_err(
290                                *span,
291                                "extern mutable statics are not allowed with `#[linkage]`",
292                            );
293                            diag.note(
294                                "marking the extern static mutable would allow changing which \
295                                symbol the static references rather than make the target of the \
296                                symbol mutable",
297                            );
298                            diag.emit();
299                        }
300                    } else {
301                        codegen_fn_attrs.linkage = linkage;
302                    }
303                }
304                AttributeKind::Sanitize { span, .. } => {
305                    interesting_spans.sanitize = Some(*span);
306                }
307                AttributeKind::ObjcClass { classname, .. } => {
308                    codegen_fn_attrs.objc_class = Some(*classname);
309                }
310                AttributeKind::ObjcSelector { methname, .. } => {
311                    codegen_fn_attrs.objc_selector = Some(*methname);
312                }
313                _ => {}
314            }
315        }
316
317        let Some(Ident { name, .. }) = attr.ident() else {
318            continue;
319        };
320
321        match name {
322            sym::rustc_allocator => codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR,
323            sym::rustc_nounwind => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NEVER_UNWIND,
324            sym::rustc_reallocator => codegen_fn_attrs.flags |= CodegenFnAttrFlags::REALLOCATOR,
325            sym::rustc_deallocator => codegen_fn_attrs.flags |= CodegenFnAttrFlags::DEALLOCATOR,
326            sym::rustc_allocator_zeroed => {
327                codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR_ZEROED
328            }
329            sym::thread_local => codegen_fn_attrs.flags |= CodegenFnAttrFlags::THREAD_LOCAL,
330            sym::instruction_set => {
331                codegen_fn_attrs.instruction_set = parse_instruction_set_attr(tcx, attr)
332            }
333            sym::patchable_function_entry => {
334                codegen_fn_attrs.patchable_function_entry =
335                    parse_patchable_function_entry(tcx, attr);
336            }
337            _ => {}
338        }
339    }
340
341    interesting_spans
342}
343
344/// Applies overrides for codegen fn attrs. These often have a specific reason why they're necessary.
345/// Please comment why when adding a new one!
346fn apply_overrides(tcx: TyCtxt<'_>, did: LocalDefId, codegen_fn_attrs: &mut CodegenFnAttrs) {
347    // Apply the minimum function alignment here. This ensures that a function's alignment is
348    // determined by the `-C` flags of the crate it is defined in, not the `-C` flags of the crate
349    // it happens to be codegen'd (or const-eval'd) in.
350    codegen_fn_attrs.alignment =
351        Ord::max(codegen_fn_attrs.alignment, tcx.sess.opts.unstable_opts.min_function_alignment);
352
353    // Passed in sanitizer settings are always the default.
354    assert!(codegen_fn_attrs.sanitizers == SanitizerFnAttrs::default());
355    // Replace with #[sanitize] value
356    codegen_fn_attrs.sanitizers = tcx.sanitizer_settings_for(did);
357    // On trait methods, inherit the `#[align]` of the trait's method prototype.
358    codegen_fn_attrs.alignment = Ord::max(codegen_fn_attrs.alignment, tcx.inherited_align(did));
359
360    // naked function MUST NOT be inlined! This attribute is required for the rust compiler itself,
361    // but not for the code generation backend because at that point the naked function will just be
362    // a declaration, with a definition provided in global assembly.
363    if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
364        codegen_fn_attrs.inline = InlineAttr::Never;
365    }
366
367    // #73631: closures inherit `#[target_feature]` annotations
368    //
369    // If this closure is marked `#[inline(always)]`, simply skip adding `#[target_feature]`.
370    //
371    // At this point, `unsafe` has already been checked and `#[target_feature]` only affects codegen.
372    // Due to LLVM limitations, emitting both `#[inline(always)]` and `#[target_feature]` is *unsound*:
373    // the function may be inlined into a caller with fewer target features. Also see
374    // <https://github.com/rust-lang/rust/issues/116573>.
375    //
376    // Using `#[inline(always)]` implies that this closure will most likely be inlined into
377    // its parent function, which effectively inherits the features anyway. Boxing this closure
378    // would result in this closure being compiled without the inherited target features, but this
379    // is probably a poor usage of `#[inline(always)]` and easily avoided by not using the attribute.
380    if tcx.is_closure_like(did.to_def_id()) && codegen_fn_attrs.inline != InlineAttr::Always {
381        let owner_id = tcx.parent(did.to_def_id());
382        if tcx.def_kind(owner_id).has_codegen_attrs() {
383            codegen_fn_attrs
384                .target_features
385                .extend(tcx.codegen_fn_attrs(owner_id).target_features.iter().copied());
386        }
387    }
388
389    // When `no_builtins` is applied at the crate level, we should add the
390    // `no-builtins` attribute to each function to ensure it takes effect in LTO.
391    let crate_attrs = tcx.hir_attrs(rustc_hir::CRATE_HIR_ID);
392    let no_builtins = attr::contains_name(crate_attrs, sym::no_builtins);
393    if no_builtins {
394        codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_BUILTINS;
395    }
396
397    // inherit track-caller properly
398    if tcx.should_inherit_track_caller(did) {
399        codegen_fn_attrs.flags |= CodegenFnAttrFlags::TRACK_CALLER;
400    }
401
402    // Foreign items by default use no mangling for their symbol name.
403    if tcx.is_foreign_item(did) {
404        codegen_fn_attrs.flags |= CodegenFnAttrFlags::FOREIGN_ITEM;
405
406        // There's a few exceptions to this rule though:
407        if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL) {
408            // * `#[rustc_std_internal_symbol]` mangles the symbol name in a special way
409            //   both for exports and imports through foreign items. This is handled further,
410            //   during symbol mangling logic.
411        } else if codegen_fn_attrs.symbol_name.is_some() {
412            // * This can be overridden with the `#[link_name]` attribute
413        } else {
414            // NOTE: there's one more exception that we cannot apply here. On wasm,
415            // some items cannot be `no_mangle`.
416            // However, we don't have enough information here to determine that.
417            // As such, no_mangle foreign items on wasm that have the same defid as some
418            // import will *still* be mangled despite this.
419            //
420            // if none of the exceptions apply; apply no_mangle
421            codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
422        }
423    }
424}
425
426fn check_result(
427    tcx: TyCtxt<'_>,
428    did: LocalDefId,
429    interesting_spans: InterestingAttributeDiagnosticSpans,
430    codegen_fn_attrs: &CodegenFnAttrs,
431) {
432    // If a function uses `#[target_feature]` it can't be inlined into general
433    // purpose functions as they wouldn't have the right target features
434    // enabled. For that reason we also forbid `#[inline(always)]` as it can't be
435    // respected.
436    //
437    // `#[rustc_force_inline]` doesn't need to be prohibited here, only
438    // `#[inline(always)]`, as forced inlining is implemented entirely within
439    // rustc (and so the MIR inliner can do any necessary checks for compatible target
440    // features).
441    //
442    // This sidesteps the LLVM blockers in enabling `target_features` +
443    // `inline(always)` to be used together (see rust-lang/rust#116573 and
444    // llvm/llvm-project#70563).
445    if !codegen_fn_attrs.target_features.is_empty()
446        && matches!(codegen_fn_attrs.inline, InlineAttr::Always)
447        && !tcx.features().target_feature_inline_always()
448        && let Some(span) = interesting_spans.inline
449    {
450        feature_err(
451            tcx.sess,
452            sym::target_feature_inline_always,
453            span,
454            "cannot use `#[inline(always)]` with `#[target_feature]`",
455        )
456        .emit();
457    }
458
459    // warn that inline has no effect when no_sanitize is present
460    if codegen_fn_attrs.sanitizers != SanitizerFnAttrs::default()
461        && codegen_fn_attrs.inline.always()
462        && let (Some(sanitize_span), Some(inline_span)) =
463            (interesting_spans.sanitize, interesting_spans.inline)
464    {
465        let hir_id = tcx.local_def_id_to_hir_id(did);
466        tcx.node_span_lint(lint::builtin::INLINE_NO_SANITIZE, hir_id, sanitize_span, |lint| {
467            lint.primary_message("non-default `sanitize` will have no effect after inlining");
468            lint.span_note(inline_span, "inlining requested here");
469        })
470    }
471
472    // warn for nonblocking async functions, blocks and closures.
473    // This doesn't behave as expected, because the executor can run blocking code without the sanitizer noticing.
474    if codegen_fn_attrs.sanitizers.rtsan_setting == RtsanSetting::Nonblocking
475        && let Some(sanitize_span) = interesting_spans.sanitize
476        // async fn
477        && (tcx.asyncness(did).is_async()
478            // async block
479            || tcx.is_coroutine(did.into())
480            // async closure
481            || (tcx.is_closure_like(did.into())
482                && tcx.hir_node_by_def_id(did).expect_closure().kind
483                    != rustc_hir::ClosureKind::Closure))
484    {
485        let hir_id = tcx.local_def_id_to_hir_id(did);
486        tcx.node_span_lint(
487            lint::builtin::RTSAN_NONBLOCKING_ASYNC,
488            hir_id,
489            sanitize_span,
490            |lint| {
491                lint.primary_message(r#"the async executor can run blocking code, without realtime sanitizer catching it"#);
492            }
493        );
494    }
495
496    // error when specifying link_name together with link_ordinal
497    if let Some(_) = codegen_fn_attrs.symbol_name
498        && let Some(_) = codegen_fn_attrs.link_ordinal
499    {
500        let msg = "cannot use `#[link_name]` with `#[link_ordinal]`";
501        if let Some(span) = interesting_spans.link_ordinal {
502            tcx.dcx().span_err(span, msg);
503        } else {
504            tcx.dcx().err(msg);
505        }
506    }
507
508    if let Some(features) = check_tied_features(
509        tcx.sess,
510        &codegen_fn_attrs
511            .target_features
512            .iter()
513            .map(|features| (features.name.as_str(), true))
514            .collect(),
515    ) {
516        let span =
517            find_attr!(tcx.get_all_attrs(did), AttributeKind::TargetFeature{attr_span: span, ..} => *span)
518                .unwrap_or_else(|| tcx.def_span(did));
519
520        tcx.dcx()
521            .create_err(errors::TargetFeatureDisableOrEnable {
522                features,
523                span: Some(span),
524                missing_features: Some(errors::MissingFeatures),
525            })
526            .emit();
527    }
528}
529
530fn handle_lang_items(
531    tcx: TyCtxt<'_>,
532    did: LocalDefId,
533    interesting_spans: &InterestingAttributeDiagnosticSpans,
534    attrs: &[Attribute],
535    codegen_fn_attrs: &mut CodegenFnAttrs,
536) {
537    let lang_item = lang_items::extract(attrs).and_then(|(name, _)| LangItem::from_name(name));
538
539    // Weak lang items have the same semantics as "std internal" symbols in the
540    // sense that they're preserved through all our LTO passes and only
541    // strippable by the linker.
542    //
543    // Additionally weak lang items have predetermined symbol names.
544    if let Some(lang_item) = lang_item
545        && let Some(link_name) = lang_item.link_name()
546    {
547        codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL;
548        codegen_fn_attrs.symbol_name = Some(link_name);
549    }
550
551    // error when using no_mangle on a lang item item
552    if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL)
553        && codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NO_MANGLE)
554    {
555        let mut err = tcx
556            .dcx()
557            .struct_span_err(
558                interesting_spans.no_mangle.unwrap_or_default(),
559                "`#[no_mangle]` cannot be used on internal language items",
560            )
561            .with_note("Rustc requires this item to have a specific mangled name.")
562            .with_span_label(tcx.def_span(did), "should be the internal language item");
563        if let Some(lang_item) = lang_item
564            && let Some(link_name) = lang_item.link_name()
565        {
566            err = err
567                .with_note("If you are trying to prevent mangling to ease debugging, many")
568                .with_note(format!("debuggers support a command such as `rbreak {link_name}` to"))
569                .with_note(format!(
570                    "match `.*{link_name}.*` instead of `break {link_name}` on a specific name"
571                ))
572        }
573        err.emit();
574    }
575}
576
577/// Generate the [`CodegenFnAttrs`] for an item (identified by the [`LocalDefId`]).
578///
579/// This happens in 4 stages:
580/// - apply built-in attributes that directly translate to codegen attributes.
581/// - handle lang items. These have special codegen attrs applied to them.
582/// - apply overrides, like minimum requirements for alignment and other settings that don't rely directly the built-in attrs on the item.
583///   overrides come after applying built-in attributes since they may only apply when certain attributes were already set in the stage before.
584/// - check that the result is valid. There's various ways in which this may not be the case, such as certain combinations of attrs.
585fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
586    if cfg!(debug_assertions) {
587        let def_kind = tcx.def_kind(did);
588        assert!(
589            def_kind.has_codegen_attrs(),
590            "unexpected `def_kind` in `codegen_fn_attrs`: {def_kind:?}",
591        );
592    }
593
594    let mut codegen_fn_attrs = CodegenFnAttrs::new();
595    let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(did));
596
597    let interesting_spans = process_builtin_attrs(tcx, did, attrs, &mut codegen_fn_attrs);
598    handle_lang_items(tcx, did, &interesting_spans, attrs, &mut codegen_fn_attrs);
599    apply_overrides(tcx, did, &mut codegen_fn_attrs);
600    check_result(tcx, did, interesting_spans, &codegen_fn_attrs);
601
602    codegen_fn_attrs
603}
604
605fn sanitizer_settings_for(tcx: TyCtxt<'_>, did: LocalDefId) -> SanitizerFnAttrs {
606    // Backtrack to the crate root.
607    let mut settings = match tcx.opt_local_parent(did) {
608        // Check the parent (recursively).
609        Some(parent) => tcx.sanitizer_settings_for(parent),
610        // We reached the crate root without seeing an attribute, so
611        // there is no sanitizers to exclude.
612        None => SanitizerFnAttrs::default(),
613    };
614
615    // Check for a sanitize annotation directly on this def.
616    if let Some((on_set, off_set, rtsan)) = find_attr!(tcx.get_all_attrs(did), AttributeKind::Sanitize {on_set, off_set, rtsan, ..} => (on_set, off_set, rtsan))
617    {
618        // the on set is the set of sanitizers explicitly enabled.
619        // we mask those out since we want the set of disabled sanitizers here
620        settings.disabled &= !*on_set;
621        // the off set is the set of sanitizers explicitly disabled.
622        // we or those in here.
623        settings.disabled |= *off_set;
624        // the on set and off set are distjoint since there's a third option: unset.
625        // a node may not set the sanitizer setting in which case it inherits from parents.
626        // the code above in this function does this backtracking
627
628        // if rtsan was specified here override the parent
629        if let Some(rtsan) = rtsan {
630            settings.rtsan_setting = *rtsan;
631        }
632    }
633    settings
634}
635
636/// Checks if the provided DefId is a method in a trait impl for a trait which has track_caller
637/// applied to the method prototype.
638fn should_inherit_track_caller(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
639    tcx.trait_item_of(def_id).is_some_and(|id| {
640        tcx.codegen_fn_attrs(id).flags.intersects(CodegenFnAttrFlags::TRACK_CALLER)
641    })
642}
643
644/// If the provided DefId is a method in a trait impl, return the value of the `#[align]`
645/// attribute on the method prototype (if any).
646fn inherited_align<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option<Align> {
647    tcx.codegen_fn_attrs(tcx.trait_item_of(def_id)?).alignment
648}
649
650/// We now check the #\[rustc_autodiff\] attributes which we generated from the #[autodiff(...)]
651/// macros. There are two forms. The pure one without args to mark primal functions (the functions
652/// being differentiated). The other form is #[rustc_autodiff(Mode, ActivityList)] on top of the
653/// placeholder functions. We wrote the rustc_autodiff attributes ourself, so this should never
654/// panic, unless we introduced a bug when parsing the autodiff macro.
655//FIXME(jdonszelmann): put in the main loop. No need to have two..... :/ Let's do that when we make autodiff parsed.
656pub fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
657    let attrs = tcx.get_attrs(id, sym::rustc_autodiff);
658
659    let attrs = attrs.filter(|attr| attr.has_name(sym::rustc_autodiff)).collect::<Vec<_>>();
660
661    // check for exactly one autodiff attribute on placeholder functions.
662    // There should only be one, since we generate a new placeholder per ad macro.
663    let attr = match &attrs[..] {
664        [] => return None,
665        [attr] => attr,
666        _ => {
667            span_bug!(attrs[1].span(), "cg_ssa: rustc_autodiff should only exist once per source");
668        }
669    };
670
671    let list = attr.meta_item_list().unwrap_or_default();
672
673    // empty autodiff attribute macros (i.e. `#[autodiff]`) are used to mark source functions
674    if list.is_empty() {
675        return Some(AutoDiffAttrs::source());
676    }
677
678    let [mode, width_meta, input_activities @ .., ret_activity] = &list[..] else {
679        span_bug!(attr.span(), "rustc_autodiff attribute must contain mode, width and activities");
680    };
681    let mode = if let MetaItemInner::MetaItem(MetaItem { path: p1, .. }) = mode {
682        p1.segments.first().unwrap().ident
683    } else {
684        span_bug!(attr.span(), "rustc_autodiff attribute must contain mode");
685    };
686
687    // parse mode
688    let mode = match mode.as_str() {
689        "Forward" => DiffMode::Forward,
690        "Reverse" => DiffMode::Reverse,
691        _ => {
692            span_bug!(mode.span, "rustc_autodiff attribute contains invalid mode");
693        }
694    };
695
696    let width: u32 = match width_meta {
697        MetaItemInner::MetaItem(MetaItem { path: p1, .. }) => {
698            let w = p1.segments.first().unwrap().ident;
699            match w.as_str().parse() {
700                Ok(val) => val,
701                Err(_) => {
702                    span_bug!(w.span, "rustc_autodiff width should fit u32");
703                }
704            }
705        }
706        MetaItemInner::Lit(lit) => {
707            if let LitKind::Int(val, _) = lit.kind {
708                match val.get().try_into() {
709                    Ok(val) => val,
710                    Err(_) => {
711                        span_bug!(lit.span, "rustc_autodiff width should fit u32");
712                    }
713                }
714            } else {
715                span_bug!(lit.span, "rustc_autodiff width should be an integer");
716            }
717        }
718    };
719
720    // First read the ret symbol from the attribute
721    let ret_symbol = if let MetaItemInner::MetaItem(MetaItem { path: p1, .. }) = ret_activity {
722        p1.segments.first().unwrap().ident
723    } else {
724        span_bug!(attr.span(), "rustc_autodiff attribute must contain the return activity");
725    };
726
727    // Then parse it into an actual DiffActivity
728    let Ok(ret_activity) = DiffActivity::from_str(ret_symbol.as_str()) else {
729        span_bug!(ret_symbol.span, "invalid return activity");
730    };
731
732    // Now parse all the intermediate (input) activities
733    let mut arg_activities: Vec<DiffActivity> = vec![];
734    for arg in input_activities {
735        let arg_symbol = if let MetaItemInner::MetaItem(MetaItem { path: p2, .. }) = arg {
736            match p2.segments.first() {
737                Some(x) => x.ident,
738                None => {
739                    span_bug!(
740                        arg.span(),
741                        "rustc_autodiff attribute must contain the input activity"
742                    );
743                }
744            }
745        } else {
746            span_bug!(arg.span(), "rustc_autodiff attribute must contain the input activity");
747        };
748
749        match DiffActivity::from_str(arg_symbol.as_str()) {
750            Ok(arg_activity) => arg_activities.push(arg_activity),
751            Err(_) => {
752                span_bug!(arg_symbol.span, "invalid input activity");
753            }
754        }
755    }
756
757    Some(AutoDiffAttrs { mode, width, ret_activity, input_activity: arg_activities })
758}
759
760pub(crate) fn provide(providers: &mut Providers) {
761    *providers = Providers {
762        codegen_fn_attrs,
763        should_inherit_track_caller,
764        inherited_align,
765        sanitizer_settings_for,
766        ..*providers
767    };
768}
rustc_codegen_ssa/codegen_attrs.rs

rustc_codegen_ssa/
codegen_attrs.rs
