Skip to main content

vicis_core/ir/module/attributes/
mod.rs

1pub mod parser;
2
3use std::fmt;
4
5#[derive(PartialEq, Eq, Clone)]
6pub enum Attribute {
7    AlignStack(u64),
8    AllocSize {
9        elt_size: u32,
10        num_elts: Option<u32>,
11    },
12    AlwaysInline,
13    Builtin,
14    Cold,
15    Convergent,
16    InaccessibleMemOnly,
17    InaccessibleMemOrArgMemOnly,
18    InlineHint,
19    JumpTable,
20    MinimizeSize,
21    Naked,
22    NoBuiltin,
23    NoCFCheck,
24    NoDuplicate,
25    NoFree,
26    NoImplicitFloat,
27    NoInline,
28    NonLazyBind,
29    NoRedZone,
30    NoReturn,
31    NoRecurse,
32    WillReturn,
33    ReturnsTwice,
34    NoSync,
35    NoUnwind,
36    OptForFuzzing,
37    OptNone,
38    OptSize,
39    ReadNone,
40    ReadOnly,
41    WriteOnly,
42    ArgMemOnly,
43    SafeStack,
44    SanitizeAddress,
45    SanitizeMemory,
46    SanitizeThread,
47    SanitizeHWAddress,
48    SanitizeMemTag,
49    ShadowCallStack,
50    SpeculativeLoadHardening,
51    Speculatable,
52    StackProtect,
53    StackProtectReq,
54    StackProtectStrong,
55    StrictFP,
56    UWTable,
57    StringAttribute {
58        kind: String,
59        value: String,
60    },
61    Ref(u32),
62    // UnknownAttribute,
63}
64
65impl fmt::Debug for Attribute {
66    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
67        match self {
68            Attribute::AlwaysInline => write!(f, "alwaysinline"),
69            Attribute::Builtin => write!(f, "builtin"),
70            Attribute::Cold => write!(f, "cold"),
71            Attribute::Convergent => write!(f, "convergent"),
72            Attribute::InaccessibleMemOnly => write!(f, "inaccessiblememonly"),
73            Attribute::InaccessibleMemOrArgMemOnly => write!(f, "inaccessiblememorargmemonly"),
74            Attribute::InlineHint => write!(f, "inlinehint"),
75            Attribute::JumpTable => write!(f, "jumptable"),
76            Attribute::MinimizeSize => write!(f, "minimizesize"),
77            Attribute::Naked => write!(f, "naked"),
78            Attribute::NoBuiltin => write!(f, "nobuiltin"),
79            Attribute::NoCFCheck => write!(f, "nocfcheck"),
80            Attribute::NoDuplicate => write!(f, "noduplicate"),
81            Attribute::NoFree => write!(f, "nofree"),
82            Attribute::NoImplicitFloat => write!(f, "noimplicitfloat"),
83            Attribute::NoInline => write!(f, "noinline"),
84            Attribute::NonLazyBind => write!(f, "nonlazybind"),
85            Attribute::NoRedZone => write!(f, "noredzone"),
86            Attribute::NoReturn => write!(f, "noreturn"),
87            Attribute::NoRecurse => write!(f, "norecurse"),
88            Attribute::WillReturn => write!(f, "willreturn"),
89            Attribute::ReturnsTwice => write!(f, "returnstwice"),
90            Attribute::NoSync => write!(f, "nosync"),
91            Attribute::NoUnwind => write!(f, "nounwind"),
92            Attribute::OptForFuzzing => write!(f, "optforfuzzing"),
93            Attribute::OptNone => write!(f, "optnone"),
94            Attribute::OptSize => write!(f, "optsize"),
95            Attribute::ReadNone => write!(f, "readnone"),
96            Attribute::ReadOnly => write!(f, "readonly"),
97            Attribute::WriteOnly => write!(f, "writeonly"),
98            Attribute::ArgMemOnly => write!(f, "argmemonly"),
99            Attribute::SafeStack => write!(f, "safestack"),
100            Attribute::SanitizeAddress => write!(f, "sanitizeaddress"),
101            Attribute::SanitizeMemory => write!(f, "sanitizememory"),
102            Attribute::SanitizeThread => write!(f, "sanitizethread"),
103            Attribute::SanitizeHWAddress => write!(f, "sanitizehwaddress"),
104            Attribute::SanitizeMemTag => write!(f, "sanitizememtag"),
105            Attribute::ShadowCallStack => write!(f, "shadowcallstack"),
106            Attribute::SpeculativeLoadHardening => write!(f, "speculativeloadhardening"),
107            Attribute::Speculatable => write!(f, "speculatable"),
108            Attribute::StackProtect => write!(f, "ssp"),
109            Attribute::StackProtectReq => write!(f, "sspreq"),
110            Attribute::StackProtectStrong => write!(f, "sspstrong"),
111            Attribute::StrictFP => write!(f, "strictfp"),
112            Attribute::UWTable => write!(f, "uwtable"),
113            Attribute::StringAttribute { kind, value } if value.is_empty() => {
114                write!(f, "\"{}\"", kind)
115            }
116            Attribute::StringAttribute { kind, value } => write!(f, "\"{}\"=\"{}\"", kind, value),
117            Attribute::Ref(i) => write!(f, "#{}", i),
118            _ => todo!(),
119        }
120    }
121}