1 use crate::mir::mono::Linkage;
2 use rustc_attr::{InlineAttr, InstructionSetAttr, OptimizeAttr};
3 use rustc_span::symbol::Symbol;
4 use rustc_target::spec::SanitizerSet;
6 #[derive(Clone, TyEncodable, TyDecodable, HashStable, Debug)]
7 pub struct CodegenFnAttrs {
8 pub flags: CodegenFnAttrFlags,
9 /// Parsed representation of the `#[inline]` attribute
10 pub inline: InlineAttr,
11 /// Parsed representation of the `#[optimize]` attribute
12 pub optimize: OptimizeAttr,
13 /// The `#[export_name = "..."]` attribute, indicating a custom symbol a
14 /// function should be exported under
15 pub export_name: Option<Symbol>,
16 /// The `#[link_name = "..."]` attribute, indicating a custom symbol an
17 /// imported function should be imported as. Note that `export_name`
18 /// probably isn't set when this is set, this is for foreign items while
19 /// `#[export_name]` is for Rust-defined functions.
20 pub link_name: Option<Symbol>,
21 /// The `#[link_ordinal = "..."]` attribute, indicating an ordinal an
22 /// imported function has in the dynamic library. Note that this must not
23 /// be set when `link_name` is set. This is for foreign items with the
25 pub link_ordinal: Option<u16>,
26 /// The `#[target_feature(enable = "...")]` attribute and the enabled
27 /// features (only enabled features are supported right now).
28 pub target_features: Vec<Symbol>,
29 /// The `#[linkage = "..."]` attribute and the value we found.
30 pub linkage: Option<Linkage>,
31 /// The `#[link_section = "..."]` attribute, or what executable section this
32 /// should be placed in.
33 pub link_section: Option<Symbol>,
34 /// The `#[no_sanitize(...)]` attribute. Indicates sanitizers for which
35 /// instrumentation should be disabled inside the annotated function.
36 pub no_sanitize: SanitizerSet,
37 /// The `#[instruction_set(set)]` attribute. Indicates if the generated code should
38 /// be generated against a specific instruction set. Only usable on architectures which allow
39 /// switching between multiple instruction sets.
40 pub instruction_set: Option<InstructionSetAttr>,
41 /// The `#[repr(align(...))]` attribute. Indicates the value of which the function should be
43 pub alignment: Option<u32>,
47 #[derive(TyEncodable, TyDecodable, HashStable)]
48 pub struct CodegenFnAttrFlags: u32 {
49 /// `#[cold]`: a hint to LLVM that this function, when called, is never on
52 /// `#[rustc_allocator]`: a hint to LLVM that the pointer returned from this
53 /// function is never null.
54 const ALLOCATOR = 1 << 1;
55 /// An indicator that function will never unwind. Will become obsolete
56 /// once C-unwind is fully stabilized.
57 const NEVER_UNWIND = 1 << 3;
58 /// `#[naked]`: an indicator to LLVM that no function prologue/epilogue
59 /// should be generated.
61 /// `#[no_mangle]`: an indicator that the function's name should be the same
63 const NO_MANGLE = 1 << 5;
64 /// `#[rustc_std_internal_symbol]`: an indicator that this symbol is a
65 /// "weird symbol" for the standard library in that it has slightly
66 /// different linkage, visibility, and reachability rules.
67 const RUSTC_STD_INTERNAL_SYMBOL = 1 << 6;
68 /// `#[thread_local]`: indicates a static is actually a thread local
70 const THREAD_LOCAL = 1 << 8;
71 /// `#[used]`: indicates that LLVM can't eliminate this function (but the
74 /// `#[ffi_returns_twice]`, indicates that an extern function can return
76 const FFI_RETURNS_TWICE = 1 << 10;
77 /// `#[track_caller]`: allow access to the caller location
78 const TRACK_CALLER = 1 << 11;
79 /// #[ffi_pure]: applies clang's `pure` attribute to a foreign function
81 const FFI_PURE = 1 << 12;
82 /// #[ffi_const]: applies clang's `const` attribute to a foreign function
84 const FFI_CONST = 1 << 13;
85 /// #[cmse_nonsecure_entry]: with a TrustZone-M extension, declare a
86 /// function as an entry function from Non-Secure code.
87 const CMSE_NONSECURE_ENTRY = 1 << 14;
88 /// `#[no_coverage]`: indicates that the function should be ignored by
89 /// the MIR `InstrumentCoverage` pass and not added to the coverage map
91 const NO_COVERAGE = 1 << 15;
96 pub fn new() -> CodegenFnAttrs {
98 flags: CodegenFnAttrFlags::empty(),
99 inline: InlineAttr::None,
100 optimize: OptimizeAttr::None,
104 target_features: vec![],
107 no_sanitize: SanitizerSet::empty(),
108 instruction_set: None,
113 /// Returns `true` if `#[inline]` or `#[inline(always)]` is present.
114 pub fn requests_inline(&self) -> bool {
116 InlineAttr::Hint | InlineAttr::Always => true,
117 InlineAttr::None | InlineAttr::Never => false,
121 /// Returns `true` if it looks like this symbol needs to be exported, for example:
123 /// * `#[no_mangle]` is present
124 /// * `#[export_name(...)]` is present
125 /// * `#[linkage]` is present
126 pub fn contains_extern_indicator(&self) -> bool {
127 self.flags.contains(CodegenFnAttrFlags::NO_MANGLE)
128 || self.export_name.is_some()
129 || match self.linkage {
130 // These are private, so make sure we don't try to consider
132 None | Some(Linkage::Internal | Linkage::Private) => false,