hllvm-sys 0.1.3

FFI wrapper around the LLVM C++ library
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
122
123
124
125
126

use libc;

/// An operation code for an IR instruction.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum OpCode {
    Terminator(TerminatorOpCode),
    Binary(BinaryOpCode),
    Logical(LogicalOpCode),
    Memory(MemoryOpCode),
    Cast(CastOpCode),
    Other(OtherOpCode),
}

/// An opcode for a block terminator instruction.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(C)]
pub enum TerminatorOpCode {
    Ret = 1,
    Br = 2,
    Switch = 3,
    IndirectBr = 4,
    Invoke = 5,
    Resume = 6,
    Unreachable = 7,
    CleanupRet = 8,
    CatchRet = 9,
    CatchSwitch = 10,
}

/// An opcode for a binary operation instruction.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(C)]
pub enum BinaryOpCode {
    Add = 11,
    FAdd = 12,
    Sub = 13,
    FSub = 14,
    Mul = 15,
    FMul = 16,
    UDiv = 17,
    SDiv = 18,
    FDiv = 19,
    URem = 20,
    SRem = 21,
    FRem = 22,
}

/// An opcode for a logical operation instruction.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(C)]
pub enum LogicalOpCode {
    Shl = 23,
    LShr = 24,
    AShr = 25,
    And = 26,
    Or = 27,
    Xor = 28,
}

/// An opcode for a memory instruction.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(C)]
pub enum MemoryOpCode {
    Alloca = 29,
    Load = 30,
    Store = 31,
    GetElementPtr = 32,
    Fence = 33,
    AtomicCmpXchg = 34,
    AtomicRMW = 35,
}

/// An opcode for a cast instruction.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(C)]
pub enum CastOpCode {
    Trunc = 36,
    ZExt = 37,
    SExt = 38,
    FPToUI = 39,
    FPToSI = 40,
    UIToFP = 41,
    SIToFP = 42,
    FPTrunc = 43,
    FPExt = 44,
    PtrToInt = 45,
    IntToPtr = 46,
    BitCast = 47,
    AddrSpaceCast = 48,
}

/// An opcode for some other instruction.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(C)]
pub enum OtherOpCode {
    CleanupPad = 49,
    CatchPad = 50,
    ICmp = 51,
    FCmp = 52,
    PHI = 53,
    Call = 54,
    Select = 55,
    UserOp1 = 56,
    UserOp2 = 57,
    VAArg = 58,
    ExtractElement = 59,
    InsertElement = 60,
    ShuffleVector = 61,
    ExtractValue = 62,
    InsertValue = 63,
    LandingPad = 64,
}

impl OpCode {
    /// Gets the numerical code for the opcode.
    pub fn code(self) -> libc::c_uint {
        match self {
            OpCode::Terminator(op) => op as libc::c_uint,
            OpCode::Binary(op) => op as libc::c_uint,
            OpCode::Logical(op) => op as libc::c_uint,
            OpCode::Memory(op) => op as libc::c_uint,
            OpCode::Cast(op) => op as libc::c_uint,
            OpCode::Other(op) => op as libc::c_uint,
        }
    }
}