blob: 49e9504d84e9114b110e1fe58d0a1d7f61a3a60e [file] [log] [blame]
Nguyen Anh Quynh6023ef72014-04-29 11:21:04 +08001/* Capstone Disassembly Engine */
2/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2014 */
Axel 0vercl0k Souchet605faf12014-05-09 20:40:00 +01003#if defined (WIN32) || defined (WIN64) || defined (_WIN32) || defined (_WIN64)
4#pragma warning(disable:4996)
5#endif
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +08006#include <stddef.h>
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +08007#include <stdio.h>
8#include <stdlib.h>
9#include <string.h>
10#include <capstone.h>
11
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +080012#include "utils.h"
Nguyen Anh Quynhc7404072014-01-05 11:35:47 +080013#include "MCRegisterInfo.h"
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +080014
Axel 0vercl0k Souchet84fecf22014-05-10 09:49:29 +010015#ifdef CAPSTONE_USE_SYS_DYN_MEM
Nguyen Anh Quynh472a4a42014-03-06 09:13:04 +080016#define INSN_CACHE_SIZE 32
Nguyen Anh Quynha836b752014-03-06 03:36:03 +080017#else
Nguyen Anh Quynh5ee2b452014-03-07 08:40:35 +080018// reduce stack variable size for kernel/firmware
Nguyen Anh Quynha836b752014-03-06 03:36:03 +080019#define INSN_CACHE_SIZE 8
20#endif
Nguyen Anh Quynhc34959b2014-01-22 09:46:42 +080021
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +080022// default SKIPDATA mnemonic
Nguyen Anh Quynhc75a9092014-04-10 10:26:49 +080023#define SKIPDATA_MNEM ".byte"
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +080024
Nguyen Anh Quynh42c6b1a2013-12-30 00:15:25 +080025cs_err (*arch_init[MAX_ARCH])(cs_struct *) = { NULL };
Nguyen Anh Quynhee143c82014-01-03 21:51:59 +080026cs_err (*arch_option[MAX_ARCH]) (cs_struct *, cs_opt_type, size_t value) = { NULL };
27void (*arch_destroy[MAX_ARCH]) (cs_struct *) = { NULL };
Nguyen Anh Quynhf1851802013-12-21 12:16:47 +080028
Nguyen Anh Quynhc272e9d2014-01-19 12:03:22 +080029extern void ARM_enable(void);
30extern void AArch64_enable(void);
31extern void Mips_enable(void);
32extern void X86_enable(void);
33extern void PPC_enable(void);
Nguyen Anh Quynh05e27132014-03-10 11:58:57 +080034extern void Sparc_enable(void);
Nguyen Anh Quynh48a14ca2014-03-23 08:35:45 +080035extern void SystemZ_enable(void);
Nguyen Anh Quynhc80d8402014-05-26 23:02:48 +080036extern void XCore_enable(void);
danghvu701b8502014-01-09 11:06:44 +070037
Nguyen Anh Quynhc272e9d2014-01-19 12:03:22 +080038static void archs_enable(void)
Nguyen Anh Quynh625b5bc2014-01-09 14:33:56 +080039{
Nguyen Anh Quynhc272e9d2014-01-19 12:03:22 +080040 static bool initialized = false;
41
42 if (initialized)
43 return;
44
danghvub33bd2c2014-01-09 12:22:56 +070045#ifdef CAPSTONE_HAS_ARM
Nguyen Anh Quynhc272e9d2014-01-19 12:03:22 +080046 ARM_enable();
danghvub33bd2c2014-01-09 12:22:56 +070047#endif
48#ifdef CAPSTONE_HAS_ARM64
Nguyen Anh Quynhc272e9d2014-01-19 12:03:22 +080049 AArch64_enable();
danghvub33bd2c2014-01-09 12:22:56 +070050#endif
51#ifdef CAPSTONE_HAS_MIPS
Nguyen Anh Quynhc272e9d2014-01-19 12:03:22 +080052 Mips_enable();
danghvub33bd2c2014-01-09 12:22:56 +070053#endif
danghvub33bd2c2014-01-09 12:22:56 +070054#ifdef CAPSTONE_HAS_POWERPC
Nguyen Anh Quynhc272e9d2014-01-19 12:03:22 +080055 PPC_enable();
danghvub33bd2c2014-01-09 12:22:56 +070056#endif
Nguyen Anh Quynh05e27132014-03-10 11:58:57 +080057#ifdef CAPSTONE_HAS_SPARC
58 Sparc_enable();
59#endif
Nguyen Anh Quynh48a14ca2014-03-23 08:35:45 +080060#ifdef CAPSTONE_HAS_SYSZ
61 SystemZ_enable();
62#endif
Nguyen Anh Quynh05e27132014-03-10 11:58:57 +080063#ifdef CAPSTONE_HAS_X86
64 X86_enable();
65#endif
Nguyen Anh Quynhc80d8402014-05-26 23:02:48 +080066#ifdef CAPSTONE_HAS_XCORE
67 XCore_enable();
68#endif
69
Nguyen Anh Quynhc272e9d2014-01-19 12:03:22 +080070
71 initialized = true;
danghvub33bd2c2014-01-09 12:22:56 +070072}
73
Nguyen Anh Quynh39a42ed2013-12-22 10:40:58 +080074unsigned int all_arch = 0;
Nguyen Anh Quynhf1851802013-12-21 12:16:47 +080075
Axel 0vercl0k Souchet84fecf22014-05-10 09:49:29 +010076#ifdef CAPSTONE_USE_SYS_DYN_MEM
Nguyen Anh Quynha8eb7a52014-01-11 12:55:31 +080077cs_malloc_t cs_mem_malloc = malloc;
78cs_calloc_t cs_mem_calloc = calloc;
79cs_realloc_t cs_mem_realloc = realloc;
80cs_free_t cs_mem_free = free;
Nguyen Anh Quynhedeeb042014-01-15 20:44:03 +080081cs_vsnprintf_t cs_vsnprintf = vsnprintf;
Nguyen Anh Quynh59492c22014-01-05 23:41:31 +080082#else
Nguyen Anh Quynha8eb7a52014-01-11 12:55:31 +080083cs_malloc_t cs_mem_malloc = NULL;
84cs_calloc_t cs_mem_calloc = NULL;
85cs_realloc_t cs_mem_realloc = NULL;
86cs_free_t cs_mem_free = NULL;
Nguyen Anh Quynhedeeb042014-01-15 20:44:03 +080087cs_vsnprintf_t cs_vsnprintf = NULL;
Nguyen Anh Quynh59492c22014-01-05 23:41:31 +080088#endif
Nguyen Anh Quynhb8806782013-12-22 15:20:07 +080089
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +080090CAPSTONE_EXPORT
Nguyen Anh Quynhb90cb992013-12-28 13:59:09 +080091unsigned int cs_version(int *major, int *minor)
Nguyen Anh Quynh36df4bb2013-12-10 13:31:20 +080092{
Nguyen Anh Quynhc46c35d2014-03-05 00:21:53 +080093 archs_enable();
94
Nguyen Anh Quynh08777472013-12-22 14:16:28 +080095 if (major != NULL && minor != NULL) {
96 *major = CS_API_MAJOR;
97 *minor = CS_API_MINOR;
98 }
Nguyen Anh Quynh39a42ed2013-12-22 10:40:58 +080099
100 return (CS_API_MAJOR << 8) + CS_API_MINOR;
101}
102
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800103CAPSTONE_EXPORT
Nguyen Anh Quynhb2870e42014-02-22 23:41:16 +0800104bool cs_support(int query)
Nguyen Anh Quynh39a42ed2013-12-22 10:40:58 +0800105{
Nguyen Anh Quynhc46c35d2014-03-05 00:21:53 +0800106 archs_enable();
107
Nguyen Anh Quynhb2870e42014-02-22 23:41:16 +0800108 if (query == CS_ARCH_ALL)
Nguyen Anh Quynh39a42ed2013-12-22 10:40:58 +0800109 return all_arch == ((1 << CS_ARCH_ARM) | (1 << CS_ARCH_ARM64) |
Nguyen Anh Quynh42c6b1a2013-12-30 00:15:25 +0800110 (1 << CS_ARCH_MIPS) | (1 << CS_ARCH_X86) |
Nguyen Anh Quynh48a14ca2014-03-23 08:35:45 +0800111 (1 << CS_ARCH_PPC) | (1 << CS_ARCH_SPARC) |
Nguyen Anh Quynhc80d8402014-05-26 23:02:48 +0800112 (1 << CS_ARCH_SYSZ) | (1 << CS_ARCH_XCORE));
Nguyen Anh Quynh39a42ed2013-12-22 10:40:58 +0800113
Nguyen Anh Quynh48d58322014-02-27 13:54:28 +0800114 if ((unsigned int)query < CS_ARCH_MAX)
Nguyen Anh Quynhb2870e42014-02-22 23:41:16 +0800115 return all_arch & (1 << query);
116
117 if (query == CS_SUPPORT_DIET) {
118#ifdef CAPSTONE_DIET
119 return true;
120#else
121 return false;
122#endif
123 }
124
Nguyen Anh Quynh59b54892014-03-27 10:54:44 +0800125 if (query == CS_SUPPORT_X86_REDUCE) {
126#if defined(CAPSTONE_HAS_X86) && defined(CAPSTONE_X86_REDUCE)
Nguyen Anh Quynh95181482014-03-25 23:20:41 +0800127 return true;
128#else
129 return false;
130#endif
131 }
132
Nguyen Anh Quynhb2870e42014-02-22 23:41:16 +0800133 // unsupported query
134 return false;
Nguyen Anh Quynh36df4bb2013-12-10 13:31:20 +0800135}
136
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800137CAPSTONE_EXPORT
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800138cs_err cs_errno(csh handle)
139{
Nguyen Anh Quynhbb0744d2014-05-12 13:41:49 +0800140 struct cs_struct *ud;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800141 if (!handle)
142 return CS_ERR_CSH;
143
Axel 0vercl0k Souchet779d4c72014-05-08 23:44:49 +0100144 ud = (struct cs_struct *)(uintptr_t)handle;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800145
Nguyen Anh Quynh3eb9ac92013-11-27 15:24:47 +0800146 return ud->errnum;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800147}
148
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800149CAPSTONE_EXPORT
Nguyen Anh Quynh34f96382014-01-03 22:49:07 +0800150const char *cs_strerror(cs_err code)
151{
152 switch(code) {
153 default:
154 return "Unknown error code";
155 case CS_ERR_OK:
156 return "OK (CS_ERR_OK)";
157 case CS_ERR_MEM:
158 return "Out of memory (CS_ERR_MEM)";
159 case CS_ERR_ARCH:
160 return "Invalid architecture (CS_ERR_ARCH)";
161 case CS_ERR_HANDLE:
162 return "Invalid handle (CS_ERR_HANDLE)";
163 case CS_ERR_CSH:
164 return "Invalid csh (CS_ERR_CSH)";
165 case CS_ERR_MODE:
166 return "Invalid mode (CS_ERR_MODE)";
167 case CS_ERR_OPTION:
168 return "Invalid option (CS_ERR_OPTION)";
169 case CS_ERR_DETAIL:
170 return "Details are unavailable (CS_ERR_DETAIL)";
Nguyen Anh Quynhc52352d2014-01-06 09:06:30 +0800171 case CS_ERR_MEMSETUP:
172 return "Dynamic memory management uninitialized (CS_ERR_MEMSETUP)";
Nguyen Anh Quynh4f220282014-02-09 00:19:15 +0800173 case CS_ERR_VERSION:
174 return "Different API version between core & binding (CS_ERR_VERSION)";
Nguyen Anh Quynhf7cdbdf2014-02-24 16:47:36 +0800175 case CS_ERR_DIET:
176 return "Information irrelevant in diet engine (CS_ERR_DIET)";
Nguyen Anh Quynh11ec8812014-04-10 17:20:01 +0800177 case CS_ERR_SKIPDATA:
178 return "Information irrelevant for 'data' instruction in SKIPDATA mode (CS_ERR_SKIPDATA)";
Nguyen Anh Quynh34f96382014-01-03 22:49:07 +0800179 }
180}
181
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800182CAPSTONE_EXPORT
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800183cs_err cs_open(cs_arch arch, cs_mode mode, csh *handle)
184{
Nguyen Anh Quynh42706a32014-05-09 07:33:35 +0800185 cs_err err;
Nguyen Anh Quynhbb0744d2014-05-12 13:41:49 +0800186 struct cs_struct *ud;
Nguyen Anh Quynhedeeb042014-01-15 20:44:03 +0800187 if (!cs_mem_malloc || !cs_mem_calloc || !cs_mem_realloc || !cs_mem_free || !cs_vsnprintf)
Nguyen Anh Quynhc52352d2014-01-06 09:06:30 +0800188 // Error: before cs_open(), dynamic memory management must be initialized
189 // with cs_option(CS_OPT_MEM)
190 return CS_ERR_MEMSETUP;
191
Nguyen Anh Quynhc272e9d2014-01-19 12:03:22 +0800192 archs_enable();
193
Nguyen Anh Quynh8f7ab492014-01-06 09:52:57 +0800194 if (arch < CS_ARCH_MAX && arch_init[arch]) {
Nguyen Anh Quynha8eb7a52014-01-11 12:55:31 +0800195 ud = cs_mem_calloc(1, sizeof(*ud));
Nguyen Anh Quynh8f7ab492014-01-06 09:52:57 +0800196 if (!ud) {
197 // memory insufficient
198 return CS_ERR_MEM;
199 }
200
Nguyen Anh Quynh9a197b32013-12-22 13:41:38 +0800201 ud->errnum = CS_ERR_OK;
202 ud->arch = arch;
203 ud->mode = mode;
204 ud->big_endian = mode & CS_MODE_BIG_ENDIAN;
Nguyen Anh Quynh39b812d2014-01-07 23:36:26 +0800205 // by default, do not break instruction into details
206 ud->detail = CS_OPT_OFF;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800207
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800208 // default skipdata setup
209 ud->skipdata_setup.mnemonic = SKIPDATA_MNEM;
210
Axel 0vercl0k Souchet779d4c72014-05-08 23:44:49 +0100211 err = arch_init[ud->arch](ud);
Nguyen Anh Quynh06b3c052014-01-21 15:26:02 +0800212 if (err) {
213 cs_mem_free(ud);
214 *handle = 0;
215 return err;
216 }
Nguyen Anh Quynh8f7ab492014-01-06 09:52:57 +0800217
218 *handle = (uintptr_t)ud;
219
220 return CS_ERR_OK;
Nguyen Anh Quynh9a197b32013-12-22 13:41:38 +0800221 } else {
222 *handle = 0;
223 return CS_ERR_ARCH;
224 }
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800225}
226
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800227CAPSTONE_EXPORT
Nguyen Anh Quynh226d7dc2014-02-27 22:20:39 +0800228cs_err cs_close(csh *handle)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800229{
Nguyen Anh Quynhbb0744d2014-05-12 13:41:49 +0800230 struct cs_struct *ud;
231
Nguyen Anh Quynhef3d04d2014-02-27 23:42:49 +0800232 if (*handle == 0)
Nguyen Anh Quynh226d7dc2014-02-27 22:20:39 +0800233 // invalid handle
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800234 return CS_ERR_CSH;
235
Axel 0vercl0k Souchet779d4c72014-05-08 23:44:49 +0100236 ud = (struct cs_struct *)(*handle);
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800237
Nguyen Anh Quynhfbe10a52014-02-27 23:59:08 +0800238 if (ud->printer_info)
239 cs_mem_free(ud->printer_info);
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800240
Nguyen Anh Quynh9fac5122014-01-07 10:56:04 +0800241 // arch_destroy[ud->arch](ud);
Nguyen Anh Quynhb2654062014-01-03 17:08:58 +0800242
Nguyen Anh Quynha8eb7a52014-01-11 12:55:31 +0800243 cs_mem_free(ud->insn_cache);
Nguyen Anh Quynhee143c82014-01-03 21:51:59 +0800244 memset(ud, 0, sizeof(*ud));
Nguyen Anh Quynha8eb7a52014-01-11 12:55:31 +0800245 cs_mem_free(ud);
Nguyen Anh Quynhee143c82014-01-03 21:51:59 +0800246
Nguyen Anh Quynhc8e07852014-02-28 09:38:11 +0800247 // invalidate this handle by ZERO out its value.
248 // this is to make sure it is unusable after cs_close()
Nguyen Anh Quynh226d7dc2014-02-27 22:20:39 +0800249 *handle = 0;
250
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800251 return CS_ERR_OK;
252}
253
254// fill insn with mnemonic & operands info
Nguyen Anh Quynha82a0892014-01-23 23:42:40 +0800255static void fill_insn(struct cs_struct *handle, cs_insn *insn, char *buffer, MCInst *mci,
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800256 PostPrinter_t postprinter, const uint8_t *code)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800257{
Nguyen Anh Quynh8c2e2db2014-05-14 07:32:56 +0800258#ifndef CAPSTONE_DIET
Nguyen Anh Quynh5329a6f2014-06-08 23:35:52 +0700259 char *sp, *mnem;
Nguyen Anh Quynh8c2e2db2014-05-14 07:32:56 +0800260#endif
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800261
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800262 // fill the instruction bytes
263 memcpy(insn->bytes, code, MIN(sizeof(insn->bytes), insn->size));
264
Nguyen Anh Quynh4d3e8522013-12-14 10:45:09 +0800265 // map internal instruction opcode to public insn ID
Nguyen Anh Quynh07e84a22014-06-08 19:27:22 +0800266 handle->insn_id(handle, insn, MCInst_getOpcode(mci));
Nguyen Anh Quynh4d3e8522013-12-14 10:45:09 +0800267
268 // alias instruction might have ID saved in OpcodePub
269 if (MCInst_getOpcodePub(mci))
270 insn->id = MCInst_getOpcodePub(mci);
271
272 // post printer handles some corner cases (hacky)
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800273 if (postprinter)
Nguyen Anh Quynh64564812014-05-19 16:46:31 +0800274 postprinter((csh)handle, insn, buffer, mci);
Nguyen Anh Quynh4d3e8522013-12-14 10:45:09 +0800275
Nguyen Anh Quynhfc83a432014-02-22 23:26:27 +0800276#ifndef CAPSTONE_DIET
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800277 // fill in mnemonic & operands
Nguyen Anh Quynhdefb9bc2013-12-12 14:00:12 +0800278 // find first space or tab
Axel 0vercl0k Souchet779d4c72014-05-08 23:44:49 +0100279 sp = buffer;
Nguyen Anh Quynh7566a2d2014-06-08 22:09:31 +0800280 mnem = insn->mnemonic;
Nguyen Anh Quynh177dd9b2014-06-08 00:17:10 +0800281 if (mci->x86_prefix[0]) {
282 for (sp = buffer; *sp; sp++) {
Nguyen Anh Quynhdb3c00c2014-06-13 11:16:53 +0700283 if (*sp == ' '|| *sp == '\t')
Nguyen Anh Quynh177dd9b2014-06-08 00:17:10 +0800284 break;
285 if (*sp == '|') // lock|rep prefix for x86
286 *sp = ' ';
Nguyen Anh Quynh7566a2d2014-06-08 22:09:31 +0800287 // copy to @mnemonic
288 *mnem = *sp;
289 mnem++;
Nguyen Anh Quynh177dd9b2014-06-08 00:17:10 +0800290 }
291 } else {
292 for (sp = buffer; *sp; sp++) {
Nguyen Anh Quynhdb3c00c2014-06-13 11:16:53 +0700293 if (*sp == ' '|| *sp == '\t')
Nguyen Anh Quynh177dd9b2014-06-08 00:17:10 +0800294 break;
Nguyen Anh Quynh7566a2d2014-06-08 22:09:31 +0800295 // copy to @mnemonic
296 *mnem = *sp;
297 mnem++;
Nguyen Anh Quynh177dd9b2014-06-08 00:17:10 +0800298 }
Nguyen Anh Quynha5ffdc32014-05-07 08:25:24 +0800299 }
300
Nguyen Anh Quynh7566a2d2014-06-08 22:09:31 +0800301 *mnem = '\0';
302
303 // copy @op_str
Nguyen Anh Quynhdefb9bc2013-12-12 14:00:12 +0800304 if (*sp) {
305 *sp = '\0';
Nguyen Anh Quynh86dc3932013-12-12 14:43:39 +0800306 // find the next non-space char
307 sp++;
308 for (; ((*sp == ' ') || (*sp == '\t')); sp++);
309 strncpy(insn->op_str, sp, sizeof(insn->op_str) - 1);
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800310 insn->op_str[sizeof(insn->op_str) - 1] = '\0';
311 } else
312 insn->op_str[0] = '\0';
Nguyen Anh Quynhfc83a432014-02-22 23:26:27 +0800313#endif
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800314}
315
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800316// how many bytes will we skip when encountering data (CS_OPT_SKIPDATA)?
Nguyen Anh Quynha89383e2014-04-10 11:53:46 +0800317// this very much depends on instruction alignment requirement of each arch.
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800318static uint8_t skipdata_size(cs_struct *handle)
319{
320 switch(handle->arch) {
321 default:
322 // should never reach
323 return -1;
324 case CS_ARCH_ARM:
Nguyen Anh Quynha89383e2014-04-10 11:53:46 +0800325 // skip 2 bytes on Thumb mode.
326 if (handle->mode & CS_MODE_THUMB)
327 return 2;
328 // otherwise, skip 4 bytes
329 return 4;
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800330 case CS_ARCH_ARM64:
331 case CS_ARCH_MIPS:
332 case CS_ARCH_PPC:
333 case CS_ARCH_SPARC:
Nguyen Anh Quynha89383e2014-04-10 11:53:46 +0800334 // skip 4 bytes
335 return 4;
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800336 case CS_ARCH_SYSZ:
Nguyen Anh Quynha89383e2014-04-10 11:53:46 +0800337 // SystemZ instruction's length can be 2, 4 or 6 bytes,
338 // so we just skip 2 bytes
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800339 return 2;
340 case CS_ARCH_X86:
341 // X86 has no restriction on instruction alignment
342 return 1;
Nguyen Anh Quynhc80d8402014-05-26 23:02:48 +0800343 case CS_ARCH_XCORE:
344 // XCore instruction's length can be 2 or 4 bytes,
345 // so we just skip 2 bytes
346 return 2;
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800347 }
348}
349
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800350CAPSTONE_EXPORT
Nguyen Anh Quynhda8adad2013-12-04 09:44:07 +0800351cs_err cs_option(csh ud, cs_opt_type type, size_t value)
Nguyen Anh Quynh01aba002013-12-03 21:00:09 +0800352{
Nguyen Anh Quynhbb0744d2014-05-12 13:41:49 +0800353 struct cs_struct *handle;
Nguyen Anh Quynhc46c35d2014-03-05 00:21:53 +0800354 archs_enable();
355
Nguyen Anh Quynh24bf0d92014-01-05 11:19:04 +0800356 // cs_option() can be called with NULL handle just for CS_OPT_MEM
357 // This is supposed to be executed before all other APIs (even cs_open())
358 if (type == CS_OPT_MEM) {
359 cs_opt_mem *mem = (cs_opt_mem *)value;
360
Nguyen Anh Quynha8eb7a52014-01-11 12:55:31 +0800361 cs_mem_malloc = mem->malloc;
362 cs_mem_calloc = mem->calloc;
363 cs_mem_realloc = mem->realloc;
364 cs_mem_free = mem->free;
Nguyen Anh Quynhedeeb042014-01-15 20:44:03 +0800365 cs_vsnprintf = mem->vsnprintf;
Nguyen Anh Quynh24bf0d92014-01-05 11:19:04 +0800366
367 return CS_ERR_OK;
368 }
369
Axel 0vercl0k Souchet779d4c72014-05-08 23:44:49 +0100370 handle = (struct cs_struct *)(uintptr_t)ud;
danghvu2b192962013-12-19 22:40:28 -0600371 if (!handle)
372 return CS_ERR_CSH;
Nguyen Anh Quynh01aba002013-12-03 21:00:09 +0800373
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800374 switch(type) {
375 default:
376 break;
377 case CS_OPT_DETAIL:
378 handle->detail = value;
379 return CS_ERR_OK;
380 case CS_OPT_SKIPDATA:
381 handle->skipdata = (value == CS_OPT_ON);
382 if (handle->skipdata) {
383 if (handle->skipdata_size == 0) {
384 // set the default skipdata size
385 handle->skipdata_size = skipdata_size(handle);
386 }
387 }
388 return CS_ERR_OK;
389 case CS_OPT_SKIPDATA_SETUP:
390 if (value)
391 handle->skipdata_setup = *((cs_opt_skipdata *)value);
392 return CS_ERR_OK;
Nguyen Anh Quynh7d02c922013-12-21 09:59:31 +0800393 }
Nguyen Anh Quynha209e672013-12-14 00:23:41 +0800394
Nguyen Anh Quynhd3458392013-12-22 11:10:56 +0800395 return arch_option[handle->arch](handle, type, value);
Nguyen Anh Quynh01aba002013-12-03 21:00:09 +0800396}
397
Nguyen Anh Quynh07ffd642014-04-10 14:36:08 +0800398// generate @op_str for data instruction of SKIPDATA
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800399static void skipdata_opstr(char *opstr, const uint8_t *buffer, size_t size)
400{
401 char *p = opstr;
402 int len;
403 size_t i;
404
405 if (!size) {
406 opstr[0] = '\0';
407 return;
408 }
409
410 len = sprintf(p, "0x%02x", buffer[0]);
411 p+= len;
412
413 for(i = 1; i < size; i++) {
414 len = sprintf(p, ", 0x%02x", buffer[i]);
415 p+= len;
416 }
417}
418
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800419// dynamicly allocate memory to contain disasm insn
420// NOTE: caller must free() the allocated memory itself to avoid memory leaking
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800421CAPSTONE_EXPORT
Nguyen Anh Quynh04c19be2013-12-25 13:26:22 +0800422size_t cs_disasm_ex(csh ud, const uint8_t *buffer, size_t size, uint64_t offset, size_t count, cs_insn **insn)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800423{
Nguyen Anh Quynha82a0892014-01-23 23:42:40 +0800424 struct cs_struct *handle = (struct cs_struct *)(uintptr_t)ud;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800425 MCInst mci;
426 uint16_t insn_size;
Nguyen Anh Quynh6c182ae2014-06-18 21:50:25 +0800427 size_t c = 0, i;
Nguyen Anh Quynh7772d852014-01-21 11:49:25 +0800428 unsigned int f = 0;
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700429 cs_insn *insn_cache;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800430 void *total = NULL;
Nguyen Anh Quynhb42a6572013-11-29 17:40:07 +0800431 size_t total_size = 0;
Nguyen Anh Quynh034a7482014-03-06 22:40:08 +0800432 bool r;
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800433 void *tmp;
434 size_t skipdata_bytes;
Nguyen Anh Quynh07ffd642014-04-10 14:36:08 +0800435 uint64_t offset_org;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800436
Nguyen Anh Quynh5848aaa2014-02-27 11:10:41 +0800437 if (!handle) {
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800438 // FIXME: how to handle this case:
Nguyen Anh Quynh3eb9ac92013-11-27 15:24:47 +0800439 // handle->errnum = CS_ERR_HANDLE;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800440 return 0;
441 }
442
Nguyen Anh Quynh3eb9ac92013-11-27 15:24:47 +0800443 handle->errnum = CS_ERR_OK;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800444
Nguyen Anh Quynh2cff6f62014-04-28 11:19:44 +0800445 // save the original offset for SKIPDATA
Nguyen Anh Quynh07ffd642014-04-10 14:36:08 +0800446 offset_org = offset;
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700447 total_size = (sizeof(cs_insn) * INSN_CACHE_SIZE);
448 total = cs_mem_malloc(total_size);
449 insn_cache = total;
Nguyen Anh Quynh2cff6f62014-04-28 11:19:44 +0800450
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800451 while (size > 0) {
Nguyen Anh Quynh495295e2014-06-16 15:54:32 +0800452 MCInst_Init(&mci);
Nguyen Anh Quynh42c6b1a2013-12-30 00:15:25 +0800453 mci.csh = handle;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800454
Nguyen Anh Quynh5329a6f2014-06-08 23:35:52 +0700455 // relative branches need to know the address & size of current insn
456 mci.address = offset;
457
458 if (handle->detail) {
459 // allocate memory for @detail pointer
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700460 insn_cache->detail = cs_mem_malloc(sizeof(cs_detail));
Nguyen Anh Quynh5329a6f2014-06-08 23:35:52 +0700461 } else {
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700462 insn_cache->detail = NULL;
Nguyen Anh Quynh5329a6f2014-06-08 23:35:52 +0700463 }
464
465 // save all the information for non-detailed mode
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700466 mci.flat_insn = insn_cache;
Nguyen Anh Quynh5329a6f2014-06-08 23:35:52 +0700467 mci.flat_insn->address = offset;
468
Nguyen Anh Quynha5ffdc32014-05-07 08:25:24 +0800469 r = handle->disasm(ud, buffer, size, &mci, &insn_size, offset, handle->getinsn_info);
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800470 if (r) {
471 SStream ss;
472 SStream_Init(&ss);
473
Nguyen Anh Quynh5329a6f2014-06-08 23:35:52 +0700474 mci.flat_insn->size = insn_size;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800475 handle->printer(&mci, &ss, handle->printer_info);
476
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700477 fill_insn(handle, insn_cache, ss.buffer, &mci, handle->post_printer, buffer);
Nguyen Anh Quynha209e672013-12-14 00:23:41 +0800478
Nguyen Anh Quynha5ffdc32014-05-07 08:25:24 +0800479 f++;
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700480 if (f == INSN_CACHE_SIZE) {
Nguyen Anh Quynha5ffdc32014-05-07 08:25:24 +0800481 // resize total to contain newly disasm insns
482 total_size += (sizeof(cs_insn) * INSN_CACHE_SIZE);
483 tmp = cs_mem_realloc(total, total_size);
484 if (tmp == NULL) { // insufficient memory
Nguyen Anh Quynh6c182ae2014-06-18 21:50:25 +0800485 if (handle->detail) {
486 insn_cache = (cs_insn *)total;
487 for (i = 0; i < c; i++, insn_cache++)
488 cs_mem_free(insn_cache->detail);
489 }
490
Nguyen Anh Quynha5ffdc32014-05-07 08:25:24 +0800491 cs_mem_free(total);
492 handle->errnum = CS_ERR_MEM;
493 return 0;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800494 }
495
Nguyen Anh Quynha5ffdc32014-05-07 08:25:24 +0800496 total = tmp;
Nguyen Anh Quynhcae09bf2014-06-17 14:58:39 +0800497 insn_cache = (cs_insn *)((char *)total + total_size - (sizeof(cs_insn) * INSN_CACHE_SIZE));
Nguyen Anh Quynha5ffdc32014-05-07 08:25:24 +0800498
499 // reset f back to 0
500 f = 0;
Nguyen Anh Quynhc88d9922014-06-09 01:59:00 +0800501 } else
502 insn_cache++;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800503
Nguyen Anh Quynha5ffdc32014-05-07 08:25:24 +0800504 c++;
Nguyen Anh Quynha5ffdc32014-05-07 08:25:24 +0800505 if (count > 0 && c == count)
506 break;
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700507
508 buffer += insn_size;
509 size -= insn_size;
510 offset += insn_size;
Nguyen Anh Quynh8f13f3c2013-12-04 22:57:04 +0800511 } else {
Nguyen Anh Quynh6c182ae2014-06-18 21:50:25 +0800512 if (handle->detail) {
513 // free memory of @detail pointer
514 cs_mem_free(insn_cache->detail);
515 }
516
Nguyen Anh Quynh8f13f3c2013-12-04 22:57:04 +0800517 // encounter a broken instruction
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800518 // if there is no request to skip data, or remaining data is too small,
519 // then bail out
520 if (!handle->skipdata || handle->skipdata_size > size)
521 break;
522
523 if (handle->skipdata_setup.callback) {
Nguyen Anh Quynh42288ac2014-04-14 14:53:13 +0800524 skipdata_bytes = handle->skipdata_setup.callback(buffer, offset - offset_org,
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800525 handle->skipdata_setup.user_data);
526 if (skipdata_bytes > size)
527 // remaining data is not enough
528 break;
529
530 if (!skipdata_bytes)
531 // user requested not to skip data, so bail out
532 break;
533 } else
534 skipdata_bytes = handle->skipdata_size;
535
536 // we have to skip some amount of data, depending on arch & mode
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700537 insn_cache->id = 0; // invalid ID for this "data" instruction
538 insn_cache->address = offset;
539 insn_cache->size = skipdata_bytes;
540 memcpy(insn_cache->bytes, buffer, skipdata_bytes);
541 strncpy(insn_cache->mnemonic, handle->skipdata_setup.mnemonic,
542 sizeof(insn_cache->mnemonic) - 1);
543 skipdata_opstr(insn_cache->op_str, buffer, skipdata_bytes);
544 insn_cache->detail = NULL;
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800545
546 f++;
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700547 if (f == INSN_CACHE_SIZE) {
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800548 // resize total to contain newly disasm insns
549
550 total_size += (sizeof(cs_insn) * INSN_CACHE_SIZE);
551 tmp = cs_mem_realloc(total, total_size);
552 if (tmp == NULL) { // insufficient memory
Nguyen Anh Quynh6c182ae2014-06-18 21:50:25 +0800553 if (handle->detail) {
554 insn_cache = (cs_insn *)total;
555 for (i = 0; i < c; i++, insn_cache++)
556 cs_mem_free(insn_cache->detail);
557 }
558
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800559 cs_mem_free(total);
560 handle->errnum = CS_ERR_MEM;
561 return 0;
562 }
563
564 total = tmp;
Nguyen Anh Quynh6c182ae2014-06-18 21:50:25 +0800565 insn_cache = (cs_insn *)((char *)total + total_size - (sizeof(cs_insn) * INSN_CACHE_SIZE));
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800566
567 // reset f back to 0
568 f = 0;
Nguyen Anh Quynh6c182ae2014-06-18 21:50:25 +0800569 } else
570 insn_cache++;
Nguyen Anh Quynhd3ffe372014-04-09 23:49:30 +0800571
572 buffer += skipdata_bytes;
573 size -= skipdata_bytes;
574 offset += skipdata_bytes;
575 c++;
Nguyen Anh Quynh8f13f3c2013-12-04 22:57:04 +0800576 }
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800577 }
578
579 if (f) {
580 // resize total to contain newly disasm insns
Nguyen Anh Quynhee583942014-06-09 00:13:31 +0700581 void *tmp = cs_mem_realloc(total, total_size - (INSN_CACHE_SIZE - f) * sizeof(*insn_cache));
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800582 if (tmp == NULL) { // insufficient memory
Nguyen Anh Quynh6c182ae2014-06-18 21:50:25 +0800583 // free all detail pointers
584 if (handle->detail) {
585 insn_cache = (cs_insn *)total;
586 for (i = 0; i < c; i++, insn_cache++)
587 cs_mem_free(insn_cache->detail);
588 }
589
Nguyen Anh Quynha8eb7a52014-01-11 12:55:31 +0800590 cs_mem_free(total);
Nguyen Anh Quynh6c182ae2014-06-18 21:50:25 +0800591
Nguyen Anh Quynh3eb9ac92013-11-27 15:24:47 +0800592 handle->errnum = CS_ERR_MEM;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800593 return 0;
594 }
595
596 total = tmp;
Nguyen Anh Quynh6c182ae2014-06-18 21:50:25 +0800597 } else if (!c) {
598 cs_mem_free(total);
599 total = NULL;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800600 }
601
602 *insn = total;
603
604 return c;
605}
606
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800607CAPSTONE_EXPORT
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800608void cs_free(cs_insn *insn, size_t count)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800609{
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800610 size_t i;
611
612 // free all detail pointers
613 for (i = 0; i < count; i++)
Nguyen Anh Quynha8eb7a52014-01-11 12:55:31 +0800614 cs_mem_free(insn[i].detail);
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800615
616 // then free pointer to cs_insn array
Nguyen Anh Quynha8eb7a52014-01-11 12:55:31 +0800617 cs_mem_free(insn);
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800618}
619
620// return friendly name of regiser in a string
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800621CAPSTONE_EXPORT
pancakef0e4eed2013-12-11 22:14:42 +0100622const char *cs_reg_name(csh ud, unsigned int reg)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800623{
Nguyen Anh Quynha82a0892014-01-23 23:42:40 +0800624 struct cs_struct *handle = (struct cs_struct *)(uintptr_t)ud;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800625
626 if (!handle || handle->reg_name == NULL) {
627 return NULL;
628 }
629
Nguyen Anh Quynha253c7a2013-12-09 10:26:18 +0800630 return handle->reg_name(ud, reg);
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800631}
632
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800633CAPSTONE_EXPORT
pancakef0e4eed2013-12-11 22:14:42 +0100634const char *cs_insn_name(csh ud, unsigned int insn)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800635{
Nguyen Anh Quynha82a0892014-01-23 23:42:40 +0800636 struct cs_struct *handle = (struct cs_struct *)(uintptr_t)ud;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800637
638 if (!handle || handle->insn_name == NULL) {
639 return NULL;
640 }
641
Nguyen Anh Quynha253c7a2013-12-09 10:26:18 +0800642 return handle->insn_name(ud, insn);
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800643}
644
Nguyen Anh Quynh70083562013-12-20 22:02:20 +0800645static bool arr_exist(unsigned char *arr, unsigned char max, unsigned int id)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800646{
647 int i;
648
649 for (i = 0; i < max; i++) {
650 if (arr[i] == id)
651 return true;
652 }
653
654 return false;
655}
656
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800657CAPSTONE_EXPORT
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800658bool cs_insn_group(csh ud, cs_insn *insn, unsigned int group_id)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800659{
Nguyen Anh Quynhbb0744d2014-05-12 13:41:49 +0800660 struct cs_struct *handle;
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800661 if (!ud)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800662 return false;
663
Axel 0vercl0k Souchet779d4c72014-05-08 23:44:49 +0100664 handle = (struct cs_struct *)(uintptr_t)ud;
Giovanni Condelloa715df12014-05-07 17:25:38 +0200665
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800666 if (!handle->detail) {
667 handle->errnum = CS_ERR_DETAIL;
668 return false;
669 }
670
Giovanni Condello95657e02014-05-07 17:31:27 +0200671 if(!insn->id) {
672 handle->errnum = CS_ERR_SKIPDATA;
673 return false;
674 }
Giovanni Condelloa715df12014-05-07 17:25:38 +0200675
Giovanni Condello95657e02014-05-07 17:31:27 +0200676 if(!insn->detail) {
677 handle->errnum = CS_ERR_DETAIL;
678 return false;
679 }
Giovanni Condelloa715df12014-05-07 17:25:38 +0200680
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800681 return arr_exist(insn->detail->groups, insn->detail->groups_count, group_id);
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800682}
683
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800684CAPSTONE_EXPORT
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800685bool cs_reg_read(csh ud, cs_insn *insn, unsigned int reg_id)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800686{
Nguyen Anh Quynhbb0744d2014-05-12 13:41:49 +0800687 struct cs_struct *handle;
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800688 if (!ud)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800689 return false;
690
Axel 0vercl0k Souchet779d4c72014-05-08 23:44:49 +0100691 handle = (struct cs_struct *)(uintptr_t)ud;
Giovanni Condelloa715df12014-05-07 17:25:38 +0200692
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800693 if (!handle->detail) {
694 handle->errnum = CS_ERR_DETAIL;
695 return false;
696 }
697
Giovanni Condello95657e02014-05-07 17:31:27 +0200698 if(!insn->id) {
699 handle->errnum = CS_ERR_SKIPDATA;
700 return false;
701 }
Giovanni Condelloa715df12014-05-07 17:25:38 +0200702
Giovanni Condello95657e02014-05-07 17:31:27 +0200703 if(!insn->detail) {
704 handle->errnum = CS_ERR_DETAIL;
705 return false;
706 }
Giovanni Condelloa715df12014-05-07 17:25:38 +0200707
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800708 return arr_exist(insn->detail->regs_read, insn->detail->regs_read_count, reg_id);
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800709}
710
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800711CAPSTONE_EXPORT
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800712bool cs_reg_write(csh ud, cs_insn *insn, unsigned int reg_id)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800713{
Nguyen Anh Quynhbb0744d2014-05-12 13:41:49 +0800714 struct cs_struct *handle;
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800715 if (!ud)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800716 return false;
717
Axel 0vercl0k Souchet779d4c72014-05-08 23:44:49 +0100718 handle = (struct cs_struct *)(uintptr_t)ud;
Giovanni Condello95657e02014-05-07 17:31:27 +0200719
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800720 if (!handle->detail) {
721 handle->errnum = CS_ERR_DETAIL;
722 return false;
723 }
724
Giovanni Condello95657e02014-05-07 17:31:27 +0200725 if(!insn->id) {
726 handle->errnum = CS_ERR_SKIPDATA;
727 return false;
728 }
Giovanni Condelloa715df12014-05-07 17:25:38 +0200729
Giovanni Condello95657e02014-05-07 17:31:27 +0200730 if(!insn->detail) {
731 handle->errnum = CS_ERR_DETAIL;
732 return false;
733 }
Giovanni Condelloa715df12014-05-07 17:25:38 +0200734
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800735 return arr_exist(insn->detail->regs_write, insn->detail->regs_write_count, reg_id);
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800736}
737
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800738CAPSTONE_EXPORT
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800739int cs_op_count(csh ud, cs_insn *insn, unsigned int op_type)
740{
Nguyen Anh Quynhbb0744d2014-05-12 13:41:49 +0800741 struct cs_struct *handle;
742 unsigned int count = 0, i;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800743 if (!ud)
744 return -1;
745
Axel 0vercl0k Souchet779d4c72014-05-08 23:44:49 +0100746 handle = (struct cs_struct *)(uintptr_t)ud;
Giovanni Condelloa715df12014-05-07 17:25:38 +0200747
Nguyen Anh Quynh24e12272014-01-15 21:27:23 +0800748 if (!handle->detail) {
749 handle->errnum = CS_ERR_DETAIL;
750 return -1;
751 }
752
Giovanni Condello95657e02014-05-07 17:31:27 +0200753 if(!insn->id) {
754 handle->errnum = CS_ERR_SKIPDATA;
755 return -1;
756 }
Giovanni Condelloa715df12014-05-07 17:25:38 +0200757
Giovanni Condello95657e02014-05-07 17:31:27 +0200758 if(!insn->detail) {
759 handle->errnum = CS_ERR_DETAIL;
760 return -1;
761 }
Giovanni Condelloa715df12014-05-07 17:25:38 +0200762
Nguyen Anh Quynh3eb9ac92013-11-27 15:24:47 +0800763 handle->errnum = CS_ERR_OK;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800764
765 switch (handle->arch) {
766 default:
Nguyen Anh Quynh3eb9ac92013-11-27 15:24:47 +0800767 handle->errnum = CS_ERR_HANDLE;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800768 return -1;
769 case CS_ARCH_ARM:
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800770 for (i = 0; i < insn->detail->arm.op_count; i++)
Alex Ionescu46018db2014-01-22 09:45:00 -0800771 if (insn->detail->arm.operands[i].type == (arm_op_type)op_type)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800772 count++;
773 break;
774 case CS_ARCH_ARM64:
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800775 for (i = 0; i < insn->detail->arm64.op_count; i++)
Alex Ionescu46018db2014-01-22 09:45:00 -0800776 if (insn->detail->arm64.operands[i].type == (arm64_op_type)op_type)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800777 count++;
778 break;
779 case CS_ARCH_X86:
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800780 for (i = 0; i < insn->detail->x86.op_count; i++)
Alex Ionescu46018db2014-01-22 09:45:00 -0800781 if (insn->detail->x86.operands[i].type == (x86_op_type)op_type)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800782 count++;
783 break;
784 case CS_ARCH_MIPS:
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800785 for (i = 0; i < insn->detail->mips.op_count; i++)
Alex Ionescu46018db2014-01-22 09:45:00 -0800786 if (insn->detail->mips.operands[i].type == (mips_op_type)op_type)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800787 count++;
788 break;
Nguyen Anh Quynh42c6b1a2013-12-30 00:15:25 +0800789 case CS_ARCH_PPC:
790 for (i = 0; i < insn->detail->ppc.op_count; i++)
Alex Ionescu46018db2014-01-22 09:45:00 -0800791 if (insn->detail->ppc.operands[i].type == (ppc_op_type)op_type)
Nguyen Anh Quynh42c6b1a2013-12-30 00:15:25 +0800792 count++;
793 break;
Nguyen Anh Quynh05e27132014-03-10 11:58:57 +0800794 case CS_ARCH_SPARC:
795 for (i = 0; i < insn->detail->sparc.op_count; i++)
796 if (insn->detail->sparc.operands[i].type == (sparc_op_type)op_type)
797 count++;
798 break;
Nguyen Anh Quynh48a14ca2014-03-23 08:35:45 +0800799 case CS_ARCH_SYSZ:
800 for (i = 0; i < insn->detail->sysz.op_count; i++)
801 if (insn->detail->sysz.operands[i].type == (sysz_op_type)op_type)
802 count++;
803 break;
Nguyen Anh Quynhc80d8402014-05-26 23:02:48 +0800804 case CS_ARCH_XCORE:
805 for (i = 0; i < insn->detail->xcore.op_count; i++)
806 if (insn->detail->xcore.operands[i].type == (xcore_op_type)op_type)
807 count++;
808 break;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800809 }
810
811 return count;
812}
813
Nguyen Anh Quynh07c36932014-06-03 18:33:15 +0800814CAPSTONE_EXPORT
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800815int cs_op_index(csh ud, cs_insn *insn, unsigned int op_type,
816 unsigned int post)
817{
Nguyen Anh Quynhbb0744d2014-05-12 13:41:49 +0800818 struct cs_struct *handle;
819 unsigned int count = 0, i;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800820 if (!ud)
821 return -1;
822
Axel 0vercl0k Souchet779d4c72014-05-08 23:44:49 +0100823 handle = (struct cs_struct *)(uintptr_t)ud;
Giovanni Condelloa715df12014-05-07 17:25:38 +0200824
Nguyen Anh Quynh24e12272014-01-15 21:27:23 +0800825 if (!handle->detail) {
826 handle->errnum = CS_ERR_DETAIL;
827 return -1;
828 }
829
Giovanni Condello95657e02014-05-07 17:31:27 +0200830 if(!insn->id) {
831 handle->errnum = CS_ERR_SKIPDATA;
832 return -1;
833 }
Giovanni Condelloa715df12014-05-07 17:25:38 +0200834
Giovanni Condello95657e02014-05-07 17:31:27 +0200835 if(!insn->detail) {
836 handle->errnum = CS_ERR_DETAIL;
837 return -1;
838 }
Giovanni Condelloa715df12014-05-07 17:25:38 +0200839
Nguyen Anh Quynh3eb9ac92013-11-27 15:24:47 +0800840 handle->errnum = CS_ERR_OK;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800841
842 switch (handle->arch) {
843 default:
Nguyen Anh Quynh3eb9ac92013-11-27 15:24:47 +0800844 handle->errnum = CS_ERR_HANDLE;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800845 return -1;
846 case CS_ARCH_ARM:
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800847 for (i = 0; i < insn->detail->arm.op_count; i++) {
Alex Ionescu46018db2014-01-22 09:45:00 -0800848 if (insn->detail->arm.operands[i].type == (arm_op_type)op_type)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800849 count++;
850 if (count == post)
851 return i;
852 }
853 break;
854 case CS_ARCH_ARM64:
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800855 for (i = 0; i < insn->detail->arm64.op_count; i++) {
Alex Ionescu46018db2014-01-22 09:45:00 -0800856 if (insn->detail->arm64.operands[i].type == (arm64_op_type)op_type)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800857 count++;
858 if (count == post)
859 return i;
860 }
861 break;
862 case CS_ARCH_X86:
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800863 for (i = 0; i < insn->detail->x86.op_count; i++) {
Alex Ionescu46018db2014-01-22 09:45:00 -0800864 if (insn->detail->x86.operands[i].type == (x86_op_type)op_type)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800865 count++;
866 if (count == post)
867 return i;
868 }
869 break;
870 case CS_ARCH_MIPS:
Nguyen Anh Quynh4fe224b2013-12-24 16:49:36 +0800871 for (i = 0; i < insn->detail->mips.op_count; i++) {
Alex Ionescu46018db2014-01-22 09:45:00 -0800872 if (insn->detail->mips.operands[i].type == (mips_op_type)op_type)
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800873 count++;
874 if (count == post)
875 return i;
876 }
877 break;
Nguyen Anh Quynh42c6b1a2013-12-30 00:15:25 +0800878 case CS_ARCH_PPC:
879 for (i = 0; i < insn->detail->ppc.op_count; i++) {
Alex Ionescu46018db2014-01-22 09:45:00 -0800880 if (insn->detail->ppc.operands[i].type == (ppc_op_type)op_type)
Nguyen Anh Quynh42c6b1a2013-12-30 00:15:25 +0800881 count++;
882 if (count == post)
883 return i;
884 }
885 break;
Nguyen Anh Quynh05e27132014-03-10 11:58:57 +0800886 case CS_ARCH_SPARC:
887 for (i = 0; i < insn->detail->sparc.op_count; i++) {
888 if (insn->detail->sparc.operands[i].type == (sparc_op_type)op_type)
889 count++;
890 if (count == post)
891 return i;
892 }
893 break;
Nguyen Anh Quynh48a14ca2014-03-23 08:35:45 +0800894 case CS_ARCH_SYSZ:
895 for (i = 0; i < insn->detail->sysz.op_count; i++) {
896 if (insn->detail->sysz.operands[i].type == (sysz_op_type)op_type)
897 count++;
898 if (count == post)
899 return i;
900 }
901 break;
Nguyen Anh Quynhc80d8402014-05-26 23:02:48 +0800902 case CS_ARCH_XCORE:
903 for (i = 0; i < insn->detail->xcore.op_count; i++) {
904 if (insn->detail->xcore.operands[i].type == (xcore_op_type)op_type)
905 count++;
906 if (count == post)
907 return i;
908 }
909 break;
Nguyen Anh Quynh26ee41a2013-11-27 12:11:31 +0800910 }
911
912 return -1;
913}