Nguyen Anh Quynh | 6023ef7 | 2014-04-29 11:21:04 +0800 | [diff] [blame] | 1 | /* Capstone Disassembly Engine */ |
Nguyen Anh Quynh | bfcaba5 | 2015-03-04 17:45:23 +0800 | [diff] [blame] | 2 | /* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2015 */ |
Nguyen Anh Quynh | 26ee41a | 2013-11-27 12:11:31 +0800 | [diff] [blame] | 3 | |
reverser | bcf09f4 | 2015-04-09 18:28:19 +0100 | [diff] [blame] | 4 | #if defined(CAPSTONE_HAS_OSXKERNEL) |
vit9696 | 7723175 | 2018-06-15 00:12:26 +0300 | [diff] [blame] | 5 | #include <Availability.h> |
reverser | bcf09f4 | 2015-04-09 18:28:19 +0100 | [diff] [blame] | 6 | #include <libkern/libkern.h> |
| 7 | #else |
Nguyen Anh Quynh | b265406 | 2014-01-03 17:08:58 +0800 | [diff] [blame] | 8 | #include <stdlib.h> |
reverser | bcf09f4 | 2015-04-09 18:28:19 +0100 | [diff] [blame] | 9 | #endif |
Nguyen Anh Quynh | 26ee41a | 2013-11-27 12:11:31 +0800 | [diff] [blame] | 10 | #include <string.h> |
| 11 | |
| 12 | #include "utils.h" |
| 13 | |
Nguyen Anh Quynh | b265406 | 2014-01-03 17:08:58 +0800 | [diff] [blame] | 14 | // create a cache for fast id lookup |
Richard Henderson | 22ead3e | 2017-10-21 17:45:40 -0700 | [diff] [blame] | 15 | static unsigned short *make_id2insn(const insn_map *insns, unsigned int size) |
Nguyen Anh Quynh | 26ee41a | 2013-11-27 12:11:31 +0800 | [diff] [blame] | 16 | { |
Nguyen Anh Quynh | b265406 | 2014-01-03 17:08:58 +0800 | [diff] [blame] | 17 | // NOTE: assume that the max id is always put at the end of insns array |
| 18 | unsigned short max_id = insns[size - 1].id; |
Alex Ionescu | 46018db | 2014-01-22 09:45:00 -0800 | [diff] [blame] | 19 | unsigned short i; |
Nguyen Anh Quynh | 26ee41a | 2013-11-27 12:11:31 +0800 | [diff] [blame] | 20 | |
obs1dium | 33f39e1 | 2017-10-13 03:04:16 +0200 | [diff] [blame] | 21 | unsigned short *cache = (unsigned short *)cs_mem_calloc(max_id + 1, sizeof(*cache)); |
Nguyen Anh Quynh | 26ee41a | 2013-11-27 12:11:31 +0800 | [diff] [blame] | 22 | |
Nguyen Anh Quynh | b265406 | 2014-01-03 17:08:58 +0800 | [diff] [blame] | 23 | for (i = 1; i < size; i++) |
| 24 | cache[insns[i].id] = i; |
Nguyen Anh Quynh | 26ee41a | 2013-11-27 12:11:31 +0800 | [diff] [blame] | 25 | |
Nguyen Anh Quynh | b265406 | 2014-01-03 17:08:58 +0800 | [diff] [blame] | 26 | return cache; |
| 27 | } |
| 28 | |
| 29 | // look for @id in @insns, given its size in @max. first time call will update @cache. |
| 30 | // return 0 if not found |
Richard Henderson | 22ead3e | 2017-10-21 17:45:40 -0700 | [diff] [blame] | 31 | unsigned short insn_find(const insn_map *insns, unsigned int max, unsigned int id, unsigned short **cache) |
Nguyen Anh Quynh | b265406 | 2014-01-03 17:08:58 +0800 | [diff] [blame] | 32 | { |
| 33 | if (id > insns[max - 1].id) |
| 34 | return 0; |
| 35 | |
| 36 | if (*cache == NULL) |
| 37 | *cache = make_id2insn(insns, max); |
| 38 | |
| 39 | return (*cache)[id]; |
Nguyen Anh Quynh | 26ee41a | 2013-11-27 12:11:31 +0800 | [diff] [blame] | 40 | } |
| 41 | |
Richard Henderson | 22ead3e | 2017-10-21 17:45:40 -0700 | [diff] [blame] | 42 | int name2id(const name_map* map, int max, const char *name) |
Nguyen Anh Quynh | 26ee41a | 2013-11-27 12:11:31 +0800 | [diff] [blame] | 43 | { |
| 44 | int i; |
| 45 | |
| 46 | for (i = 0; i < max; i++) { |
Nguyen Anh Quynh | 19146e9 | 2014-05-28 12:41:31 +0800 | [diff] [blame] | 47 | if (!strcmp(map[i].name, name)) { |
Nguyen Anh Quynh | 26ee41a | 2013-11-27 12:11:31 +0800 | [diff] [blame] | 48 | return map[i].id; |
| 49 | } |
| 50 | } |
| 51 | |
| 52 | // nothing match |
| 53 | return -1; |
| 54 | } |
| 55 | |
Nguyen Anh Quynh | afffa5d | 2018-07-20 12:36:50 +0800 | [diff] [blame] | 56 | const char *id2name(const name_map* map, int max, const unsigned int id) |
Nguyen Anh Quynh | 1182d25 | 2015-04-27 12:13:34 +0800 | [diff] [blame] | 57 | { |
| 58 | int i; |
| 59 | |
| 60 | for (i = 0; i < max; i++) { |
| 61 | if (map[i].id == id) { |
| 62 | return map[i].name; |
| 63 | } |
| 64 | } |
| 65 | |
| 66 | // nothing match |
| 67 | return NULL; |
| 68 | } |
| 69 | |
Nguyen Anh Quynh | f35e2ad | 2013-12-03 11:10:26 +0800 | [diff] [blame] | 70 | // count number of positive members in a list. |
| 71 | // NOTE: list must be guaranteed to end in 0 |
Nguyen Anh Quynh | afffa5d | 2018-07-20 12:36:50 +0800 | [diff] [blame] | 72 | unsigned int count_positive(const uint16_t *list) |
Nguyen Anh Quynh | efffe78 | 2015-03-25 15:02:13 +0800 | [diff] [blame] | 73 | { |
| 74 | unsigned int c; |
| 75 | |
| 76 | for (c = 0; list[c] > 0; c++); |
| 77 | |
| 78 | return c; |
| 79 | } |
| 80 | |
| 81 | // count number of positive members in a list. |
| 82 | // NOTE: list must be guaranteed to end in 0 |
Nguyen Anh Quynh | afffa5d | 2018-07-20 12:36:50 +0800 | [diff] [blame] | 83 | unsigned int count_positive8(const unsigned char *list) |
Nguyen Anh Quynh | f35e2ad | 2013-12-03 11:10:26 +0800 | [diff] [blame] | 84 | { |
| 85 | unsigned int c; |
| 86 | |
| 87 | for (c = 0; list[c] > 0; c++); |
| 88 | |
| 89 | return c; |
| 90 | } |
Nguyen Anh Quynh | a9ffb44 | 2014-01-15 18:27:01 +0800 | [diff] [blame] | 91 | |
| 92 | char *cs_strdup(const char *str) |
| 93 | { |
| 94 | size_t len = strlen(str)+ 1; |
| 95 | void *new = cs_mem_malloc(len); |
| 96 | |
| 97 | if (new == NULL) |
| 98 | return NULL; |
| 99 | |
| 100 | return (char *)memmove(new, str, len); |
| 101 | } |
Nguyen Anh Quynh | 4b6b15f | 2014-08-26 15:57:04 +0800 | [diff] [blame] | 102 | |
| 103 | // we need this since Windows doesnt have snprintf() |
| 104 | int cs_snprintf(char *buffer, size_t size, const char *fmt, ...) |
| 105 | { |
| 106 | int ret; |
| 107 | |
| 108 | va_list ap; |
| 109 | va_start(ap, fmt); |
| 110 | ret = cs_vsnprintf(buffer, size, fmt, ap); |
| 111 | va_end(ap); |
| 112 | |
| 113 | return ret; |
| 114 | } |
Nguyen Anh Quynh | 58eb073 | 2015-04-02 15:18:33 +0800 | [diff] [blame] | 115 | |
| 116 | bool arr_exist8(unsigned char *arr, unsigned char max, unsigned int id) |
| 117 | { |
| 118 | int i; |
| 119 | |
| 120 | for (i = 0; i < max; i++) { |
| 121 | if (arr[i] == id) |
| 122 | return true; |
| 123 | } |
| 124 | |
| 125 | return false; |
| 126 | } |
| 127 | |
| 128 | bool arr_exist(uint16_t *arr, unsigned char max, unsigned int id) |
| 129 | { |
| 130 | int i; |
| 131 | |
| 132 | for (i = 0; i < max; i++) { |
| 133 | if (arr[i] == id) |
| 134 | return true; |
| 135 | } |
| 136 | |
| 137 | return false; |
| 138 | } |
| 139 | |