Struct CodegenFnAttrs

pub struct CodegenFnAttrs {

    pub flags: CodegenFnAttrFlags,
    pub inline: InlineAttr,
    pub optimize: OptimizeAttr,
    pub export_name: Option<Symbol>,
    pub link_name: Option<Symbol>,
    pub link_ordinal: Option<u16>,
    pub target_features: Vec<TargetFeature>,
    pub linkage: Option<Linkage>,
    pub import_linkage: Option<Linkage>,
    pub link_section: Option<Symbol>,
    pub no_sanitize: SanitizerSet,
    pub instruction_set: Option<InstructionSetAttr>,
    pub alignment: Option<Align>,
    pub patchable_function_entry: Option<PatchableFunctionEntry>,
}

Fields

flags: CodegenFnAttrFlags

inline: InlineAttr

Parsed representation of the #[inline] attribute

optimize: OptimizeAttr

Parsed representation of the #[optimize] attribute

export_name: Option<Symbol>

The #[export_name = "..."] attribute, indicating a custom symbol a function should be exported under

link_name: Option<Symbol>

The #[link_name = "..."] attribute, indicating a custom symbol an imported function should be imported as. Note that export_name probably isn’t set when this is set, this is for foreign items while #[export_name] is for Rust-defined functions.

link_ordinal: Option<u16>

The #[link_ordinal = "..."] attribute, indicating an ordinal an imported function has in the dynamic library. Note that this must not be set when link_name is set. This is for foreign items with the “raw-dylib” kind.

target_features: Vec<TargetFeature>

The #[target_feature(enable = "...")] attribute and the enabled features (only enabled features are supported right now).

linkage: Option<Linkage>

The #[linkage = "..."] attribute on Rust-defined items and the value we found.

import_linkage: Option<Linkage>

The #[linkage = "..."] attribute on foreign items and the value we found.

link_section: Option<Symbol>

The #[link_section = "..."] attribute, or what executable section this should be placed in.

no_sanitize: SanitizerSet

The #[no_sanitize(...)] attribute. Indicates sanitizers for which instrumentation should be disabled inside the annotated function.

instruction_set: Option<InstructionSetAttr>

The #[instruction_set(set)] attribute. Indicates if the generated code should be generated against a specific instruction set. Only usable on architectures which allow switching between multiple instruction sets.

alignment: Option<Align>

The #[repr(align(...))] attribute. Indicates the value of which the function should be aligned to.

patchable_function_entry: Option<PatchableFunctionEntry>

The #[patchable_function_entry(...)] attribute. Indicates how many nops should be around the function entry.

Implementations

impl CodegenFnAttrs

pub const EMPTY: &'static Self = _

pub const fn new() -> CodegenFnAttrs

pub fn contains_extern_indicator(&self) -> bool

Returns true if it looks like this symbol needs to be exported, for example:

• #[no_mangle] is present
• #[export_name(...)] is present
• #[linkage] is present

Trait Implementations

impl Clone for CodegenFnAttrs

fn clone(&self) -> CodegenFnAttrs

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CodegenFnAttrs

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<__D: TyDecoder> Decodable<__D> for CodegenFnAttrs

fn decode(__decoder: &mut __D) -> Self

impl<__E: TyEncoder> Encodable<__E> for CodegenFnAttrs

fn encode(&self, __encoder: &mut __E)

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for CodegenFnAttrs

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher, )

impl ParameterizedOverTcx for CodegenFnAttrs

type Value<'tcx> = CodegenFnAttrs

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 56 bytes