1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

pub mod parser;

use std::fmt;

#[derive(PartialEq, Eq, Clone)]
pub enum Attribute {
    AlignStack(u64),
    AllocSize {
        elt_size: u32,
        num_elts: Option<u32>,
    },
    AlwaysInline,
    Builtin,
    Cold,
    Convergent,
    InaccessibleMemOnly,
    InaccessibleMemOrArgMemOnly,
    InlineHint,
    JumpTable,
    MinimizeSize,
    Naked,
    NoBuiltin,
    NoCFCheck,
    NoDuplicate,
    NoFree,
    NoImplicitFloat,
    NoInline,
    NonLazyBind,
    NoRedZone,
    NoReturn,
    NoRecurse,
    WillReturn,
    ReturnsTwice,
    NoSync,
    NoUnwind,
    OptForFuzzing,
    OptNone,
    OptSize,
    ReadNone,
    ReadOnly,
    WriteOnly,
    ArgMemOnly,
    SafeStack,
    SanitizeAddress,
    SanitizeMemory,
    SanitizeThread,
    SanitizeHWAddress,
    SanitizeMemTag,
    ShadowCallStack,
    SpeculativeLoadHardening,
    Speculatable,
    StackProtect,
    StackProtectReq,
    StackProtectStrong,
    StrictFP,
    UWTable,
    StringAttribute {
        kind: String,
        value: String,
    },
    Ref(u32),
    // UnknownAttribute,
}

impl fmt::Debug for Attribute {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Attribute::AlwaysInline => write!(f, "alwaysinline"),
            Attribute::Builtin => write!(f, "builtin"),
            Attribute::Cold => write!(f, "cold"),
            Attribute::Convergent => write!(f, "convergent"),
            Attribute::InaccessibleMemOnly => write!(f, "inaccessiblememonly"),
            Attribute::InaccessibleMemOrArgMemOnly => write!(f, "inaccessiblememorargmemonly"),
            Attribute::InlineHint => write!(f, "inlinehint"),
            Attribute::JumpTable => write!(f, "jumptable"),
            Attribute::MinimizeSize => write!(f, "minimizesize"),
            Attribute::Naked => write!(f, "naked"),
            Attribute::NoBuiltin => write!(f, "nobuiltin"),
            Attribute::NoCFCheck => write!(f, "nocfcheck"),
            Attribute::NoDuplicate => write!(f, "noduplicate"),
            Attribute::NoFree => write!(f, "nofree"),
            Attribute::NoImplicitFloat => write!(f, "noimplicitfloat"),
            Attribute::NoInline => write!(f, "noinline"),
            Attribute::NonLazyBind => write!(f, "nonlazybind"),
            Attribute::NoRedZone => write!(f, "noredzone"),
            Attribute::NoReturn => write!(f, "noreturn"),
            Attribute::NoRecurse => write!(f, "norecurse"),
            Attribute::WillReturn => write!(f, "willreturn"),
            Attribute::ReturnsTwice => write!(f, "returnstwice"),
            Attribute::NoSync => write!(f, "nosync"),
            Attribute::NoUnwind => write!(f, "nounwind"),
            Attribute::OptForFuzzing => write!(f, "optforfuzzing"),
            Attribute::OptNone => write!(f, "optnone"),
            Attribute::OptSize => write!(f, "optsize"),
            Attribute::ReadNone => write!(f, "readnone"),
            Attribute::ReadOnly => write!(f, "readonly"),
            Attribute::WriteOnly => write!(f, "writeonly"),
            Attribute::ArgMemOnly => write!(f, "argmemonly"),
            Attribute::SafeStack => write!(f, "safestack"),
            Attribute::SanitizeAddress => write!(f, "sanitizeaddress"),
            Attribute::SanitizeMemory => write!(f, "sanitizememory"),
            Attribute::SanitizeThread => write!(f, "sanitizethread"),
            Attribute::SanitizeHWAddress => write!(f, "sanitizehwaddress"),
            Attribute::SanitizeMemTag => write!(f, "sanitizememtag"),
            Attribute::ShadowCallStack => write!(f, "shadowcallstack"),
            Attribute::SpeculativeLoadHardening => write!(f, "speculativeloadhardening"),
            Attribute::Speculatable => write!(f, "speculatable"),
            Attribute::StackProtect => write!(f, "ssp"),
            Attribute::StackProtectReq => write!(f, "sspreq"),
            Attribute::StackProtectStrong => write!(f, "sspstrong"),
            Attribute::StrictFP => write!(f, "strictfp"),
            Attribute::UWTable => write!(f, "uwtable"),
            Attribute::StringAttribute { kind, value } if value.is_empty() => {
                write!(f, "\"{}\"", kind)
            }
            Attribute::StringAttribute { kind, value } => write!(f, "\"{}\"=\"{}\"", kind, value),
            Attribute::Ref(i) => write!(f, "#{}", i),
            _ => todo!(),
        }
    }
}