disasm-core 0.5.1

Core crate for disasm library
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
120
121
122
123
124

// !!!! CAUTION !!!!
// !---------------!
// !  DANGER ZONE  !
// !---------------!
// ! HIGH RISK  OF !
// ! BRAIN DAMAGE  !
// !---------------!
// !   KEEP OUT    !
// !!!!!!!!!!!!!!!!!

#[macro_export]
macro_rules! impl_arch_operands {
    ($(#[$attr:meta])* $vis:vis enum $name:ident {
        $($op:ident = $n:expr),+ $(,)?
    }) => (
        #[repr(u64)]
        #[derive(Copy, Clone, Debug, PartialEq, Eq)]
        $(#[$attr])*
        $vis enum $name {
            $($op = $n),+
        }

        impl From<$name> for u64 {
            fn from(value: $name) -> u64 {
                value as u64
            }
        }

        impl $name {
            pub fn from_u64(value: u64) -> Option<Self> {
                Some(match value {
                    $($n => Self::$op,)+
                    _ => return None,
                })
            }
        }
    );
}
pub use impl_arch_operands;

#[macro_export]
macro_rules! impl_opcode_check {
    ($($mask:expr, $opcode:expr, $name:ident;)*) => ($(
        #[inline]
        fn $name(&self) -> bool {
            self.raw() & $mask == $opcode
        }
    )*);
}
pub use impl_opcode_check;

#[macro_export]
macro_rules! impl_field {
    ($($name:ident =
        $pos:expr,
        $len:expr,
        $ret:tt $(: $cast:ty)?
        $(,$map:expr $(, $arg:ident: $arg_ty:ty)*)?
    ;)*) => ($(
        impl_field!(impl $name, $ret $(: $cast)?, $pos, $len $(,$map $(, $arg: $arg_ty)*)?);
    )*);
    (impl
         $name:ident,
         bool $(: $cast:ty)?,
         $pos:expr,
         $len:expr
         $(,$map:expr $(, $arg:ident: $arg_ty:ty)*)?
    ) => (
        fn $name(&self $($(, $arg: $arg_ty)*)?) -> bool {
            let ret = zextract(self.raw(), $pos, $len) $(as $cast)?;
            $(let ret = $map(ret $(, $arg)?);)?
            ret != 0
        }
    );
    (impl
        $name:ident,
        $ret:ty,
        $pos:expr,
        $len:expr
        $(,$map:expr $(, $arg:ident: $arg_ty:ty)*)?
    ) => (
        fn $name(&self $($(, $arg: $arg_ty)*)?) -> $ret {
            let ret = zextract(self.raw(), $pos, $len);
            $(let ret = $map(ret $(, $arg)?);)?
            ret as $ret
        }
    );
    (impl
        $name:ident,
        $ret:ty: $cast:ty,
        $pos:expr,
        $len:expr
        $(,$map:expr $(, $arg:ident: $arg_ty:ty)*)?
    ) => (
        fn $name(&self $($(, $arg: $arg_ty)*)?) -> $ret {
            let ret = zextract(self.raw(), $pos, $len) as $cast;
            $(let ret = $map(ret $(, $arg)?);)?
            ret
        }
    );
}
pub use impl_field;

#[macro_export]
macro_rules! define_opcodes {
    ($($name:ident = $mnemonic:literal),* $(,)?) => (
        #[allow(non_camel_case_types)]
        #[repr(u32)]
        enum Opcodes {
            $($name),*
        }

        $(pub const $name: Opcode = Opcode(Opcodes::$name as u32);)*

        #[cfg(feature = "mnemonic")]
        pub(crate) fn defined_mnemonic(opcode: Opcode) -> Option<&'static str> {
            Some(match opcode {
                $($name => $mnemonic,)*
                _ => return None,
            })
        }
    );
}
pub use define_opcodes;