/src/capstonev5/Mapping.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* Capstone Disassembly Engine */ |
2 | | /* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */ |
3 | | /* Rot127 <unisono@quyllur.org>, 2022-2023 */ |
4 | | |
5 | | #include "Mapping.h" |
6 | | |
7 | | // create a cache for fast id lookup |
8 | | static unsigned short *make_id2insn(const insn_map *insns, unsigned int size) |
9 | 29.7k | { |
10 | | // NOTE: assume that the max id is always put at the end of insns array |
11 | 29.7k | unsigned short max_id = insns[size - 1].id; |
12 | 29.7k | unsigned int i; |
13 | | |
14 | 29.7k | unsigned short *cache = |
15 | 29.7k | (unsigned short *)cs_mem_calloc(max_id + 1, sizeof(*cache)); |
16 | | |
17 | 62.0M | for (i = 1; i < size; i++) |
18 | 61.9M | cache[insns[i].id] = i; |
19 | | |
20 | 29.7k | return cache; |
21 | 29.7k | } |
22 | | |
23 | | // look for @id in @insns, given its size in @max. first time call will update |
24 | | // @cache. return 0 if not found |
25 | | unsigned short insn_find(const insn_map *insns, unsigned int max, |
26 | | unsigned int id, unsigned short **cache) |
27 | 2.79M | { |
28 | 2.79M | if (id > insns[max - 1].id) |
29 | 0 | return 0; |
30 | | |
31 | 2.79M | if (*cache == NULL) |
32 | 29.7k | *cache = make_id2insn(insns, max); |
33 | | |
34 | 2.79M | return (*cache)[id]; |
35 | 2.79M | } |
36 | | |
37 | | // Gives the id for the given @name if it is saved in @map. |
38 | | // Returns the id or -1 if not found. |
39 | | int name2id(const name_map *map, int max, const char *name) |
40 | 151k | { |
41 | 151k | int i; |
42 | | |
43 | 24.7M | for (i = 0; i < max; i++) { |
44 | 24.6M | if (!strcmp(map[i].name, name)) { |
45 | 111k | return map[i].id; |
46 | 111k | } |
47 | 24.6M | } |
48 | | |
49 | | // nothing match |
50 | 40.2k | return -1; |
51 | 151k | } |
52 | | |
53 | | // Gives the name for the given @id if it is saved in @map. |
54 | | // Returns the name or NULL if not found. |
55 | | const char *id2name(const name_map *map, int max, const unsigned int id) |
56 | 5.82M | { |
57 | 5.82M | int i; |
58 | | |
59 | 127M | for (i = 0; i < max; i++) { |
60 | 127M | if (map[i].id == id) { |
61 | 5.82M | return map[i].name; |
62 | 5.82M | } |
63 | 127M | } |
64 | | |
65 | | // nothing match |
66 | 0 | return NULL; |
67 | 5.82M | } |
68 | | |
69 | | /// Adds a register to the implicit write register list. |
70 | | /// It will not add the same register twice. |
71 | | void map_add_implicit_write(MCInst *MI, uint32_t Reg) |
72 | 500k | { |
73 | 500k | if (!MI->flat_insn->detail) |
74 | 0 | return; |
75 | | |
76 | 500k | uint16_t *regs_write = MI->flat_insn->detail->regs_write; |
77 | 504k | for (int i = 0; i < MAX_IMPL_W_REGS; ++i) { |
78 | 504k | if (i == MI->flat_insn->detail->regs_write_count) { |
79 | 481k | regs_write[i] = Reg; |
80 | 481k | MI->flat_insn->detail->regs_write_count++; |
81 | 481k | return; |
82 | 481k | } |
83 | 23.1k | if (regs_write[i] == Reg) |
84 | 19.5k | return; |
85 | 23.1k | } |
86 | 500k | } |
87 | | |
88 | | /// Copies the implicit read registers of @imap to @MI->flat_insn. |
89 | | /// Already present registers will be preserved. |
90 | | void map_implicit_reads(MCInst *MI, const insn_map *imap) |
91 | 1.90M | { |
92 | 1.90M | #ifndef CAPSTONE_DIET |
93 | 1.90M | if (!MI->flat_insn->detail) |
94 | 0 | return; |
95 | | |
96 | 1.90M | cs_detail *detail = MI->flat_insn->detail; |
97 | 1.90M | unsigned Opcode = MCInst_getOpcode(MI); |
98 | 1.90M | unsigned i = 0; |
99 | 1.90M | uint16_t reg = imap[Opcode].regs_use[i]; |
100 | 1.98M | while (reg != 0) { |
101 | 87.8k | if (i >= MAX_IMPL_R_REGS || |
102 | 87.8k | detail->regs_read_count >= MAX_IMPL_R_REGS) { |
103 | 0 | printf("ERROR: Too many implicit read register defined in " |
104 | 0 | "instruction mapping.\n"); |
105 | 0 | return; |
106 | 0 | } |
107 | 87.8k | detail->regs_read[detail->regs_read_count++] = reg; |
108 | 87.8k | reg = imap[Opcode].regs_use[++i]; |
109 | 87.8k | } |
110 | 1.90M | #endif // CAPSTONE_DIET |
111 | 1.90M | } |
112 | | |
113 | | /// Copies the implicit write registers of @imap to @MI->flat_insn. |
114 | | /// Already present registers will be preserved. |
115 | | void map_implicit_writes(MCInst *MI, const insn_map *imap) |
116 | 1.90M | { |
117 | 1.90M | #ifndef CAPSTONE_DIET |
118 | 1.90M | if (!MI->flat_insn->detail) |
119 | 0 | return; |
120 | | |
121 | 1.90M | cs_detail *detail = MI->flat_insn->detail; |
122 | 1.90M | unsigned Opcode = MCInst_getOpcode(MI); |
123 | 1.90M | unsigned i = 0; |
124 | 1.90M | uint16_t reg = imap[Opcode].regs_mod[i]; |
125 | 2.21M | while (reg != 0) { |
126 | 318k | if (i >= MAX_IMPL_W_REGS || |
127 | 318k | detail->regs_write_count >= MAX_IMPL_W_REGS) { |
128 | 0 | printf("ERROR: Too many implicit write register defined in " |
129 | 0 | "instruction mapping.\n"); |
130 | 0 | return; |
131 | 0 | } |
132 | 318k | detail->regs_write[detail->regs_write_count++] = reg; |
133 | 318k | reg = imap[Opcode].regs_mod[++i]; |
134 | 318k | } |
135 | 1.90M | #endif // CAPSTONE_DIET |
136 | 1.90M | } |
137 | | |
138 | | /// Copies the groups from @imap to @MI->flat_insn. |
139 | | /// Already present groups will be preserved. |
140 | | void map_groups(MCInst *MI, const insn_map *imap) |
141 | 1.90M | { |
142 | 1.90M | #ifndef CAPSTONE_DIET |
143 | 1.90M | if (!MI->flat_insn->detail) |
144 | 0 | return; |
145 | | |
146 | 1.90M | cs_detail *detail = MI->flat_insn->detail; |
147 | 1.90M | unsigned Opcode = MCInst_getOpcode(MI); |
148 | 1.90M | unsigned i = 0; |
149 | 1.90M | uint16_t group = imap[Opcode].groups[i]; |
150 | 3.95M | while (group != 0) { |
151 | 2.05M | if (detail->groups_count >= MAX_NUM_GROUPS) { |
152 | 0 | printf("ERROR: Too many groups defined in instruction mapping.\n"); |
153 | 0 | return; |
154 | 0 | } |
155 | 2.05M | detail->groups[detail->groups_count++] = group; |
156 | 2.05M | group = imap[Opcode].groups[++i]; |
157 | 2.05M | } |
158 | 1.90M | #endif // CAPSTONE_DIET |
159 | 1.90M | } |
160 | | |
161 | | // Search for the CS instruction id for the given @MC_Opcode in @imap. |
162 | | // return -1 if none is found. |
163 | | unsigned int find_cs_id(unsigned MC_Opcode, const insn_map *imap, |
164 | | unsigned imap_size) |
165 | 1.90M | { |
166 | | // binary searching since the IDs are sorted in order |
167 | 1.90M | unsigned int left, right, m; |
168 | 1.90M | unsigned int max = imap_size; |
169 | | |
170 | 1.90M | right = max - 1; |
171 | | |
172 | 1.90M | if (MC_Opcode < imap[0].id || MC_Opcode > imap[right].id) |
173 | | // not found |
174 | 0 | return -1; |
175 | | |
176 | 1.90M | left = 0; |
177 | | |
178 | 21.6M | while (left <= right) { |
179 | 21.6M | m = (left + right) / 2; |
180 | 21.6M | if (MC_Opcode == imap[m].id) { |
181 | 1.90M | return m; |
182 | 1.90M | } |
183 | | |
184 | 19.7M | if (MC_Opcode < imap[m].id) |
185 | 6.25M | right = m - 1; |
186 | 13.4M | else |
187 | 13.4M | left = m + 1; |
188 | 19.7M | } |
189 | | |
190 | 0 | return -1; |
191 | 1.90M | } |
192 | | |
193 | | /// Sets the Capstone instruction id which maps to the @MI opcode. |
194 | | /// If no mapping is found the function returns and prints an error. |
195 | | void map_cs_id(MCInst *MI, const insn_map *imap, unsigned int imap_size) |
196 | 1.90M | { |
197 | 1.90M | unsigned int i = find_cs_id(MCInst_getOpcode(MI), imap, imap_size); |
198 | 1.90M | if (i != -1) { |
199 | 1.90M | MI->flat_insn->id = imap[i].mapid; |
200 | 1.90M | return; |
201 | 1.90M | } |
202 | 0 | printf("ERROR: Could not find CS id for MCInst opcode: %d\n", |
203 | 0 | MCInst_getOpcode(MI)); |
204 | 0 | return; |
205 | 1.90M | } |
206 | | |
207 | | /// Returns the operand type information from the |
208 | | /// mapping table for instruction operands. |
209 | | /// Only usable by `auto-sync` archs! |
210 | | const cs_op_type mapping_get_op_type(MCInst *MI, unsigned OpNum, |
211 | | const map_insn_ops *insn_ops_map, |
212 | | size_t map_size) |
213 | 17.5M | { |
214 | 17.5M | assert(MI); |
215 | 17.5M | assert(MI->Opcode < map_size); |
216 | 17.5M | assert(OpNum < sizeof(insn_ops_map[MI->Opcode].ops) / |
217 | 17.5M | sizeof(insn_ops_map[MI->Opcode].ops[0])); |
218 | | |
219 | 17.5M | return insn_ops_map[MI->Opcode].ops[OpNum].type; |
220 | 17.5M | } |
221 | | |
222 | | /// Returns the operand access flags from the |
223 | | /// mapping table for instruction operands. |
224 | | /// Only usable by `auto-sync` archs! |
225 | | const cs_ac_type mapping_get_op_access(MCInst *MI, unsigned OpNum, |
226 | | const map_insn_ops *insn_ops_map, |
227 | | size_t map_size) |
228 | 5.75M | { |
229 | 5.75M | assert(MI); |
230 | 5.75M | assert(MI->Opcode < map_size); |
231 | 5.75M | assert(OpNum < sizeof(insn_ops_map[MI->Opcode].ops) / |
232 | 5.75M | sizeof(insn_ops_map[MI->Opcode].ops[0])); |
233 | | |
234 | 5.75M | cs_ac_type access = insn_ops_map[MI->Opcode].ops[OpNum].access; |
235 | 5.75M | if (MCInst_opIsTied(MI, OpNum) || MCInst_opIsTying(MI, OpNum)) |
236 | 515k | access |= (access == CS_AC_READ) ? CS_AC_WRITE : CS_AC_READ; |
237 | 5.75M | return access; |
238 | 5.75M | } |
239 | | |
240 | | /// Returns the operand at detail->arch.operands[op_count + offset] |
241 | | /// Or NULL if detail is not set. |
242 | | #define DEFINE_get_detail_op(arch, ARCH) \ |
243 | | cs_##arch##_op *ARCH##_get_detail_op(MCInst *MI, int offset) \ |
244 | 16.9M | { \ |
245 | 16.9M | if (!MI->flat_insn->detail) \ |
246 | 16.9M | return NULL; \ |
247 | 16.9M | int OpIdx = MI->flat_insn->detail->arch.op_count + offset; \ |
248 | 16.9M | assert(OpIdx >= 0 && OpIdx < MAX_MC_OPS); \ |
249 | 16.9M | return &MI->flat_insn->detail->arch.operands[OpIdx]; \ |
250 | 16.9M | } Line | Count | Source | 244 | 16.2M | { \ | 245 | 16.2M | if (!MI->flat_insn->detail) \ | 246 | 16.2M | return NULL; \ | 247 | 16.2M | int OpIdx = MI->flat_insn->detail->arch.op_count + offset; \ | 248 | 16.2M | assert(OpIdx >= 0 && OpIdx < MAX_MC_OPS); \ | 249 | 16.2M | return &MI->flat_insn->detail->arch.operands[OpIdx]; \ | 250 | 16.2M | } |
Line | Count | Source | 244 | 767k | { \ | 245 | 767k | if (!MI->flat_insn->detail) \ | 246 | 767k | return NULL; \ | 247 | 767k | int OpIdx = MI->flat_insn->detail->arch.op_count + offset; \ | 248 | 767k | assert(OpIdx >= 0 && OpIdx < MAX_MC_OPS); \ | 249 | 767k | return &MI->flat_insn->detail->arch.operands[OpIdx]; \ | 250 | 767k | } |
Unexecuted instantiation: TriCore_get_detail_op |
251 | | |
252 | | DEFINE_get_detail_op(arm, ARM); |
253 | | DEFINE_get_detail_op(ppc, PPC); |
254 | | DEFINE_get_detail_op(tricore, TriCore); |