keystone-engine 0.1.0

Rust bindings for the Keystone Engine assembler 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
125
126
127
128
129
130
131
132
133
134
135

{-# LANGUAGE ForeignFunctionInterface #-}

{-|
Module      : Keystone.Internal.Keystone
Description : The Keystone assembler engine.
Copyright   : (c) Adrian Herrera, 2016
License     : GPL-2

Low-level bindings for the Keystone assembler engine.

This module should not be directly imported; it is only exposed because of the
way cabal handles ordering of chs files.
-}
module Keystone.Internal.Keystone
    ( -- * Types
      Architecture(..)
    , Mode(..)
    , OptionType(..)
    , OptionValue(..)

      -- * Function bindings
    , ksOpen
    , ksOption
    , ksFree
    , ksAsm
    , ksVersion
    , ksErrno
    , ksStrerror
    ) where

import Foreign
import Foreign.C

import Keystone.Internal.Util

{# import Keystone.Internal.Core #}

{# context lib = "keystone" #}

#include <keystone/keystone.h>

-------------------------------------------------------------------------------
-- Types
-------------------------------------------------------------------------------

-- | CPU architecture.
{# enum ks_arch as Architecture
   { underscoreToCase }
   with prefix = "KS_"
   deriving (Show, Eq, Bounded)
#}

-- | CPU hardware mode.
{# enum ks_mode as Mode
   { underscoreToCase }
   with prefix = "KS_"
   deriving (Show, Eq, Bounded)
#}

-- | Runtime option types.
{# enum ks_opt_type as OptionType
   { underscoreToCase }
   with prefix = "KS_"
   deriving (Show, Eq, Bounded)
#}

-- | Runtime option values.
{# enum ks_opt_value as OptionValue
   { underscoreToCase }
   with prefix = "KS_OPT_"
   deriving (Show, Eq, Bounded)
#}

-------------------------------------------------------------------------------
-- Assembler control
-------------------------------------------------------------------------------

{# fun ks_open as ^
   { `Architecture'
   , combineEnums `[Mode]'
   , alloca- `EnginePtr' peek*
   } -> `Error'
#}

{# fun ks_option as ^
   { `Engine'
   , `OptionType'
   , `OptionValue'
   } -> `Error'
#}

{# fun ks_asm as ^
   { `Engine'
   ,  `String'
   ,  `Word64'
   ,  alloca- `Ptr CUChar' peek*
   ,  alloca- `Int' peekToInt*
   ,  alloca- `Int' peekToInt*
   } -> `Int'
#}

{# fun ks_free as ^
   { castPtr `Ptr CUChar'
   } -> `()'
#}

-------------------------------------------------------------------------------
-- Misc.
-------------------------------------------------------------------------------

{# fun pure unsafe ks_version as ^
   { id `Ptr CUInt'
   , id `Ptr CUInt'
   } -> `Int'
#}

{# fun unsafe ks_errno as ^
   { `Engine'
   } -> `Error'
#}

{# fun pure unsafe ks_strerror as ^
   { `Error'
   } -> `String'
#}

-------------------------------------------------------------------------------
-- Helper functions
-------------------------------------------------------------------------------

peekToInt :: (Storable a, Integral a, Num b)
          => Ptr a
          -> IO b
peekToInt ptr =
    peek ptr >>= (return . fromIntegral)