vicis 0.1.0

Manipulate LLVM-IR in Pure Rust
Documentation 
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

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,
    },
    // 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, "stackprotect"),
            Attribute::StackProtectReq => write!(f, "stackprotectreq"),
            Attribute::StackProtectStrong => write!(f, "stackprotectstrong"),
            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),
            _ => todo!(),
        }
    }
}