Line | Count | Source (jump to first uncovered line) |
1 | | /* Capstone Disassembly Engine */ |
2 | | /* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */ |
3 | | #if defined (WIN32) || defined (WIN64) || defined (_WIN32) || defined (_WIN64) |
4 | | #pragma warning(disable:4996) // disable MSVC's warning on strcpy() |
5 | | #pragma warning(disable:28719) // disable MSVC's warning on strcpy() |
6 | | #endif |
7 | | #if defined(CAPSTONE_HAS_OSXKERNEL) |
8 | | #include <Availability.h> |
9 | | #include <libkern/libkern.h> |
10 | | #else |
11 | | #include <stddef.h> |
12 | | #include <stdio.h> |
13 | | #include <stdlib.h> |
14 | | #endif |
15 | | |
16 | | #include <string.h> |
17 | | #include <capstone/capstone.h> |
18 | | |
19 | | #include "utils.h" |
20 | | #include "MCRegisterInfo.h" |
21 | | |
22 | | #if defined(_KERNEL_MODE) |
23 | | #include "windows\winkernel_mm.h" |
24 | | #endif |
25 | | |
26 | | // Issue #681: Windows kernel does not support formatting float point |
27 | | #if defined(_KERNEL_MODE) && !defined(CAPSTONE_DIET) |
28 | | #if defined(CAPSTONE_HAS_ARM) || defined(CAPSTONE_HAS_ARM64) || defined(CAPSTONE_HAS_M68K) |
29 | | #define CAPSTONE_STR_INTERNAL(x) #x |
30 | | #define CAPSTONE_STR(x) CAPSTONE_STR_INTERNAL(x) |
31 | | #define CAPSTONE_MSVC_WRANING_PREFIX __FILE__ "("CAPSTONE_STR(__LINE__)") : warning message : " |
32 | | |
33 | | #pragma message(CAPSTONE_MSVC_WRANING_PREFIX "Windows driver does not support full features for selected architecture(s). Define CAPSTONE_DIET to compile Capstone with only supported features. See issue #681 for details.") |
34 | | |
35 | | #undef CAPSTONE_MSVC_WRANING_PREFIX |
36 | | #undef CAPSTONE_STR |
37 | | #undef CAPSTONE_STR_INTERNAL |
38 | | #endif |
39 | | #endif // defined(_KERNEL_MODE) && !defined(CAPSTONE_DIET) |
40 | | |
41 | | #if !defined(CAPSTONE_HAS_OSXKERNEL) && !defined(CAPSTONE_DIET) && !defined(_KERNEL_MODE) |
42 | 27.8k | #define INSN_CACHE_SIZE 32 |
43 | | #else |
44 | | // reduce stack variable size for kernel/firmware |
45 | | #define INSN_CACHE_SIZE 8 |
46 | | #endif |
47 | | |
48 | | // default SKIPDATA mnemonic |
49 | | #ifndef CAPSTONE_DIET |
50 | 87.1k | #define SKIPDATA_MNEM ".byte" |
51 | | #else // No printing is available in diet mode |
52 | | #define SKIPDATA_MNEM NULL |
53 | | #endif |
54 | | |
55 | | #include "arch/AArch64/AArch64Module.h" |
56 | | #include "arch/ARM/ARMModule.h" |
57 | | #include "arch/EVM/EVMModule.h" |
58 | | #include "arch/WASM/WASMModule.h" |
59 | | #include "arch/M680X/M680XModule.h" |
60 | | #include "arch/M68K/M68KModule.h" |
61 | | #include "arch/Mips/MipsModule.h" |
62 | | #include "arch/PowerPC/PPCModule.h" |
63 | | #include "arch/Sparc/SparcModule.h" |
64 | | #include "arch/SystemZ/SystemZModule.h" |
65 | | #include "arch/TMS320C64x/TMS320C64xModule.h" |
66 | | #include "arch/X86/X86Module.h" |
67 | | #include "arch/XCore/XCoreModule.h" |
68 | | #include "arch/RISCV/RISCVModule.h" |
69 | | #include "arch/MOS65XX/MOS65XXModule.h" |
70 | | #include "arch/BPF/BPFModule.h" |
71 | | #include "arch/SH/SHModule.h" |
72 | | #include "arch/TriCore/TriCoreModule.h" |
73 | | |
74 | | static const struct { |
75 | | // constructor initialization |
76 | | cs_err (*arch_init)(cs_struct *); |
77 | | // support cs_option() |
78 | | cs_err (*arch_option)(cs_struct *, cs_opt_type, size_t value); |
79 | | // bitmask for finding disallowed modes for an arch: |
80 | | // to be called in cs_open()/cs_option() |
81 | | cs_mode arch_disallowed_mode_mask; |
82 | | } arch_configs[MAX_ARCH] = { |
83 | | #ifdef CAPSTONE_HAS_ARM |
84 | | { |
85 | | ARM_global_init, |
86 | | ARM_option, |
87 | | ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_ARM | CS_MODE_V8 | CS_MODE_MCLASS |
88 | | | CS_MODE_THUMB | CS_MODE_BIG_ENDIAN) |
89 | | }, |
90 | | #else |
91 | | { NULL, NULL, 0 }, |
92 | | #endif |
93 | | #ifdef CAPSTONE_HAS_ARM64 |
94 | | { |
95 | | AArch64_global_init, |
96 | | AArch64_option, |
97 | | ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_ARM | CS_MODE_BIG_ENDIAN), |
98 | | }, |
99 | | #else |
100 | | { NULL, NULL, 0 }, |
101 | | #endif |
102 | | #ifdef CAPSTONE_HAS_MIPS |
103 | | { |
104 | | Mips_global_init, |
105 | | Mips_option, |
106 | | ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_32 | CS_MODE_64 | CS_MODE_MICRO |
107 | | | CS_MODE_MIPS32R6 | CS_MODE_BIG_ENDIAN | CS_MODE_MIPS2 | CS_MODE_MIPS3), |
108 | | }, |
109 | | #else |
110 | | { NULL, NULL, 0 }, |
111 | | #endif |
112 | | #ifdef CAPSTONE_HAS_X86 |
113 | | { |
114 | | X86_global_init, |
115 | | X86_option, |
116 | | ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_32 | CS_MODE_64 | CS_MODE_16), |
117 | | }, |
118 | | #else |
119 | | { NULL, NULL, 0 }, |
120 | | #endif |
121 | | #ifdef CAPSTONE_HAS_POWERPC |
122 | | { |
123 | | PPC_global_init, |
124 | | PPC_option, |
125 | | ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_32 | CS_MODE_64 | CS_MODE_BIG_ENDIAN |
126 | | | CS_MODE_QPX | CS_MODE_PS), |
127 | | }, |
128 | | #else |
129 | | { NULL, NULL, 0 }, |
130 | | #endif |
131 | | #ifdef CAPSTONE_HAS_SPARC |
132 | | { |
133 | | Sparc_global_init, |
134 | | Sparc_option, |
135 | | ~(CS_MODE_BIG_ENDIAN | CS_MODE_V9), |
136 | | }, |
137 | | #else |
138 | | { NULL, NULL, 0 }, |
139 | | #endif |
140 | | #ifdef CAPSTONE_HAS_SYSZ |
141 | | { |
142 | | SystemZ_global_init, |
143 | | SystemZ_option, |
144 | | ~(CS_MODE_BIG_ENDIAN), |
145 | | }, |
146 | | #else |
147 | | { NULL, NULL, 0 }, |
148 | | #endif |
149 | | #ifdef CAPSTONE_HAS_XCORE |
150 | | { |
151 | | XCore_global_init, |
152 | | XCore_option, |
153 | | ~(CS_MODE_BIG_ENDIAN), |
154 | | }, |
155 | | #else |
156 | | { NULL, NULL, 0 }, |
157 | | #endif |
158 | | #ifdef CAPSTONE_HAS_M68K |
159 | | { |
160 | | M68K_global_init, |
161 | | M68K_option, |
162 | | ~(CS_MODE_BIG_ENDIAN | CS_MODE_M68K_000 | CS_MODE_M68K_010 | CS_MODE_M68K_020 |
163 | | | CS_MODE_M68K_030 | CS_MODE_M68K_040 | CS_MODE_M68K_060), |
164 | | }, |
165 | | #else |
166 | | { NULL, NULL, 0 }, |
167 | | #endif |
168 | | #ifdef CAPSTONE_HAS_TMS320C64X |
169 | | { |
170 | | TMS320C64x_global_init, |
171 | | TMS320C64x_option, |
172 | | ~(CS_MODE_BIG_ENDIAN), |
173 | | }, |
174 | | #else |
175 | | { NULL, NULL, 0 }, |
176 | | #endif |
177 | | #ifdef CAPSTONE_HAS_M680X |
178 | | { |
179 | | M680X_global_init, |
180 | | M680X_option, |
181 | | ~(CS_MODE_M680X_6301 | CS_MODE_M680X_6309 | CS_MODE_M680X_6800 |
182 | | | CS_MODE_M680X_6801 | CS_MODE_M680X_6805 | CS_MODE_M680X_6808 |
183 | | | CS_MODE_M680X_6809 | CS_MODE_M680X_6811 | CS_MODE_M680X_CPU12 |
184 | | | CS_MODE_M680X_HCS08), |
185 | | }, |
186 | | #else |
187 | | { NULL, NULL, 0 }, |
188 | | #endif |
189 | | #ifdef CAPSTONE_HAS_EVM |
190 | | { |
191 | | EVM_global_init, |
192 | | EVM_option, |
193 | | 0, |
194 | | }, |
195 | | #else |
196 | | { NULL, NULL, 0 }, |
197 | | #endif |
198 | | #ifdef CAPSTONE_HAS_MOS65XX |
199 | | { |
200 | | MOS65XX_global_init, |
201 | | MOS65XX_option, |
202 | | ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_MOS65XX_6502 | CS_MODE_MOS65XX_65C02 |
203 | | | CS_MODE_MOS65XX_W65C02 | CS_MODE_MOS65XX_65816_LONG_MX), |
204 | | }, |
205 | | #else |
206 | | { NULL, NULL, 0 }, |
207 | | #endif |
208 | | #ifdef CAPSTONE_HAS_WASM |
209 | | { |
210 | | WASM_global_init, |
211 | | WASM_option, |
212 | | 0, |
213 | | }, |
214 | | #else |
215 | | { NULL, NULL, 0 }, |
216 | | #endif |
217 | | #ifdef CAPSTONE_HAS_BPF |
218 | | { |
219 | | BPF_global_init, |
220 | | BPF_option, |
221 | | ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_BPF_CLASSIC | CS_MODE_BPF_EXTENDED |
222 | | | CS_MODE_BIG_ENDIAN), |
223 | | }, |
224 | | #else |
225 | | { NULL, NULL, 0 }, |
226 | | #endif |
227 | | #ifdef CAPSTONE_HAS_RISCV |
228 | | { |
229 | | RISCV_global_init, |
230 | | RISCV_option, |
231 | | ~(CS_MODE_RISCV32 | CS_MODE_RISCV64 | CS_MODE_RISCVC), |
232 | | }, |
233 | | #else |
234 | | { NULL, NULL, 0 }, |
235 | | #endif |
236 | | #ifdef CAPSTONE_HAS_SH |
237 | | { |
238 | | SH_global_init, |
239 | | SH_option, |
240 | | ~(CS_MODE_SH2 | CS_MODE_SH2A | CS_MODE_SH3 | |
241 | | CS_MODE_SH4 | CS_MODE_SH4A | |
242 | | CS_MODE_SHFPU | CS_MODE_SHDSP|CS_MODE_BIG_ENDIAN), |
243 | | }, |
244 | | #else |
245 | | { NULL, NULL, 0 }, |
246 | | #endif |
247 | | #ifdef CAPSTONE_HAS_TRICORE |
248 | | { |
249 | | TRICORE_global_init, |
250 | | TRICORE_option, |
251 | | ~(CS_MODE_TRICORE_110 | CS_MODE_TRICORE_120 | CS_MODE_TRICORE_130 |
252 | | | CS_MODE_TRICORE_131 | CS_MODE_TRICORE_160 | CS_MODE_TRICORE_161 |
253 | | | CS_MODE_TRICORE_162 | CS_MODE_LITTLE_ENDIAN), |
254 | | }, |
255 | | #else |
256 | | { NULL, NULL, 0 }, |
257 | | #endif |
258 | | }; |
259 | | |
260 | | // bitmask of enabled architectures |
261 | | static const uint32_t all_arch = 0 |
262 | | #ifdef CAPSTONE_HAS_ARM |
263 | | | (1 << CS_ARCH_ARM) |
264 | | #endif |
265 | | #ifdef CAPSTONE_HAS_ARM64 |
266 | | | (1 << CS_ARCH_ARM64) |
267 | | #endif |
268 | | #ifdef CAPSTONE_HAS_MIPS |
269 | | | (1 << CS_ARCH_MIPS) |
270 | | #endif |
271 | | #ifdef CAPSTONE_HAS_X86 |
272 | | | (1 << CS_ARCH_X86) |
273 | | #endif |
274 | | #ifdef CAPSTONE_HAS_POWERPC |
275 | | | (1 << CS_ARCH_PPC) |
276 | | #endif |
277 | | #ifdef CAPSTONE_HAS_SPARC |
278 | | | (1 << CS_ARCH_SPARC) |
279 | | #endif |
280 | | #ifdef CAPSTONE_HAS_SYSZ |
281 | | | (1 << CS_ARCH_SYSZ) |
282 | | #endif |
283 | | #ifdef CAPSTONE_HAS_XCORE |
284 | | | (1 << CS_ARCH_XCORE) |
285 | | #endif |
286 | | #ifdef CAPSTONE_HAS_M68K |
287 | | | (1 << CS_ARCH_M68K) |
288 | | #endif |
289 | | #ifdef CAPSTONE_HAS_TMS320C64X |
290 | | | (1 << CS_ARCH_TMS320C64X) |
291 | | #endif |
292 | | #ifdef CAPSTONE_HAS_M680X |
293 | | | (1 << CS_ARCH_M680X) |
294 | | #endif |
295 | | #ifdef CAPSTONE_HAS_EVM |
296 | | | (1 << CS_ARCH_EVM) |
297 | | #endif |
298 | | #ifdef CAPSTONE_HAS_MOS65XX |
299 | | | (1 << CS_ARCH_MOS65XX) |
300 | | #endif |
301 | | #ifdef CAPSTONE_HAS_WASM |
302 | | | (1 << CS_ARCH_WASM) |
303 | | #endif |
304 | | #ifdef CAPSTONE_HAS_BPF |
305 | | | (1 << CS_ARCH_BPF) |
306 | | #endif |
307 | | #ifdef CAPSTONE_HAS_RISCV |
308 | | | (1 << CS_ARCH_RISCV) |
309 | | #endif |
310 | | #ifdef CAPSTONE_HAS_SH |
311 | | | (1 << CS_ARCH_SH) |
312 | | #endif |
313 | | #ifdef CAPSTONE_HAS_TRICORE |
314 | | | (1 << CS_ARCH_TRICORE) |
315 | | #endif |
316 | | ; |
317 | | |
318 | | |
319 | | #if defined(CAPSTONE_USE_SYS_DYN_MEM) |
320 | | #if !defined(CAPSTONE_HAS_OSXKERNEL) && !defined(_KERNEL_MODE) |
321 | | // default |
322 | | cs_malloc_t cs_mem_malloc = malloc; |
323 | | cs_calloc_t cs_mem_calloc = calloc; |
324 | | cs_realloc_t cs_mem_realloc = realloc; |
325 | | cs_free_t cs_mem_free = free; |
326 | | #if defined(_WIN32_WCE) |
327 | | cs_vsnprintf_t cs_vsnprintf = _vsnprintf; |
328 | | #else |
329 | | cs_vsnprintf_t cs_vsnprintf = vsnprintf; |
330 | | #endif // defined(_WIN32_WCE) |
331 | | |
332 | | #elif defined(_KERNEL_MODE) |
333 | | // Windows driver |
334 | | cs_malloc_t cs_mem_malloc = cs_winkernel_malloc; |
335 | | cs_calloc_t cs_mem_calloc = cs_winkernel_calloc; |
336 | | cs_realloc_t cs_mem_realloc = cs_winkernel_realloc; |
337 | | cs_free_t cs_mem_free = cs_winkernel_free; |
338 | | cs_vsnprintf_t cs_vsnprintf = cs_winkernel_vsnprintf; |
339 | | #else |
340 | | // OSX kernel |
341 | | extern void* kern_os_malloc(size_t size); |
342 | | extern void kern_os_free(void* addr); |
343 | | extern void* kern_os_realloc(void* addr, size_t nsize); |
344 | | |
345 | | static void* cs_kern_os_calloc(size_t num, size_t size) |
346 | | { |
347 | | return kern_os_malloc(num * size); // malloc bzeroes the buffer |
348 | | } |
349 | | |
350 | | cs_malloc_t cs_mem_malloc = kern_os_malloc; |
351 | | cs_calloc_t cs_mem_calloc = cs_kern_os_calloc; |
352 | | cs_realloc_t cs_mem_realloc = kern_os_realloc; |
353 | | cs_free_t cs_mem_free = kern_os_free; |
354 | | cs_vsnprintf_t cs_vsnprintf = vsnprintf; |
355 | | #endif // !defined(CAPSTONE_HAS_OSXKERNEL) && !defined(_KERNEL_MODE) |
356 | | #else |
357 | | // User-defined |
358 | | cs_malloc_t cs_mem_malloc = NULL; |
359 | | cs_calloc_t cs_mem_calloc = NULL; |
360 | | cs_realloc_t cs_mem_realloc = NULL; |
361 | | cs_free_t cs_mem_free = NULL; |
362 | | cs_vsnprintf_t cs_vsnprintf = NULL; |
363 | | |
364 | | #endif // defined(CAPSTONE_USE_SYS_DYN_MEM) |
365 | | |
366 | | CAPSTONE_EXPORT |
367 | | unsigned int CAPSTONE_API cs_version(int *major, int *minor) |
368 | 0 | { |
369 | 0 | if (major != NULL && minor != NULL) { |
370 | 0 | *major = CS_API_MAJOR; |
371 | 0 | *minor = CS_API_MINOR; |
372 | 0 | } |
373 | |
|
374 | 0 | return (CS_API_MAJOR << 8) + CS_API_MINOR; |
375 | 0 | } |
376 | | |
377 | | CAPSTONE_EXPORT |
378 | | bool CAPSTONE_API cs_support(int query) |
379 | 0 | { |
380 | 0 | if (query == CS_ARCH_ALL) |
381 | 0 | return all_arch == ((1 << CS_ARCH_ARM) | (1 << CS_ARCH_ARM64) | |
382 | 0 | (1 << CS_ARCH_MIPS) | (1 << CS_ARCH_X86) | |
383 | 0 | (1 << CS_ARCH_PPC) | (1 << CS_ARCH_SPARC) | |
384 | 0 | (1 << CS_ARCH_SYSZ) | (1 << CS_ARCH_XCORE) | |
385 | 0 | (1 << CS_ARCH_M68K) | (1 << CS_ARCH_TMS320C64X) | |
386 | 0 | (1 << CS_ARCH_M680X) | (1 << CS_ARCH_EVM) | |
387 | 0 | (1 << CS_ARCH_RISCV) | (1 << CS_ARCH_MOS65XX) | |
388 | 0 | (1 << CS_ARCH_WASM) | (1 << CS_ARCH_BPF) | |
389 | 0 | (1 << CS_ARCH_SH) | (1 << CS_ARCH_TRICORE)); |
390 | | |
391 | 0 | if ((unsigned int)query < CS_ARCH_MAX) |
392 | 0 | return all_arch & (1 << query); |
393 | | |
394 | 0 | if (query == CS_SUPPORT_DIET) { |
395 | | #ifdef CAPSTONE_DIET |
396 | | return true; |
397 | | #else |
398 | 0 | return false; |
399 | 0 | #endif |
400 | 0 | } |
401 | | |
402 | 0 | if (query == CS_SUPPORT_X86_REDUCE) { |
403 | | #if defined(CAPSTONE_HAS_X86) && defined(CAPSTONE_X86_REDUCE) |
404 | | return true; |
405 | | #else |
406 | 0 | return false; |
407 | 0 | #endif |
408 | 0 | } |
409 | | |
410 | | // unsupported query |
411 | 0 | return false; |
412 | 0 | } |
413 | | |
414 | | CAPSTONE_EXPORT |
415 | | cs_err CAPSTONE_API cs_errno(csh handle) |
416 | 0 | { |
417 | 0 | struct cs_struct *ud; |
418 | 0 | if (!handle) |
419 | 0 | return CS_ERR_CSH; |
420 | | |
421 | 0 | ud = (struct cs_struct *)(uintptr_t)handle; |
422 | |
|
423 | 0 | return ud->errnum; |
424 | 0 | } |
425 | | |
426 | | CAPSTONE_EXPORT |
427 | | const char * CAPSTONE_API cs_strerror(cs_err code) |
428 | 0 | { |
429 | 0 | switch(code) { |
430 | 0 | default: |
431 | 0 | return "Unknown error code"; |
432 | 0 | case CS_ERR_OK: |
433 | 0 | return "OK (CS_ERR_OK)"; |
434 | 0 | case CS_ERR_MEM: |
435 | 0 | return "Out of memory (CS_ERR_MEM)"; |
436 | 0 | case CS_ERR_ARCH: |
437 | 0 | return "Invalid/unsupported architecture(CS_ERR_ARCH)"; |
438 | 0 | case CS_ERR_HANDLE: |
439 | 0 | return "Invalid handle (CS_ERR_HANDLE)"; |
440 | 0 | case CS_ERR_CSH: |
441 | 0 | return "Invalid csh (CS_ERR_CSH)"; |
442 | 0 | case CS_ERR_MODE: |
443 | 0 | return "Invalid mode (CS_ERR_MODE)"; |
444 | 0 | case CS_ERR_OPTION: |
445 | 0 | return "Invalid option (CS_ERR_OPTION)"; |
446 | 0 | case CS_ERR_DETAIL: |
447 | 0 | return "Details are unavailable (CS_ERR_DETAIL)"; |
448 | 0 | case CS_ERR_MEMSETUP: |
449 | 0 | return "Dynamic memory management uninitialized (CS_ERR_MEMSETUP)"; |
450 | 0 | case CS_ERR_VERSION: |
451 | 0 | return "Different API version between core & binding (CS_ERR_VERSION)"; |
452 | 0 | case CS_ERR_DIET: |
453 | 0 | return "Information irrelevant in diet engine (CS_ERR_DIET)"; |
454 | 0 | case CS_ERR_SKIPDATA: |
455 | 0 | return "Information irrelevant for 'data' instruction in SKIPDATA mode (CS_ERR_SKIPDATA)"; |
456 | 0 | case CS_ERR_X86_ATT: |
457 | 0 | return "AT&T syntax is unavailable (CS_ERR_X86_ATT)"; |
458 | 0 | case CS_ERR_X86_INTEL: |
459 | 0 | return "INTEL syntax is unavailable (CS_ERR_X86_INTEL)"; |
460 | 0 | case CS_ERR_X86_MASM: |
461 | 0 | return "MASM syntax is unavailable (CS_ERR_X86_MASM)"; |
462 | 0 | } |
463 | 0 | } |
464 | | |
465 | | CAPSTONE_EXPORT |
466 | | cs_err CAPSTONE_API cs_open(cs_arch arch, cs_mode mode, csh *handle) |
467 | 87.1k | { |
468 | 87.1k | cs_err err; |
469 | 87.1k | struct cs_struct *ud; |
470 | 87.1k | if (!cs_mem_malloc || !cs_mem_calloc || !cs_mem_realloc || !cs_mem_free || !cs_vsnprintf) |
471 | | // Error: before cs_open(), dynamic memory management must be initialized |
472 | | // with cs_option(CS_OPT_MEM) |
473 | 0 | return CS_ERR_MEMSETUP; |
474 | | |
475 | 87.1k | if (arch < CS_ARCH_MAX && arch_configs[arch].arch_init) { |
476 | | // verify if requested mode is valid |
477 | 87.1k | if (mode & arch_configs[arch].arch_disallowed_mode_mask) { |
478 | 7 | *handle = 0; |
479 | 7 | return CS_ERR_MODE; |
480 | 7 | } |
481 | | |
482 | 87.1k | ud = cs_mem_calloc(1, sizeof(*ud)); |
483 | 87.1k | if (!ud) { |
484 | | // memory insufficient |
485 | 0 | return CS_ERR_MEM; |
486 | 0 | } |
487 | | |
488 | 87.1k | ud->errnum = CS_ERR_OK; |
489 | 87.1k | ud->arch = arch; |
490 | 87.1k | ud->mode = mode; |
491 | | // by default, do not break instruction into details |
492 | 87.1k | ud->detail = CS_OPT_OFF; |
493 | | |
494 | | // default skipdata setup |
495 | 87.1k | ud->skipdata_setup.mnemonic = SKIPDATA_MNEM; |
496 | | |
497 | 87.1k | err = arch_configs[ud->arch].arch_init(ud); |
498 | 87.1k | if (err) { |
499 | 0 | cs_mem_free(ud); |
500 | 0 | *handle = 0; |
501 | 0 | return err; |
502 | 0 | } |
503 | | |
504 | 87.1k | *handle = (uintptr_t)ud; |
505 | | |
506 | 87.1k | return CS_ERR_OK; |
507 | 87.1k | } else { |
508 | 0 | *handle = 0; |
509 | 0 | return CS_ERR_ARCH; |
510 | 0 | } |
511 | 87.1k | } |
512 | | |
513 | | CAPSTONE_EXPORT |
514 | | cs_err CAPSTONE_API cs_close(csh *handle) |
515 | 87.1k | { |
516 | 87.1k | struct cs_struct *ud; |
517 | 87.1k | struct insn_mnem *next, *tmp; |
518 | | |
519 | 87.1k | if (*handle == 0) |
520 | | // invalid handle |
521 | 0 | return CS_ERR_CSH; |
522 | | |
523 | 87.1k | ud = (struct cs_struct *)(*handle); |
524 | | |
525 | 87.1k | if (ud->printer_info) |
526 | 82.8k | cs_mem_free(ud->printer_info); |
527 | | |
528 | | // free the linked list of customized mnemonic |
529 | 87.1k | tmp = ud->mnem_list; |
530 | 87.1k | while(tmp) { |
531 | 0 | next = tmp->next; |
532 | 0 | cs_mem_free(tmp); |
533 | 0 | tmp = next; |
534 | 0 | } |
535 | | |
536 | 87.1k | cs_mem_free(ud->insn_cache); |
537 | | |
538 | 87.1k | memset(ud, 0, sizeof(*ud)); |
539 | 87.1k | cs_mem_free(ud); |
540 | | |
541 | | // invalidate this handle by ZERO out its value. |
542 | | // this is to make sure it is unusable after cs_close() |
543 | 87.1k | *handle = 0; |
544 | | |
545 | 87.1k | return CS_ERR_OK; |
546 | 87.1k | } |
547 | | |
548 | | // replace str1 in target with str2; target starts with str1 |
549 | | // output is put into result (which is array of char with size CS_MNEMONIC_SIZE) |
550 | | // return 0 on success, -1 on failure |
551 | | static int str_replace(char *result, char *target, const char *str1, char *str2) |
552 | 0 | { |
553 | | // only perform replacement if the output fits into result |
554 | 0 | if (strlen(target) - strlen(str1) + strlen(str2) < CS_MNEMONIC_SIZE - 1) { |
555 | | // copy str2 to begining of result |
556 | 0 | strcpy(result, str2); |
557 | | // skip str1 - already replaced by str2 |
558 | 0 | strcat(result, target + strlen(str1)); |
559 | |
|
560 | 0 | return 0; |
561 | 0 | } else |
562 | 0 | return -1; |
563 | 0 | } |
564 | | |
565 | | // fill insn with mnemonic & operands info |
566 | | static void fill_insn(struct cs_struct *handle, cs_insn *insn, char *buffer, MCInst *mci, |
567 | | PostPrinter_t postprinter, const uint8_t *code) |
568 | 7.00M | { |
569 | 7.00M | #ifndef CAPSTONE_DIET |
570 | 7.00M | char *sp, *mnem; |
571 | 7.00M | #endif |
572 | 7.00M | uint16_t copy_size = MIN(sizeof(insn->bytes), insn->size); |
573 | | |
574 | | // fill the instruction bytes. |
575 | | // we might skip some redundant bytes in front in the case of X86 |
576 | 7.00M | memcpy(insn->bytes, code + insn->size - copy_size, copy_size); |
577 | 7.00M | insn->op_str[0] = '\0'; |
578 | 7.00M | insn->size = copy_size; |
579 | | |
580 | | // alias instruction might have ID saved in OpcodePub |
581 | 7.00M | if (MCInst_getOpcodePub(mci)) |
582 | 294k | insn->id = MCInst_getOpcodePub(mci); |
583 | | |
584 | | // post printer handles some corner cases (hacky) |
585 | 7.00M | if (postprinter) |
586 | 3.57M | postprinter((csh)handle, insn, buffer, mci); |
587 | | |
588 | 7.00M | #ifndef CAPSTONE_DIET |
589 | 7.00M | mnem = insn->mnemonic; |
590 | | // memset(mnem, 0, CS_MNEMONIC_SIZE); |
591 | 38.7M | for (sp = buffer; *sp; sp++) { |
592 | 38.3M | if (*sp == ' '|| *sp == '\t') |
593 | 6.62M | break; |
594 | 31.7M | if (*sp == '|') // lock|rep prefix for x86 |
595 | 164k | *sp = ' '; |
596 | | // copy to @mnemonic |
597 | 31.7M | *mnem = *sp; |
598 | 31.7M | mnem++; |
599 | 31.7M | } |
600 | | |
601 | 7.00M | *mnem = '\0'; |
602 | | |
603 | | // we might have customized mnemonic |
604 | 7.00M | if (handle->mnem_list) { |
605 | 0 | struct insn_mnem *tmp = handle->mnem_list; |
606 | 0 | while(tmp) { |
607 | 0 | if (tmp->insn.id == insn->id) { |
608 | 0 | char str[CS_MNEMONIC_SIZE]; |
609 | |
|
610 | 0 | if (!str_replace(str, insn->mnemonic, cs_insn_name((csh)handle, insn->id), tmp->insn.mnemonic)) { |
611 | | // copy result to mnemonic |
612 | 0 | (void)strncpy(insn->mnemonic, str, sizeof(insn->mnemonic) - 1); |
613 | 0 | insn->mnemonic[sizeof(insn->mnemonic) - 1] = '\0'; |
614 | 0 | } |
615 | |
|
616 | 0 | break; |
617 | 0 | } |
618 | 0 | tmp = tmp->next; |
619 | 0 | } |
620 | 0 | } |
621 | | |
622 | | // copy @op_str |
623 | 7.00M | if (*sp) { |
624 | | // find the next non-space char |
625 | 6.62M | sp++; |
626 | 6.62M | for (; ((*sp == ' ') || (*sp == '\t')); sp++); |
627 | 6.62M | strncpy(insn->op_str, sp, sizeof(insn->op_str) - 1); |
628 | 6.62M | insn->op_str[sizeof(insn->op_str) - 1] = '\0'; |
629 | 6.62M | } else |
630 | 377k | insn->op_str[0] = '\0'; |
631 | | |
632 | 7.00M | #endif |
633 | 7.00M | } |
634 | | |
635 | | // how many bytes will we skip when encountering data (CS_OPT_SKIPDATA)? |
636 | | // this very much depends on instruction alignment requirement of each arch. |
637 | | static uint8_t skipdata_size(cs_struct *handle) |
638 | 0 | { |
639 | 0 | switch(handle->arch) { |
640 | 0 | default: |
641 | | // should never reach |
642 | 0 | return (uint8_t)-1; |
643 | 0 | case CS_ARCH_ARM: |
644 | | // skip 2 bytes on Thumb mode. |
645 | 0 | if (handle->mode & CS_MODE_THUMB) |
646 | 0 | return 2; |
647 | | // otherwise, skip 4 bytes |
648 | 0 | return 4; |
649 | 0 | case CS_ARCH_ARM64: |
650 | 0 | case CS_ARCH_MIPS: |
651 | 0 | case CS_ARCH_PPC: |
652 | 0 | case CS_ARCH_SPARC: |
653 | | // skip 4 bytes |
654 | 0 | return 4; |
655 | 0 | case CS_ARCH_SYSZ: |
656 | | // SystemZ instruction's length can be 2, 4 or 6 bytes, |
657 | | // so we just skip 2 bytes |
658 | 0 | return 2; |
659 | 0 | case CS_ARCH_X86: |
660 | | // X86 has no restriction on instruction alignment |
661 | 0 | return 1; |
662 | 0 | case CS_ARCH_XCORE: |
663 | | // XCore instruction's length can be 2 or 4 bytes, |
664 | | // so we just skip 2 bytes |
665 | 0 | return 2; |
666 | 0 | case CS_ARCH_M68K: |
667 | | // M68K has 2 bytes instruction alignment but contain multibyte instruction so we skip 2 bytes |
668 | 0 | return 2; |
669 | 0 | case CS_ARCH_TMS320C64X: |
670 | | // TMS320C64x alignment is 4. |
671 | 0 | return 4; |
672 | 0 | case CS_ARCH_M680X: |
673 | | // M680X alignment is 1. |
674 | 0 | return 1; |
675 | 0 | case CS_ARCH_EVM: |
676 | | // EVM alignment is 1. |
677 | 0 | return 1; |
678 | 0 | case CS_ARCH_WASM: |
679 | | //WASM alignment is 1 |
680 | 0 | return 1; |
681 | 0 | case CS_ARCH_MOS65XX: |
682 | | // MOS65XX alignment is 1. |
683 | 0 | return 1; |
684 | 0 | case CS_ARCH_BPF: |
685 | | // both classic and extended BPF have alignment 8. |
686 | 0 | return 8; |
687 | 0 | case CS_ARCH_RISCV: |
688 | | // special compress mode |
689 | 0 | if (handle->mode & CS_MODE_RISCVC) |
690 | 0 | return 2; |
691 | 0 | return 4; |
692 | 0 | case CS_ARCH_SH: |
693 | 0 | return 2; |
694 | 0 | case CS_ARCH_TRICORE: |
695 | | // TriCore instruction's length can be 2 or 4 bytes, |
696 | | // so we just skip 2 bytes |
697 | 0 | return 2; |
698 | 0 | } |
699 | 0 | } |
700 | | |
701 | | CAPSTONE_EXPORT |
702 | | cs_err CAPSTONE_API cs_option(csh ud, cs_opt_type type, size_t value) |
703 | 35.7k | { |
704 | 35.7k | struct cs_struct *handle; |
705 | 35.7k | cs_opt_mnem *opt; |
706 | | |
707 | | // cs_option() can be called with NULL handle just for CS_OPT_MEM |
708 | | // This is supposed to be executed before all other APIs (even cs_open()) |
709 | 35.7k | if (type == CS_OPT_MEM) { |
710 | 0 | cs_opt_mem *mem = (cs_opt_mem *)value; |
711 | |
|
712 | 0 | cs_mem_malloc = mem->malloc; |
713 | 0 | cs_mem_calloc = mem->calloc; |
714 | 0 | cs_mem_realloc = mem->realloc; |
715 | 0 | cs_mem_free = mem->free; |
716 | 0 | cs_vsnprintf = mem->vsnprintf; |
717 | |
|
718 | 0 | return CS_ERR_OK; |
719 | 0 | } |
720 | | |
721 | 35.7k | handle = (struct cs_struct *)(uintptr_t)ud; |
722 | 35.7k | if (!handle) |
723 | 0 | return CS_ERR_CSH; |
724 | | |
725 | 35.7k | switch(type) { |
726 | 7.91k | default: |
727 | 7.91k | break; |
728 | | |
729 | 7.91k | case CS_OPT_UNSIGNED: |
730 | 0 | handle->imm_unsigned = (cs_opt_value)value; |
731 | 0 | return CS_ERR_OK; |
732 | | |
733 | 27.8k | case CS_OPT_DETAIL: |
734 | 27.8k | handle->detail = (cs_opt_value)value; |
735 | 27.8k | return CS_ERR_OK; |
736 | | |
737 | 0 | case CS_OPT_SKIPDATA: |
738 | 0 | handle->skipdata = (value == CS_OPT_ON); |
739 | 0 | if (handle->skipdata) { |
740 | 0 | if (handle->skipdata_size == 0) { |
741 | | // set the default skipdata size |
742 | 0 | handle->skipdata_size = skipdata_size(handle); |
743 | 0 | } |
744 | 0 | } |
745 | 0 | return CS_ERR_OK; |
746 | | |
747 | 0 | case CS_OPT_SKIPDATA_SETUP: |
748 | 0 | if (value) { |
749 | 0 | handle->skipdata_setup = *((cs_opt_skipdata *)value); |
750 | 0 | if (handle->skipdata_setup.mnemonic == NULL) { |
751 | 0 | handle->skipdata_setup.mnemonic = SKIPDATA_MNEM; |
752 | 0 | } |
753 | 0 | } |
754 | 0 | return CS_ERR_OK; |
755 | | |
756 | 0 | case CS_OPT_MNEMONIC: |
757 | 0 | opt = (cs_opt_mnem *)value; |
758 | 0 | if (opt->id) { |
759 | 0 | if (opt->mnemonic) { |
760 | 0 | struct insn_mnem *tmp; |
761 | | |
762 | | // add new instruction, or replace existing instruction |
763 | | // 1. find if we already had this insn in the linked list |
764 | 0 | tmp = handle->mnem_list; |
765 | 0 | while(tmp) { |
766 | 0 | if (tmp->insn.id == opt->id) { |
767 | | // found this instruction, so replace its mnemonic |
768 | 0 | (void)strncpy(tmp->insn.mnemonic, opt->mnemonic, sizeof(tmp->insn.mnemonic) - 1); |
769 | 0 | tmp->insn.mnemonic[sizeof(tmp->insn.mnemonic) - 1] = '\0'; |
770 | 0 | break; |
771 | 0 | } |
772 | 0 | tmp = tmp->next; |
773 | 0 | } |
774 | | |
775 | | // 2. add this instruction if we have not had it yet |
776 | 0 | if (!tmp) { |
777 | 0 | tmp = cs_mem_malloc(sizeof(*tmp)); |
778 | 0 | tmp->insn.id = opt->id; |
779 | 0 | (void)strncpy(tmp->insn.mnemonic, opt->mnemonic, sizeof(tmp->insn.mnemonic) - 1); |
780 | 0 | tmp->insn.mnemonic[sizeof(tmp->insn.mnemonic) - 1] = '\0'; |
781 | | // this new instruction is heading the list |
782 | 0 | tmp->next = handle->mnem_list; |
783 | 0 | handle->mnem_list = tmp; |
784 | 0 | } |
785 | 0 | return CS_ERR_OK; |
786 | 0 | } else { |
787 | 0 | struct insn_mnem *prev, *tmp; |
788 | | |
789 | | // we want to delete an existing instruction |
790 | | // iterate the list to find the instruction to remove it |
791 | 0 | tmp = handle->mnem_list; |
792 | 0 | prev = tmp; |
793 | 0 | while(tmp) { |
794 | 0 | if (tmp->insn.id == opt->id) { |
795 | | // delete this instruction |
796 | 0 | if (tmp == prev) { |
797 | | // head of the list |
798 | 0 | handle->mnem_list = tmp->next; |
799 | 0 | } else { |
800 | 0 | prev->next = tmp->next; |
801 | 0 | } |
802 | 0 | cs_mem_free(tmp); |
803 | 0 | break; |
804 | 0 | } |
805 | 0 | prev = tmp; |
806 | 0 | tmp = tmp->next; |
807 | 0 | } |
808 | 0 | } |
809 | 0 | } |
810 | 0 | return CS_ERR_OK; |
811 | | |
812 | 0 | case CS_OPT_MODE: |
813 | | // verify if requested mode is valid |
814 | 0 | if (value & arch_configs[handle->arch].arch_disallowed_mode_mask) { |
815 | 0 | return CS_ERR_OPTION; |
816 | 0 | } |
817 | 0 | break; |
818 | 35.7k | } |
819 | | |
820 | 7.91k | return arch_configs[handle->arch].arch_option(handle, type, value); |
821 | 35.7k | } |
822 | | |
823 | | // generate @op_str for data instruction of SKIPDATA |
824 | | #ifndef CAPSTONE_DIET |
825 | | static void skipdata_opstr(char *opstr, const uint8_t *buffer, size_t size) |
826 | 0 | { |
827 | 0 | char *p = opstr; |
828 | 0 | int len; |
829 | 0 | size_t i; |
830 | 0 | size_t available = sizeof(((cs_insn*)NULL)->op_str); |
831 | |
|
832 | 0 | if (!size) { |
833 | 0 | opstr[0] = '\0'; |
834 | 0 | return; |
835 | 0 | } |
836 | | |
837 | 0 | len = cs_snprintf(p, available, "0x%02x", buffer[0]); |
838 | 0 | p+= len; |
839 | 0 | available -= len; |
840 | |
|
841 | 0 | for(i = 1; i < size; i++) { |
842 | 0 | len = cs_snprintf(p, available, ", 0x%02x", buffer[i]); |
843 | 0 | if (len < 0) { |
844 | 0 | break; |
845 | 0 | } |
846 | 0 | if ((size_t)len > available - 1) { |
847 | 0 | break; |
848 | 0 | } |
849 | 0 | p+= len; |
850 | 0 | available -= len; |
851 | 0 | } |
852 | 0 | } |
853 | | #endif |
854 | | |
855 | | // dynamicly allocate memory to contain disasm insn |
856 | | // NOTE: caller must free() the allocated memory itself to avoid memory leaking |
857 | | CAPSTONE_EXPORT |
858 | | size_t CAPSTONE_API cs_disasm(csh ud, const uint8_t *buffer, size_t size, uint64_t offset, size_t count, cs_insn **insn) |
859 | 27.8k | { |
860 | 27.8k | struct cs_struct *handle; |
861 | 27.8k | MCInst mci; |
862 | 27.8k | uint16_t insn_size; |
863 | 27.8k | size_t c = 0, i; |
864 | 27.8k | unsigned int f = 0; // index of the next instruction in the cache |
865 | 27.8k | cs_insn *insn_cache; // cache contains disassembled instructions |
866 | 27.8k | void *total = NULL; |
867 | 27.8k | size_t total_size = 0; // total size of output buffer containing all insns |
868 | 27.8k | bool r; |
869 | 27.8k | void *tmp; |
870 | 27.8k | size_t skipdata_bytes; |
871 | 27.8k | uint64_t offset_org; // save all the original info of the buffer |
872 | 27.8k | size_t size_org; |
873 | 27.8k | const uint8_t *buffer_org; |
874 | 27.8k | unsigned int cache_size = INSN_CACHE_SIZE; |
875 | 27.8k | size_t next_offset; |
876 | | |
877 | 27.8k | handle = (struct cs_struct *)(uintptr_t)ud; |
878 | 27.8k | if (!handle) { |
879 | | // FIXME: how to handle this case: |
880 | | // handle->errnum = CS_ERR_HANDLE; |
881 | 0 | return 0; |
882 | 0 | } |
883 | | |
884 | 27.8k | handle->errnum = CS_ERR_OK; |
885 | | |
886 | | // reset IT block of ARM structure |
887 | 27.8k | if (handle->arch == CS_ARCH_ARM) |
888 | 5.75k | handle->ITBlock.size = 0; |
889 | | |
890 | 27.8k | #ifdef CAPSTONE_USE_SYS_DYN_MEM |
891 | 27.8k | if (count > 0 && count <= INSN_CACHE_SIZE) |
892 | 0 | cache_size = (unsigned int) count; |
893 | 27.8k | #endif |
894 | | |
895 | | // save the original offset for SKIPDATA |
896 | 27.8k | buffer_org = buffer; |
897 | 27.8k | offset_org = offset; |
898 | 27.8k | size_org = size; |
899 | | |
900 | 27.8k | total_size = sizeof(cs_insn) * cache_size; |
901 | 27.8k | total = cs_mem_calloc(sizeof(cs_insn), cache_size); |
902 | 27.8k | if (total == NULL) { |
903 | | // insufficient memory |
904 | 0 | handle->errnum = CS_ERR_MEM; |
905 | 0 | return 0; |
906 | 0 | } |
907 | | |
908 | 27.8k | insn_cache = total; |
909 | | |
910 | 3.12M | while (size > 0) { |
911 | 3.11M | MCInst_Init(&mci); |
912 | 3.11M | mci.csh = handle; |
913 | | |
914 | | // relative branches need to know the address & size of current insn |
915 | 3.11M | mci.address = offset; |
916 | | |
917 | 3.11M | if (handle->detail) { |
918 | | // allocate memory for @detail pointer |
919 | 3.11M | insn_cache->detail = cs_mem_malloc(sizeof(cs_detail)); |
920 | 3.11M | } else { |
921 | 0 | insn_cache->detail = NULL; |
922 | 0 | } |
923 | | |
924 | | // save all the information for non-detailed mode |
925 | 3.11M | mci.flat_insn = insn_cache; |
926 | 3.11M | mci.flat_insn->address = offset; |
927 | | #ifdef CAPSTONE_DIET |
928 | | // zero out mnemonic & op_str |
929 | | mci.flat_insn->mnemonic[0] = '\0'; |
930 | | mci.flat_insn->op_str[0] = '\0'; |
931 | | #endif |
932 | | |
933 | 3.11M | r = handle->disasm(ud, buffer, size, &mci, &insn_size, offset, handle->getinsn_info); |
934 | 3.11M | if (r) { |
935 | 3.09M | SStream ss; |
936 | 3.09M | SStream_Init(&ss); |
937 | | |
938 | 3.09M | mci.flat_insn->size = insn_size; |
939 | | |
940 | | // map internal instruction opcode to public insn ID |
941 | | |
942 | 3.09M | handle->insn_id(handle, insn_cache, mci.Opcode); |
943 | | |
944 | 3.09M | handle->printer(&mci, &ss, handle->printer_info); |
945 | 3.09M | fill_insn(handle, insn_cache, ss.buffer, &mci, handle->post_printer, buffer); |
946 | | |
947 | | // adjust for pseudo opcode (X86) |
948 | 3.09M | if (handle->arch == CS_ARCH_X86 && insn_cache->id != X86_INS_VCMP) |
949 | 1.00M | insn_cache->id += mci.popcode_adjust; |
950 | | |
951 | 3.09M | next_offset = insn_size; |
952 | 3.09M | } else { |
953 | | // encounter a broken instruction |
954 | | |
955 | | // free memory of @detail pointer |
956 | 19.0k | if (handle->detail) { |
957 | 19.0k | cs_mem_free(insn_cache->detail); |
958 | 19.0k | } |
959 | | |
960 | | // if there is no request to skip data, or remaining data is too small, |
961 | | // then bail out |
962 | 19.0k | if (!handle->skipdata || handle->skipdata_size > size) |
963 | 19.0k | break; |
964 | | |
965 | 0 | if (handle->skipdata_setup.callback) { |
966 | 0 | skipdata_bytes = handle->skipdata_setup.callback(buffer_org, size_org, |
967 | 0 | (size_t)(offset - offset_org), handle->skipdata_setup.user_data); |
968 | 0 | if (skipdata_bytes > size) |
969 | | // remaining data is not enough |
970 | 0 | break; |
971 | | |
972 | 0 | if (!skipdata_bytes) |
973 | | // user requested not to skip data, so bail out |
974 | 0 | break; |
975 | 0 | } else |
976 | 0 | skipdata_bytes = handle->skipdata_size; |
977 | | |
978 | | // we have to skip some amount of data, depending on arch & mode |
979 | 0 | insn_cache->id = 0; // invalid ID for this "data" instruction |
980 | 0 | insn_cache->address = offset; |
981 | 0 | insn_cache->size = (uint16_t)skipdata_bytes; |
982 | 0 | memcpy(insn_cache->bytes, buffer, skipdata_bytes); |
983 | | #ifdef CAPSTONE_DIET |
984 | | insn_cache->mnemonic[0] = '\0'; |
985 | | insn_cache->op_str[0] = '\0'; |
986 | | #else |
987 | 0 | strncpy(insn_cache->mnemonic, handle->skipdata_setup.mnemonic, |
988 | 0 | sizeof(insn_cache->mnemonic) - 1); |
989 | 0 | skipdata_opstr(insn_cache->op_str, buffer, skipdata_bytes); |
990 | 0 | #endif |
991 | 0 | insn_cache->detail = NULL; |
992 | |
|
993 | 0 | next_offset = skipdata_bytes; |
994 | 0 | } |
995 | | |
996 | | // one more instruction entering the cache |
997 | 3.09M | f++; |
998 | | |
999 | | // one more instruction disassembled |
1000 | 3.09M | c++; |
1001 | 3.09M | if (count > 0 && c == count) |
1002 | | // already got requested number of instructions |
1003 | 0 | break; |
1004 | | |
1005 | 3.09M | if (f == cache_size) { |
1006 | | // full cache, so expand the cache to contain incoming insns |
1007 | 28.1k | cache_size = cache_size * 8 / 5; // * 1.6 ~ golden ratio |
1008 | 28.1k | total_size += (sizeof(cs_insn) * cache_size); |
1009 | 28.1k | tmp = cs_mem_realloc(total, total_size); |
1010 | 28.1k | if (tmp == NULL) { // insufficient memory |
1011 | 0 | if (handle->detail) { |
1012 | 0 | insn_cache = (cs_insn *)total; |
1013 | 0 | for (i = 0; i < c; i++, insn_cache++) |
1014 | 0 | cs_mem_free(insn_cache->detail); |
1015 | 0 | } |
1016 | |
|
1017 | 0 | cs_mem_free(total); |
1018 | 0 | *insn = NULL; |
1019 | 0 | handle->errnum = CS_ERR_MEM; |
1020 | 0 | return 0; |
1021 | 0 | } |
1022 | | |
1023 | 28.1k | total = tmp; |
1024 | | // continue to fill in the cache after the last instruction |
1025 | 28.1k | insn_cache = (cs_insn *)((char *)total + sizeof(cs_insn) * c); |
1026 | | |
1027 | | // reset f back to 0, so we fill in the cache from begining |
1028 | 28.1k | f = 0; |
1029 | 28.1k | } else |
1030 | 3.07M | insn_cache++; |
1031 | | |
1032 | 3.09M | buffer += next_offset; |
1033 | 3.09M | size -= next_offset; |
1034 | 3.09M | offset += next_offset; |
1035 | 3.09M | } |
1036 | | |
1037 | 27.8k | if (!c) { |
1038 | | // we did not disassemble any instruction |
1039 | 228 | cs_mem_free(total); |
1040 | 228 | total = NULL; |
1041 | 27.6k | } else if (f != cache_size) { |
1042 | | // total did not fully use the last cache, so downsize it |
1043 | 27.6k | tmp = cs_mem_realloc(total, total_size - (cache_size - f) * sizeof(*insn_cache)); |
1044 | 27.6k | if (tmp == NULL) { // insufficient memory |
1045 | | // free all detail pointers |
1046 | 0 | if (handle->detail) { |
1047 | 0 | insn_cache = (cs_insn *)total; |
1048 | 0 | for (i = 0; i < c; i++, insn_cache++) |
1049 | 0 | cs_mem_free(insn_cache->detail); |
1050 | 0 | } |
1051 | |
|
1052 | 0 | cs_mem_free(total); |
1053 | 0 | *insn = NULL; |
1054 | |
|
1055 | 0 | handle->errnum = CS_ERR_MEM; |
1056 | 0 | return 0; |
1057 | 0 | } |
1058 | | |
1059 | 27.6k | total = tmp; |
1060 | 27.6k | } |
1061 | | |
1062 | 27.8k | *insn = total; |
1063 | | |
1064 | 27.8k | return c; |
1065 | 27.8k | } |
1066 | | |
1067 | | CAPSTONE_EXPORT |
1068 | | void CAPSTONE_API cs_free(cs_insn *insn, size_t count) |
1069 | 85.6k | { |
1070 | 85.6k | size_t i; |
1071 | | |
1072 | | // free all detail pointers |
1073 | 7.08M | for (i = 0; i < count; i++) |
1074 | 7.00M | cs_mem_free(insn[i].detail); |
1075 | | |
1076 | | // then free pointer to cs_insn array |
1077 | 85.6k | cs_mem_free(insn); |
1078 | 85.6k | } |
1079 | | |
1080 | | CAPSTONE_EXPORT |
1081 | | cs_insn * CAPSTONE_API cs_malloc(csh ud) |
1082 | 0 | { |
1083 | 0 | cs_insn *insn; |
1084 | 0 | struct cs_struct *handle = (struct cs_struct *)(uintptr_t)ud; |
1085 | |
|
1086 | 0 | insn = cs_mem_malloc(sizeof(cs_insn)); |
1087 | 0 | if (!insn) { |
1088 | | // insufficient memory |
1089 | 0 | handle->errnum = CS_ERR_MEM; |
1090 | 0 | return NULL; |
1091 | 0 | } else { |
1092 | 0 | if (handle->detail) { |
1093 | | // allocate memory for @detail pointer |
1094 | 0 | insn->detail = cs_mem_malloc(sizeof(cs_detail)); |
1095 | 0 | if (insn->detail == NULL) { // insufficient memory |
1096 | 0 | cs_mem_free(insn); |
1097 | 0 | handle->errnum = CS_ERR_MEM; |
1098 | 0 | return NULL; |
1099 | 0 | } |
1100 | 0 | } else |
1101 | 0 | insn->detail = NULL; |
1102 | 0 | } |
1103 | | |
1104 | 0 | return insn; |
1105 | 0 | } |
1106 | | |
1107 | | // iterator for instruction "single-stepping" |
1108 | | CAPSTONE_EXPORT |
1109 | | bool CAPSTONE_API cs_disasm_iter(csh ud, const uint8_t **code, size_t *size, |
1110 | | uint64_t *address, cs_insn *insn) |
1111 | 0 | { |
1112 | 0 | struct cs_struct *handle; |
1113 | 0 | uint16_t insn_size; |
1114 | 0 | MCInst mci; |
1115 | 0 | bool r; |
1116 | |
|
1117 | 0 | handle = (struct cs_struct *)(uintptr_t)ud; |
1118 | 0 | if (!handle) { |
1119 | 0 | return false; |
1120 | 0 | } |
1121 | | |
1122 | 0 | handle->errnum = CS_ERR_OK; |
1123 | |
|
1124 | 0 | MCInst_Init(&mci); |
1125 | 0 | mci.csh = handle; |
1126 | | |
1127 | | // relative branches need to know the address & size of current insn |
1128 | 0 | mci.address = *address; |
1129 | | |
1130 | | // save all the information for non-detailed mode |
1131 | 0 | mci.flat_insn = insn; |
1132 | 0 | mci.flat_insn->address = *address; |
1133 | | #ifdef CAPSTONE_DIET |
1134 | | // zero out mnemonic & op_str |
1135 | | mci.flat_insn->mnemonic[0] = '\0'; |
1136 | | mci.flat_insn->op_str[0] = '\0'; |
1137 | | #endif |
1138 | |
|
1139 | 0 | r = handle->disasm(ud, *code, *size, &mci, &insn_size, *address, handle->getinsn_info); |
1140 | 0 | if (r) { |
1141 | 0 | SStream ss; |
1142 | 0 | SStream_Init(&ss); |
1143 | |
|
1144 | 0 | mci.flat_insn->size = insn_size; |
1145 | | |
1146 | | // map internal instruction opcode to public insn ID |
1147 | 0 | handle->insn_id(handle, insn, mci.Opcode); |
1148 | |
|
1149 | 0 | handle->printer(&mci, &ss, handle->printer_info); |
1150 | |
|
1151 | 0 | fill_insn(handle, insn, ss.buffer, &mci, handle->post_printer, *code); |
1152 | | |
1153 | | // adjust for pseudo opcode (X86) |
1154 | 0 | if (handle->arch == CS_ARCH_X86) |
1155 | 0 | insn->id += mci.popcode_adjust; |
1156 | |
|
1157 | 0 | *code += insn_size; |
1158 | 0 | *size -= insn_size; |
1159 | 0 | *address += insn_size; |
1160 | 0 | } else { // encounter a broken instruction |
1161 | 0 | size_t skipdata_bytes; |
1162 | | |
1163 | | // if there is no request to skip data, or remaining data is too small, |
1164 | | // then bail out |
1165 | 0 | if (!handle->skipdata || handle->skipdata_size > *size) |
1166 | 0 | return false; |
1167 | | |
1168 | 0 | if (handle->skipdata_setup.callback) { |
1169 | 0 | skipdata_bytes = handle->skipdata_setup.callback(*code, *size, |
1170 | 0 | 0, handle->skipdata_setup.user_data); |
1171 | 0 | if (skipdata_bytes > *size) |
1172 | | // remaining data is not enough |
1173 | 0 | return false; |
1174 | | |
1175 | 0 | if (!skipdata_bytes) |
1176 | | // user requested not to skip data, so bail out |
1177 | 0 | return false; |
1178 | 0 | } else |
1179 | 0 | skipdata_bytes = handle->skipdata_size; |
1180 | | |
1181 | | // we have to skip some amount of data, depending on arch & mode |
1182 | 0 | insn->id = 0; // invalid ID for this "data" instruction |
1183 | 0 | insn->address = *address; |
1184 | 0 | insn->size = (uint16_t)skipdata_bytes; |
1185 | | #ifdef CAPSTONE_DIET |
1186 | | insn->mnemonic[0] = '\0'; |
1187 | | insn->op_str[0] = '\0'; |
1188 | | #else |
1189 | 0 | memcpy(insn->bytes, *code, skipdata_bytes); |
1190 | 0 | strncpy(insn->mnemonic, handle->skipdata_setup.mnemonic, |
1191 | 0 | sizeof(insn->mnemonic) - 1); |
1192 | 0 | skipdata_opstr(insn->op_str, *code, skipdata_bytes); |
1193 | 0 | #endif |
1194 | |
|
1195 | 0 | *code += skipdata_bytes; |
1196 | 0 | *size -= skipdata_bytes; |
1197 | 0 | *address += skipdata_bytes; |
1198 | 0 | } |
1199 | | |
1200 | 0 | return true; |
1201 | 0 | } |
1202 | | |
1203 | | // return friendly name of register in a string |
1204 | | CAPSTONE_EXPORT |
1205 | | const char * CAPSTONE_API cs_reg_name(csh ud, unsigned int reg) |
1206 | 6.30M | { |
1207 | 6.30M | struct cs_struct *handle = (struct cs_struct *)(uintptr_t)ud; |
1208 | | |
1209 | 6.30M | if (!handle || handle->reg_name == NULL) { |
1210 | 0 | return NULL; |
1211 | 0 | } |
1212 | | |
1213 | 6.30M | return handle->reg_name(ud, reg); |
1214 | 6.30M | } |
1215 | | |
1216 | | CAPSTONE_EXPORT |
1217 | | const char * CAPSTONE_API cs_insn_name(csh ud, unsigned int insn) |
1218 | 7.00M | { |
1219 | 7.00M | struct cs_struct *handle = (struct cs_struct *)(uintptr_t)ud; |
1220 | | |
1221 | 7.00M | if (!handle || handle->insn_name == NULL) { |
1222 | 0 | return NULL; |
1223 | 0 | } |
1224 | | |
1225 | 7.00M | return handle->insn_name(ud, insn); |
1226 | 7.00M | } |
1227 | | |
1228 | | CAPSTONE_EXPORT |
1229 | | const char * CAPSTONE_API cs_group_name(csh ud, unsigned int group) |
1230 | 5.85M | { |
1231 | 5.85M | struct cs_struct *handle = (struct cs_struct *)(uintptr_t)ud; |
1232 | | |
1233 | 5.85M | if (!handle || handle->group_name == NULL) { |
1234 | 0 | return NULL; |
1235 | 0 | } |
1236 | | |
1237 | 5.85M | return handle->group_name(ud, group); |
1238 | 5.85M | } |
1239 | | |
1240 | | CAPSTONE_EXPORT |
1241 | | bool CAPSTONE_API cs_insn_group(csh ud, const cs_insn *insn, unsigned int group_id) |
1242 | 0 | { |
1243 | 0 | struct cs_struct *handle; |
1244 | 0 | if (!ud) |
1245 | 0 | return false; |
1246 | | |
1247 | 0 | handle = (struct cs_struct *)(uintptr_t)ud; |
1248 | |
|
1249 | 0 | if (!handle->detail) { |
1250 | 0 | handle->errnum = CS_ERR_DETAIL; |
1251 | 0 | return false; |
1252 | 0 | } |
1253 | | |
1254 | 0 | if (!insn->id) { |
1255 | 0 | handle->errnum = CS_ERR_SKIPDATA; |
1256 | 0 | return false; |
1257 | 0 | } |
1258 | | |
1259 | 0 | if (!insn->detail) { |
1260 | 0 | handle->errnum = CS_ERR_DETAIL; |
1261 | 0 | return false; |
1262 | 0 | } |
1263 | | |
1264 | 0 | return arr_exist8(insn->detail->groups, insn->detail->groups_count, group_id); |
1265 | 0 | } |
1266 | | |
1267 | | CAPSTONE_EXPORT |
1268 | | bool CAPSTONE_API cs_reg_read(csh ud, const cs_insn *insn, unsigned int reg_id) |
1269 | 0 | { |
1270 | 0 | struct cs_struct *handle; |
1271 | 0 | if (!ud) |
1272 | 0 | return false; |
1273 | | |
1274 | 0 | handle = (struct cs_struct *)(uintptr_t)ud; |
1275 | |
|
1276 | 0 | if (!handle->detail) { |
1277 | 0 | handle->errnum = CS_ERR_DETAIL; |
1278 | 0 | return false; |
1279 | 0 | } |
1280 | | |
1281 | 0 | if (!insn->id) { |
1282 | 0 | handle->errnum = CS_ERR_SKIPDATA; |
1283 | 0 | return false; |
1284 | 0 | } |
1285 | | |
1286 | 0 | if (!insn->detail) { |
1287 | 0 | handle->errnum = CS_ERR_DETAIL; |
1288 | 0 | return false; |
1289 | 0 | } |
1290 | | |
1291 | 0 | return arr_exist(insn->detail->regs_read, insn->detail->regs_read_count, reg_id); |
1292 | 0 | } |
1293 | | |
1294 | | CAPSTONE_EXPORT |
1295 | | bool CAPSTONE_API cs_reg_write(csh ud, const cs_insn *insn, unsigned int reg_id) |
1296 | 1.13M | { |
1297 | 1.13M | struct cs_struct *handle; |
1298 | 1.13M | if (!ud) |
1299 | 0 | return false; |
1300 | | |
1301 | 1.13M | handle = (struct cs_struct *)(uintptr_t)ud; |
1302 | | |
1303 | 1.13M | if (!handle->detail) { |
1304 | 0 | handle->errnum = CS_ERR_DETAIL; |
1305 | 0 | return false; |
1306 | 0 | } |
1307 | | |
1308 | 1.13M | if (!insn->id) { |
1309 | 0 | handle->errnum = CS_ERR_SKIPDATA; |
1310 | 0 | return false; |
1311 | 0 | } |
1312 | | |
1313 | 1.13M | if (!insn->detail) { |
1314 | 0 | handle->errnum = CS_ERR_DETAIL; |
1315 | 0 | return false; |
1316 | 0 | } |
1317 | | |
1318 | 1.13M | return arr_exist(insn->detail->regs_write, insn->detail->regs_write_count, reg_id); |
1319 | 1.13M | } |
1320 | | |
1321 | | CAPSTONE_EXPORT |
1322 | | int CAPSTONE_API cs_op_count(csh ud, const cs_insn *insn, unsigned int op_type) |
1323 | 0 | { |
1324 | 0 | struct cs_struct *handle; |
1325 | 0 | unsigned int count = 0, i; |
1326 | 0 | if (!ud) |
1327 | 0 | return -1; |
1328 | | |
1329 | 0 | handle = (struct cs_struct *)(uintptr_t)ud; |
1330 | |
|
1331 | 0 | if (!handle->detail) { |
1332 | 0 | handle->errnum = CS_ERR_DETAIL; |
1333 | 0 | return -1; |
1334 | 0 | } |
1335 | | |
1336 | 0 | if (!insn->id) { |
1337 | 0 | handle->errnum = CS_ERR_SKIPDATA; |
1338 | 0 | return -1; |
1339 | 0 | } |
1340 | | |
1341 | 0 | if (!insn->detail) { |
1342 | 0 | handle->errnum = CS_ERR_DETAIL; |
1343 | 0 | return -1; |
1344 | 0 | } |
1345 | | |
1346 | 0 | handle->errnum = CS_ERR_OK; |
1347 | |
|
1348 | 0 | switch (handle->arch) { |
1349 | 0 | default: |
1350 | 0 | handle->errnum = CS_ERR_HANDLE; |
1351 | 0 | return -1; |
1352 | 0 | case CS_ARCH_ARM: |
1353 | 0 | for (i = 0; i < insn->detail->arm.op_count; i++) |
1354 | 0 | if (insn->detail->arm.operands[i].type == (arm_op_type)op_type) |
1355 | 0 | count++; |
1356 | 0 | break; |
1357 | 0 | case CS_ARCH_ARM64: |
1358 | 0 | for (i = 0; i < insn->detail->arm64.op_count; i++) |
1359 | 0 | if (insn->detail->arm64.operands[i].type == (arm64_op_type)op_type) |
1360 | 0 | count++; |
1361 | 0 | break; |
1362 | 0 | case CS_ARCH_X86: |
1363 | 0 | for (i = 0; i < insn->detail->x86.op_count; i++) |
1364 | 0 | if (insn->detail->x86.operands[i].type == (x86_op_type)op_type) |
1365 | 0 | count++; |
1366 | 0 | break; |
1367 | 0 | case CS_ARCH_MIPS: |
1368 | 0 | for (i = 0; i < insn->detail->mips.op_count; i++) |
1369 | 0 | if (insn->detail->mips.operands[i].type == (mips_op_type)op_type) |
1370 | 0 | count++; |
1371 | 0 | break; |
1372 | 0 | case CS_ARCH_PPC: |
1373 | 0 | for (i = 0; i < insn->detail->ppc.op_count; i++) |
1374 | 0 | if (insn->detail->ppc.operands[i].type == (ppc_op_type)op_type) |
1375 | 0 | count++; |
1376 | 0 | break; |
1377 | 0 | case CS_ARCH_SPARC: |
1378 | 0 | for (i = 0; i < insn->detail->sparc.op_count; i++) |
1379 | 0 | if (insn->detail->sparc.operands[i].type == (sparc_op_type)op_type) |
1380 | 0 | count++; |
1381 | 0 | break; |
1382 | 0 | case CS_ARCH_SYSZ: |
1383 | 0 | for (i = 0; i < insn->detail->sysz.op_count; i++) |
1384 | 0 | if (insn->detail->sysz.operands[i].type == (sysz_op_type)op_type) |
1385 | 0 | count++; |
1386 | 0 | break; |
1387 | 0 | case CS_ARCH_XCORE: |
1388 | 0 | for (i = 0; i < insn->detail->xcore.op_count; i++) |
1389 | 0 | if (insn->detail->xcore.operands[i].type == (xcore_op_type)op_type) |
1390 | 0 | count++; |
1391 | 0 | break; |
1392 | 0 | case CS_ARCH_M68K: |
1393 | 0 | for (i = 0; i < insn->detail->m68k.op_count; i++) |
1394 | 0 | if (insn->detail->m68k.operands[i].type == (m68k_op_type)op_type) |
1395 | 0 | count++; |
1396 | 0 | break; |
1397 | 0 | case CS_ARCH_TMS320C64X: |
1398 | 0 | for (i = 0; i < insn->detail->tms320c64x.op_count; i++) |
1399 | 0 | if (insn->detail->tms320c64x.operands[i].type == (tms320c64x_op_type)op_type) |
1400 | 0 | count++; |
1401 | 0 | break; |
1402 | 0 | case CS_ARCH_M680X: |
1403 | 0 | for (i = 0; i < insn->detail->m680x.op_count; i++) |
1404 | 0 | if (insn->detail->m680x.operands[i].type == (m680x_op_type)op_type) |
1405 | 0 | count++; |
1406 | 0 | break; |
1407 | 0 | case CS_ARCH_EVM: |
1408 | 0 | break; |
1409 | 0 | case CS_ARCH_MOS65XX: |
1410 | 0 | for (i = 0; i < insn->detail->mos65xx.op_count; i++) |
1411 | 0 | if (insn->detail->mos65xx.operands[i].type == (mos65xx_op_type)op_type) |
1412 | 0 | count++; |
1413 | 0 | break; |
1414 | 0 | case CS_ARCH_WASM: |
1415 | 0 | for (i = 0; i < insn->detail->wasm.op_count; i++) |
1416 | 0 | if (insn->detail->wasm.operands[i].type == (wasm_op_type)op_type) |
1417 | 0 | count++; |
1418 | 0 | break; |
1419 | 0 | case CS_ARCH_BPF: |
1420 | 0 | for (i = 0; i < insn->detail->bpf.op_count; i++) |
1421 | 0 | if (insn->detail->bpf.operands[i].type == (bpf_op_type)op_type) |
1422 | 0 | count++; |
1423 | 0 | break; |
1424 | 0 | case CS_ARCH_RISCV: |
1425 | 0 | for (i = 0; i < insn->detail->riscv.op_count; i++) |
1426 | 0 | if (insn->detail->riscv.operands[i].type == (riscv_op_type)op_type) |
1427 | 0 | count++; |
1428 | 0 | break; |
1429 | 0 | case CS_ARCH_TRICORE: |
1430 | 0 | for (i = 0; i < insn->detail->tricore.op_count; i++) |
1431 | 0 | if (insn->detail->tricore.operands[i].type == (tricore_op_type)op_type) |
1432 | 0 | count++; |
1433 | 0 | break; |
1434 | 0 | } |
1435 | | |
1436 | 0 | return count; |
1437 | 0 | } |
1438 | | |
1439 | | CAPSTONE_EXPORT |
1440 | | int CAPSTONE_API cs_op_index(csh ud, const cs_insn *insn, unsigned int op_type, |
1441 | | unsigned int post) |
1442 | 0 | { |
1443 | 0 | struct cs_struct *handle; |
1444 | 0 | unsigned int count = 0, i; |
1445 | 0 | if (!ud) |
1446 | 0 | return -1; |
1447 | | |
1448 | 0 | handle = (struct cs_struct *)(uintptr_t)ud; |
1449 | |
|
1450 | 0 | if (!handle->detail) { |
1451 | 0 | handle->errnum = CS_ERR_DETAIL; |
1452 | 0 | return -1; |
1453 | 0 | } |
1454 | | |
1455 | 0 | if (!insn->id) { |
1456 | 0 | handle->errnum = CS_ERR_SKIPDATA; |
1457 | 0 | return -1; |
1458 | 0 | } |
1459 | | |
1460 | 0 | if (!insn->detail) { |
1461 | 0 | handle->errnum = CS_ERR_DETAIL; |
1462 | 0 | return -1; |
1463 | 0 | } |
1464 | | |
1465 | 0 | handle->errnum = CS_ERR_OK; |
1466 | |
|
1467 | 0 | switch (handle->arch) { |
1468 | 0 | default: |
1469 | 0 | handle->errnum = CS_ERR_HANDLE; |
1470 | 0 | return -1; |
1471 | 0 | case CS_ARCH_ARM: |
1472 | 0 | for (i = 0; i < insn->detail->arm.op_count; i++) { |
1473 | 0 | if (insn->detail->arm.operands[i].type == (arm_op_type)op_type) |
1474 | 0 | count++; |
1475 | 0 | if (count == post) |
1476 | 0 | return i; |
1477 | 0 | } |
1478 | 0 | break; |
1479 | 0 | case CS_ARCH_ARM64: |
1480 | 0 | for (i = 0; i < insn->detail->arm64.op_count; i++) { |
1481 | 0 | if (insn->detail->arm64.operands[i].type == (arm64_op_type)op_type) |
1482 | 0 | count++; |
1483 | 0 | if (count == post) |
1484 | 0 | return i; |
1485 | 0 | } |
1486 | 0 | break; |
1487 | 0 | case CS_ARCH_X86: |
1488 | 0 | for (i = 0; i < insn->detail->x86.op_count; i++) { |
1489 | 0 | if (insn->detail->x86.operands[i].type == (x86_op_type)op_type) |
1490 | 0 | count++; |
1491 | 0 | if (count == post) |
1492 | 0 | return i; |
1493 | 0 | } |
1494 | 0 | break; |
1495 | 0 | case CS_ARCH_MIPS: |
1496 | 0 | for (i = 0; i < insn->detail->mips.op_count; i++) { |
1497 | 0 | if (insn->detail->mips.operands[i].type == (mips_op_type)op_type) |
1498 | 0 | count++; |
1499 | 0 | if (count == post) |
1500 | 0 | return i; |
1501 | 0 | } |
1502 | 0 | break; |
1503 | 0 | case CS_ARCH_PPC: |
1504 | 0 | for (i = 0; i < insn->detail->ppc.op_count; i++) { |
1505 | 0 | if (insn->detail->ppc.operands[i].type == (ppc_op_type)op_type) |
1506 | 0 | count++; |
1507 | 0 | if (count == post) |
1508 | 0 | return i; |
1509 | 0 | } |
1510 | 0 | break; |
1511 | 0 | case CS_ARCH_SPARC: |
1512 | 0 | for (i = 0; i < insn->detail->sparc.op_count; i++) { |
1513 | 0 | if (insn->detail->sparc.operands[i].type == (sparc_op_type)op_type) |
1514 | 0 | count++; |
1515 | 0 | if (count == post) |
1516 | 0 | return i; |
1517 | 0 | } |
1518 | 0 | break; |
1519 | 0 | case CS_ARCH_SYSZ: |
1520 | 0 | for (i = 0; i < insn->detail->sysz.op_count; i++) { |
1521 | 0 | if (insn->detail->sysz.operands[i].type == (sysz_op_type)op_type) |
1522 | 0 | count++; |
1523 | 0 | if (count == post) |
1524 | 0 | return i; |
1525 | 0 | } |
1526 | 0 | break; |
1527 | 0 | case CS_ARCH_XCORE: |
1528 | 0 | for (i = 0; i < insn->detail->xcore.op_count; i++) { |
1529 | 0 | if (insn->detail->xcore.operands[i].type == (xcore_op_type)op_type) |
1530 | 0 | count++; |
1531 | 0 | if (count == post) |
1532 | 0 | return i; |
1533 | 0 | } |
1534 | 0 | break; |
1535 | 0 | case CS_ARCH_TRICORE: |
1536 | 0 | for (i = 0; i < insn->detail->tricore.op_count; i++) { |
1537 | 0 | if (insn->detail->tricore.operands[i].type == (tricore_op_type)op_type) |
1538 | 0 | count++; |
1539 | 0 | if (count == post) |
1540 | 0 | return i; |
1541 | 0 | } |
1542 | 0 | break; |
1543 | 0 | case CS_ARCH_M68K: |
1544 | 0 | for (i = 0; i < insn->detail->m68k.op_count; i++) { |
1545 | 0 | if (insn->detail->m68k.operands[i].type == (m68k_op_type)op_type) |
1546 | 0 | count++; |
1547 | 0 | if (count == post) |
1548 | 0 | return i; |
1549 | 0 | } |
1550 | 0 | break; |
1551 | 0 | case CS_ARCH_TMS320C64X: |
1552 | 0 | for (i = 0; i < insn->detail->tms320c64x.op_count; i++) { |
1553 | 0 | if (insn->detail->tms320c64x.operands[i].type == (tms320c64x_op_type)op_type) |
1554 | 0 | count++; |
1555 | 0 | if (count == post) |
1556 | 0 | return i; |
1557 | 0 | } |
1558 | 0 | break; |
1559 | 0 | case CS_ARCH_M680X: |
1560 | 0 | for (i = 0; i < insn->detail->m680x.op_count; i++) { |
1561 | 0 | if (insn->detail->m680x.operands[i].type == (m680x_op_type)op_type) |
1562 | 0 | count++; |
1563 | 0 | if (count == post) |
1564 | 0 | return i; |
1565 | 0 | } |
1566 | 0 | break; |
1567 | 0 | case CS_ARCH_EVM: |
1568 | | #if 0 |
1569 | | for (i = 0; i < insn->detail->evm.op_count; i++) { |
1570 | | if (insn->detail->evm.operands[i].type == (evm_op_type)op_type) |
1571 | | count++; |
1572 | | if (count == post) |
1573 | | return i; |
1574 | | } |
1575 | | #endif |
1576 | 0 | break; |
1577 | 0 | case CS_ARCH_MOS65XX: |
1578 | 0 | for (i = 0; i < insn->detail->mos65xx.op_count; i++) { |
1579 | 0 | if (insn->detail->mos65xx.operands[i].type == (mos65xx_op_type)op_type) |
1580 | 0 | count++; |
1581 | 0 | if (count == post) |
1582 | 0 | return i; |
1583 | 0 | } |
1584 | 0 | break; |
1585 | 0 | case CS_ARCH_WASM: |
1586 | 0 | for (i = 0; i < insn->detail->wasm.op_count; i++) { |
1587 | 0 | if (insn->detail->wasm.operands[i].type == (wasm_op_type)op_type) |
1588 | 0 | count++; |
1589 | 0 | if (count == post) |
1590 | 0 | return i; |
1591 | 0 | } |
1592 | 0 | break; |
1593 | 0 | case CS_ARCH_BPF: |
1594 | 0 | for (i = 0; i < insn->detail->bpf.op_count; i++) { |
1595 | 0 | if (insn->detail->bpf.operands[i].type == (bpf_op_type)op_type) |
1596 | 0 | count++; |
1597 | 0 | if (count == post) |
1598 | 0 | return i; |
1599 | 0 | } |
1600 | 0 | break; |
1601 | 0 | case CS_ARCH_RISCV: |
1602 | 0 | for (i = 0; i < insn->detail->riscv.op_count; i++) { |
1603 | 0 | if (insn->detail->riscv.operands[i].type == (riscv_op_type)op_type) |
1604 | 0 | count++; |
1605 | 0 | if (count == post) |
1606 | 0 | return i; |
1607 | 0 | } |
1608 | 0 | break; |
1609 | 0 | case CS_ARCH_SH: |
1610 | 0 | for (i = 0; i < insn->detail->sh.op_count; i++) { |
1611 | 0 | if (insn->detail->sh.operands[i].type == (sh_op_type)op_type) |
1612 | 0 | count++; |
1613 | 0 | if (count == post) |
1614 | 0 | return i; |
1615 | 0 | } |
1616 | 0 | break; |
1617 | 0 | } |
1618 | | |
1619 | 0 | return -1; |
1620 | 0 | } |
1621 | | |
1622 | | CAPSTONE_EXPORT |
1623 | | cs_err CAPSTONE_API cs_regs_access(csh ud, const cs_insn *insn, |
1624 | | cs_regs regs_read, uint8_t *regs_read_count, |
1625 | | cs_regs regs_write, uint8_t *regs_write_count) |
1626 | 0 | { |
1627 | 0 | struct cs_struct *handle; |
1628 | |
|
1629 | 0 | if (!ud) |
1630 | 0 | return -1; |
1631 | | |
1632 | 0 | handle = (struct cs_struct *)(uintptr_t)ud; |
1633 | |
|
1634 | | #ifdef CAPSTONE_DIET |
1635 | | // This API does not work in DIET mode |
1636 | | handle->errnum = CS_ERR_DIET; |
1637 | | return CS_ERR_DIET; |
1638 | | #else |
1639 | 0 | if (!handle->detail) { |
1640 | 0 | handle->errnum = CS_ERR_DETAIL; |
1641 | 0 | return CS_ERR_DETAIL; |
1642 | 0 | } |
1643 | | |
1644 | 0 | if (!insn->id) { |
1645 | 0 | handle->errnum = CS_ERR_SKIPDATA; |
1646 | 0 | return CS_ERR_SKIPDATA; |
1647 | 0 | } |
1648 | | |
1649 | 0 | if (!insn->detail) { |
1650 | 0 | handle->errnum = CS_ERR_DETAIL; |
1651 | 0 | return CS_ERR_DETAIL; |
1652 | 0 | } |
1653 | | |
1654 | 0 | if (handle->reg_access) { |
1655 | 0 | handle->reg_access(insn, regs_read, regs_read_count, regs_write, regs_write_count); |
1656 | 0 | } else { |
1657 | | // this arch is unsupported yet |
1658 | 0 | handle->errnum = CS_ERR_ARCH; |
1659 | 0 | return CS_ERR_ARCH; |
1660 | 0 | } |
1661 | | |
1662 | 0 | return CS_ERR_OK; |
1663 | 0 | #endif |
1664 | 0 | } |