capstone 0.14.0

High level bindings to capstone disassembly engine (https://www.capstone-engine.org/)
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

//! Contains sysz-specific types

use core::convert::From;
use core::{cmp, fmt, slice};

// XXX todo(garnt): create rusty versions
pub use capstone_sys::sysz_insn_group as SysZInsnGroup;
pub use capstone_sys::sysz_insn as SysZInsn;
pub use capstone_sys::sysz_reg as SysZReg;
use capstone_sys::{cs_sysz, cs_sysz_op, sysz_op_mem, sysz_op_type};

pub use crate::arch::arch_builder::sysz::*;
use crate::arch::DetailsArchInsn;
use crate::instruction::{RegId, RegIdInt};

/// Contains sysz-specific details for an instruction
pub struct SysZInsnDetail<'a>(pub(crate) &'a cs_sysz);

impl_PartialEq_repr_fields!(SysZInsnDetail<'a> [ 'a ];
    operands
);

/// SysZ operand
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum SysZOperand {
    /// Register
    Reg(RegId),

    /// Immediate
    Imm(i64),

    /// Memory
    Mem(SysZOpMem),

    /// Access Register
    AcReg(RegId),

    /// Invalid
    Invalid,
}

impl Default for SysZOperand {
    fn default() -> Self {
        SysZOperand::Invalid
    }
}

/// SysZ memory operand
#[derive(Debug, Copy, Clone)]
pub struct SysZOpMem(pub(crate) sysz_op_mem);

impl SysZOpMem {
    /// Base register
    pub fn base(&self) -> u8 {
        self.0.base
    }

    /// Index register
    pub fn index(&self) -> u8 {
        self.0.index
    }

    /// BDLAddr operand
    pub fn length(&self) -> u64 {
        self.0.length
    }

    /// Disp value
    pub fn disp(&self) -> i64 {
        self.0.disp
    }
}

impl_PartialEq_repr_fields!(SysZOpMem;
    base, index, length, disp
);

impl cmp::Eq for SysZOpMem {}

impl  From<&cs_sysz_op> for SysZOperand {
    fn from(insn: &cs_sysz_op) -> SysZOperand {
        match insn.type_ {
            sysz_op_type::SYSZ_OP_REG => {
                SysZOperand::Reg(RegId(unsafe { insn.__bindgen_anon_1.reg } as RegIdInt))
            },
            sysz_op_type::SYSZ_OP_IMM => SysZOperand::Imm(unsafe { insn.__bindgen_anon_1.imm }),
            sysz_op_type::SYSZ_OP_MEM => {
                SysZOperand::Mem(SysZOpMem(unsafe { insn.__bindgen_anon_1.mem }))
            },
            sysz_op_type::SYSZ_OP_ACREG => {
                SysZOperand::AcReg(RegId(unsafe { insn.__bindgen_anon_1.reg } as RegIdInt))
            },
            sysz_op_type::SYSZ_OP_INVALID => SysZOperand::Invalid,
        }
    }
}

def_arch_details_struct!(
    InsnDetail = SysZInsnDetail;
    Operand = SysZOperand;
    OperandIterator = SysZOperandIterator;
    OperandIteratorLife = SysZOperandIterator<'a>;
    [ pub struct SysZOperandIterator<'a>(slice::Iter<'a, cs_sysz_op>); ]
    cs_arch_op = cs_sysz_op;
    cs_arch = cs_sysz;
);