/src/capstonenext/arch/WASM/WASMDisassembler.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* Capstone Disassembly Engine */ |
2 | | /* By Spike, xwings 2019 */ |
3 | | |
4 | | #include <string.h> |
5 | | #include <stddef.h> |
6 | | |
7 | | #include "WASMDisassembler.h" |
8 | | #include "WASMMapping.h" |
9 | | #include "../../cs_priv.h" |
10 | | |
11 | | static const short opcodes[256] = { |
12 | | WASM_INS_UNREACHABLE, |
13 | | WASM_INS_NOP, |
14 | | WASM_INS_BLOCK, |
15 | | WASM_INS_LOOP, |
16 | | WASM_INS_IF, |
17 | | WASM_INS_ELSE, |
18 | | -1, |
19 | | -1, |
20 | | -1, |
21 | | -1, |
22 | | -1, |
23 | | WASM_INS_END, |
24 | | WASM_INS_BR, |
25 | | WASM_INS_BR_IF, |
26 | | WASM_INS_BR_TABLE, |
27 | | WASM_INS_RETURN, |
28 | | WASM_INS_CALL, |
29 | | WASM_INS_CALL_INDIRECT, |
30 | | -1, |
31 | | -1, |
32 | | -1, |
33 | | -1, |
34 | | -1, |
35 | | -1, |
36 | | -1, |
37 | | -1, |
38 | | WASM_INS_DROP, |
39 | | WASM_INS_SELECT, |
40 | | -1, |
41 | | -1, |
42 | | -1, |
43 | | -1, |
44 | | WASM_INS_GET_LOCAL, |
45 | | WASM_INS_SET_LOCAL, |
46 | | WASM_INS_TEE_LOCAL, |
47 | | WASM_INS_GET_GLOBAL, |
48 | | WASM_INS_SET_GLOBAL, |
49 | | -1, |
50 | | -1, |
51 | | -1, |
52 | | WASM_INS_I32_LOAD, |
53 | | WASM_INS_I64_LOAD, |
54 | | WASM_INS_F32_LOAD, |
55 | | WASM_INS_F64_LOAD, |
56 | | WASM_INS_I32_LOAD8_S, |
57 | | WASM_INS_I32_LOAD8_U, |
58 | | WASM_INS_I32_LOAD16_S, |
59 | | WASM_INS_I32_LOAD16_U, |
60 | | WASM_INS_I64_LOAD8_S, |
61 | | WASM_INS_I64_LOAD8_U, |
62 | | WASM_INS_I64_LOAD16_S, |
63 | | WASM_INS_I64_LOAD16_U, |
64 | | WASM_INS_I64_LOAD32_S, |
65 | | WASM_INS_I64_LOAD32_U, |
66 | | WASM_INS_I32_STORE, |
67 | | WASM_INS_I64_STORE, |
68 | | WASM_INS_F32_STORE, |
69 | | WASM_INS_F64_STORE, |
70 | | WASM_INS_I32_STORE8, |
71 | | WASM_INS_I32_STORE16, |
72 | | WASM_INS_I64_STORE8, |
73 | | WASM_INS_I64_STORE16, |
74 | | WASM_INS_I64_STORE32, |
75 | | WASM_INS_CURRENT_MEMORY, |
76 | | WASM_INS_GROW_MEMORY, |
77 | | WASM_INS_I32_CONST, |
78 | | WASM_INS_I64_CONST, |
79 | | WASM_INS_F32_CONST, |
80 | | WASM_INS_F64_CONST, |
81 | | WASM_INS_I32_EQZ, |
82 | | WASM_INS_I32_EQ, |
83 | | WASM_INS_I32_NE, |
84 | | WASM_INS_I32_LT_S, |
85 | | WASM_INS_I32_LT_U, |
86 | | WASM_INS_I32_GT_S, |
87 | | WASM_INS_I32_GT_U, |
88 | | WASM_INS_I32_LE_S, |
89 | | WASM_INS_I32_LE_U, |
90 | | WASM_INS_I32_GE_S, |
91 | | WASM_INS_I32_GE_U, |
92 | | WASM_INS_I64_EQZ, |
93 | | WASM_INS_I64_EQ, |
94 | | WASM_INS_I64_NE, |
95 | | WASM_INS_I64_LT_S, |
96 | | WASM_INS_I64_LT_U, |
97 | | WASN_INS_I64_GT_S, |
98 | | WASM_INS_I64_GT_U, |
99 | | WASM_INS_I64_LE_S, |
100 | | WASM_INS_I64_LE_U, |
101 | | WASM_INS_I64_GE_S, |
102 | | WASM_INS_I64_GE_U, |
103 | | WASM_INS_F32_EQ, |
104 | | WASM_INS_F32_NE, |
105 | | WASM_INS_F32_LT, |
106 | | WASM_INS_F32_GT, |
107 | | WASM_INS_F32_LE, |
108 | | WASM_INS_F32_GE, |
109 | | WASM_INS_F64_EQ, |
110 | | WASM_INS_F64_NE, |
111 | | WASM_INS_F64_LT, |
112 | | WASM_INS_F64_GT, |
113 | | WASM_INS_F64_LE, |
114 | | WASM_INS_F64_GE, |
115 | | WASM_INS_I32_CLZ, |
116 | | WASM_INS_I32_CTZ, |
117 | | WASM_INS_I32_POPCNT, |
118 | | WASM_INS_I32_ADD, |
119 | | WASM_INS_I32_SUB, |
120 | | WASM_INS_I32_MUL, |
121 | | WASM_INS_I32_DIV_S, |
122 | | WASM_INS_I32_DIV_U, |
123 | | WASM_INS_I32_REM_S, |
124 | | WASM_INS_I32_REM_U, |
125 | | WASM_INS_I32_AND, |
126 | | WASM_INS_I32_OR, |
127 | | WASM_INS_I32_XOR, |
128 | | WASM_INS_I32_SHL, |
129 | | WASM_INS_I32_SHR_S, |
130 | | WASM_INS_I32_SHR_U, |
131 | | WASM_INS_I32_ROTL, |
132 | | WASM_INS_I32_ROTR, |
133 | | WASM_INS_I64_CLZ, |
134 | | WASM_INS_I64_CTZ, |
135 | | WASM_INS_I64_POPCNT, |
136 | | WASM_INS_I64_ADD, |
137 | | WASM_INS_I64_SUB, |
138 | | WASM_INS_I64_MUL, |
139 | | WASM_INS_I64_DIV_S, |
140 | | WASM_INS_I64_DIV_U, |
141 | | WASM_INS_I64_REM_S, |
142 | | WASM_INS_I64_REM_U, |
143 | | WASM_INS_I64_AND, |
144 | | WASM_INS_I64_OR, |
145 | | WASM_INS_I64_XOR, |
146 | | WASM_INS_I64_SHL, |
147 | | WASM_INS_I64_SHR_S, |
148 | | WASM_INS_I64_SHR_U, |
149 | | WASM_INS_I64_ROTL, |
150 | | WASM_INS_I64_ROTR, |
151 | | WASM_INS_F32_ABS, |
152 | | WASM_INS_F32_NEG, |
153 | | WASM_INS_F32_CEIL, |
154 | | WASM_INS_F32_FLOOR, |
155 | | WASM_INS_F32_TRUNC, |
156 | | WASM_INS_F32_NEAREST, |
157 | | WASM_INS_F32_SQRT, |
158 | | WASM_INS_F32_ADD, |
159 | | WASM_INS_F32_SUB, |
160 | | WASM_INS_F32_MUL, |
161 | | WASM_INS_F32_DIV, |
162 | | WASM_INS_F32_MIN, |
163 | | WASM_INS_F32_MAX, |
164 | | WASM_INS_F32_COPYSIGN, |
165 | | WASM_INS_F64_ABS, |
166 | | WASM_INS_F64_NEG, |
167 | | WASM_INS_F64_CEIL, |
168 | | WASM_INS_F64_FLOOR, |
169 | | WASM_INS_F64_TRUNC, |
170 | | WASM_INS_F64_NEAREST, |
171 | | WASM_INS_F64_SQRT, |
172 | | WASM_INS_F64_ADD, |
173 | | WASM_INS_F64_SUB, |
174 | | WASM_INS_F64_MUL, |
175 | | WASM_INS_F64_DIV, |
176 | | WASM_INS_F64_MIN, |
177 | | WASM_INS_F64_MAX, |
178 | | WASM_INS_F64_COPYSIGN, |
179 | | WASM_INS_I32_WARP_I64, |
180 | | WASP_INS_I32_TRUNC_S_F32, |
181 | | WASM_INS_I32_TRUNC_U_F32, |
182 | | WASM_INS_I32_TRUNC_S_F64, |
183 | | WASM_INS_I32_TRUNC_U_F64, |
184 | | WASM_INS_I64_EXTEND_S_I32, |
185 | | WASM_INS_I64_EXTEND_U_I32, |
186 | | WASM_INS_I64_TRUNC_S_F32, |
187 | | WASM_INS_I64_TRUNC_U_F32, |
188 | | WASM_INS_I64_TRUNC_S_F64, |
189 | | WASM_INS_I64_TRUNC_U_F64, |
190 | | WASM_INS_F32_CONVERT_S_I32, |
191 | | WASM_INS_F32_CONVERT_U_I32, |
192 | | WASM_INS_F32_CONVERT_S_I64, |
193 | | WASM_INS_F32_CONVERT_U_I64, |
194 | | WASM_INS_F32_DEMOTE_F64, |
195 | | WASM_INS_F64_CONVERT_S_I32, |
196 | | WASM_INS_F64_CONVERT_U_I32, |
197 | | WASM_INS_F64_CONVERT_S_I64, |
198 | | WASM_INS_F64_CONVERT_U_I64, |
199 | | WASM_INS_F64_PROMOTE_F32, |
200 | | WASM_INS_I32_REINTERPRET_F32, |
201 | | WASM_INS_I64_REINTERPRET_F64, |
202 | | WASM_INS_F32_REINTERPRET_I32, |
203 | | WASM_INS_F64_REINTERPRET_I64, |
204 | | -1, |
205 | | -1, |
206 | | -1, |
207 | | -1, |
208 | | -1, |
209 | | -1, |
210 | | -1, |
211 | | -1, |
212 | | -1, |
213 | | -1, |
214 | | -1, |
215 | | -1, |
216 | | -1, |
217 | | -1, |
218 | | -1, |
219 | | -1, |
220 | | -1, |
221 | | -1, |
222 | | -1, |
223 | | -1, |
224 | | -1, |
225 | | -1, |
226 | | -1, |
227 | | -1, |
228 | | -1, |
229 | | -1, |
230 | | -1, |
231 | | -1, |
232 | | -1, |
233 | | -1, |
234 | | -1, |
235 | | -1, |
236 | | -1, |
237 | | -1, |
238 | | -1, |
239 | | -1, |
240 | | -1, |
241 | | -1, |
242 | | -1, |
243 | | -1, |
244 | | -1, |
245 | | -1, |
246 | | -1, |
247 | | -1, |
248 | | -1, |
249 | | -1, |
250 | | -1, |
251 | | -1, |
252 | | -1, |
253 | | -1, |
254 | | -1, |
255 | | -1, |
256 | | -1, |
257 | | -1, |
258 | | -1, |
259 | | -1, |
260 | | -1, |
261 | | -1, |
262 | | -1, |
263 | | -1, |
264 | | -1, |
265 | | -1, |
266 | | -1, |
267 | | -1, |
268 | | }; |
269 | | |
270 | | // input | code: code pointer start from varuint32 |
271 | | // | code_len: real code len count from varint |
272 | | // | leng: return value, means length of varint. -1 means error |
273 | | // return | varint |
274 | | static uint32_t get_varuint32(const uint8_t *code, size_t code_len, |
275 | | size_t *leng) |
276 | 52.4k | { |
277 | 52.4k | uint32_t data = 0; |
278 | 52.4k | int i; |
279 | | |
280 | 75.1k | for (i = 0;; i++) { |
281 | 75.1k | if (code_len < i + 1) { |
282 | 322 | *leng = -1; |
283 | 322 | return 0; |
284 | 322 | } |
285 | | |
286 | 74.7k | if (i > 4 || (i == 4 && (code[i] & 0x7f) > 0x0f)) { |
287 | 621 | *leng = -1; |
288 | 621 | return 0; |
289 | 621 | } |
290 | | |
291 | 74.1k | data = data + (((uint32_t)code[i] & 0x7f) << (i * 7)); |
292 | 74.1k | if (code[i] >> 7 == 0) { |
293 | 51.4k | break; |
294 | 51.4k | } |
295 | 74.1k | } |
296 | | |
297 | 51.4k | *leng = i + 1; |
298 | | |
299 | 51.4k | return data; |
300 | 52.4k | } |
301 | | |
302 | | // input | code : code pointer start from varuint64 |
303 | | // | code_len : real code len count from varint |
304 | | // | leng: return value, means length of varint. -1 means error |
305 | | // return | varint |
306 | | static uint64_t get_varuint64(const uint8_t *code, size_t code_len, |
307 | | size_t *leng) |
308 | 1.24k | { |
309 | 1.24k | uint64_t data; |
310 | 1.24k | int i; |
311 | | |
312 | 1.24k | data = 0; |
313 | 2.42k | for (i = 0;; i++) { |
314 | 2.42k | if (code_len < i + 1) { |
315 | 4 | *leng = -1; |
316 | 4 | return 0; |
317 | 4 | } |
318 | | |
319 | 2.41k | if (i > 9 || (i == 9 && (code[i] & 0x7f) > 0x01)) { |
320 | 5 | *leng = -1; |
321 | 5 | return 0; |
322 | 5 | } |
323 | | |
324 | 2.41k | data = data + (((uint64_t)code[i] & 0x7f) << (i * 7)); |
325 | 2.41k | if (code[i] >> 7 == 0) { |
326 | 1.23k | break; |
327 | 1.23k | } |
328 | 2.41k | } |
329 | | |
330 | 1.23k | *leng = i + 1; |
331 | | |
332 | 1.23k | return data; |
333 | 1.24k | } |
334 | | |
335 | | // input | code : code pointer start from uint32 |
336 | | // | dest : the pointer where we store the uint32 |
337 | | // return | None |
338 | | static void get_uint32(const uint8_t *code, uint32_t *dest) |
339 | 894 | { |
340 | 894 | memcpy(dest, code, 4); |
341 | 894 | } |
342 | | |
343 | | // input | code : code pointer start from uint32 |
344 | | // | dest : the pointer where we store the uint64 |
345 | | // return | None |
346 | | static void get_uint64(const uint8_t *code, uint64_t *dest) |
347 | 754 | { |
348 | 754 | memcpy(dest, code, 8); |
349 | 754 | } |
350 | | |
351 | | // input | code : code pointer start from varint7 |
352 | | // | code_len : start from the code pointer to the end, how long is it |
353 | | // | leng : length of the param , -1 means error |
354 | | // return | data of varint7 |
355 | | static int8_t get_varint7(const uint8_t *code, size_t code_len, size_t *leng) |
356 | 2.33k | { |
357 | 2.33k | int8_t data; |
358 | | |
359 | 2.33k | if (code_len < 1) { |
360 | 0 | *leng = -1; |
361 | 0 | return -1; |
362 | 0 | } |
363 | | |
364 | 2.33k | *leng = 1; |
365 | | |
366 | 2.33k | if (code[0] == 0x40) { |
367 | 308 | return -1; |
368 | 308 | } |
369 | | |
370 | 2.02k | data = code[0] & 0x7f; |
371 | | |
372 | 2.02k | return data; |
373 | 2.33k | } |
374 | | |
375 | | // input | code : code pointer start from varuint32 |
376 | | // | code_len : start from the code pointer to the end, how long is it |
377 | | // | param_size : pointer of the param size |
378 | | // | MI : Mcinst handler in this round of disasm |
379 | | // return | true/false if the function successfully finished |
380 | | static bool read_varuint32(const uint8_t *code, size_t code_len, |
381 | | uint16_t *param_size, MCInst *MI) |
382 | 7.35k | { |
383 | 7.35k | size_t len = 0; |
384 | 7.35k | uint32_t data; |
385 | | |
386 | 7.35k | data = get_varuint32(code, code_len, &len); |
387 | 7.35k | if (len == -1) { |
388 | 44 | return false; |
389 | 44 | } |
390 | | |
391 | 7.31k | if (MI->flat_insn->detail) { |
392 | 7.31k | MI->flat_insn->detail->wasm.op_count = 1; |
393 | 7.31k | MI->flat_insn->detail->wasm.operands[0].type = |
394 | 7.31k | WASM_OP_VARUINT32; |
395 | 7.31k | MI->flat_insn->detail->wasm.operands[0].size = len; |
396 | 7.31k | MI->flat_insn->detail->wasm.operands[0].varuint32 = data; |
397 | 7.31k | } |
398 | | |
399 | 7.31k | MI->wasm_data.size = len; |
400 | 7.31k | MI->wasm_data.type = WASM_OP_VARUINT32; |
401 | 7.31k | MI->wasm_data.uint32 = data; |
402 | 7.31k | *param_size = len; |
403 | | |
404 | 7.31k | return true; |
405 | 7.35k | } |
406 | | |
407 | | // input | code : code pointer start from varuint64 |
408 | | // | code_len : start from the code pointer to the end, how long is it |
409 | | // | param_size : pointer of the param size |
410 | | // | MI : Mcinst handler in this round of disasm |
411 | | // return | true/false if the function successfully finished |
412 | | static bool read_varuint64(const uint8_t *code, size_t code_len, |
413 | | uint16_t *param_size, MCInst *MI) |
414 | 1.24k | { |
415 | 1.24k | size_t len = 0; |
416 | 1.24k | uint64_t data; |
417 | | |
418 | 1.24k | data = get_varuint64(code, code_len, &len); |
419 | 1.24k | if (len == -1) { |
420 | 9 | return false; |
421 | 9 | } |
422 | | |
423 | 1.23k | if (MI->flat_insn->detail) { |
424 | 1.23k | MI->flat_insn->detail->wasm.op_count = 1; |
425 | 1.23k | MI->flat_insn->detail->wasm.operands[0].type = |
426 | 1.23k | WASM_OP_VARUINT64; |
427 | 1.23k | MI->flat_insn->detail->wasm.operands[0].size = len; |
428 | 1.23k | MI->flat_insn->detail->wasm.operands[0].varuint64 = data; |
429 | 1.23k | } |
430 | | |
431 | 1.23k | MI->wasm_data.size = len; |
432 | 1.23k | MI->wasm_data.type = WASM_OP_VARUINT64; |
433 | 1.23k | MI->wasm_data.uint64 = data; |
434 | 1.23k | *param_size = len; |
435 | | |
436 | 1.23k | return true; |
437 | 1.24k | } |
438 | | |
439 | | // input | code : code pointer start from memoryimmediate |
440 | | // | code_len : start from the code pointer to the end, how long is it |
441 | | // | param_size : pointer of the param size (sum of two params) |
442 | | // | MI : Mcinst handler in this round of disasm |
443 | | // return | true/false if the function successfully finished |
444 | | static bool read_memoryimmediate(const uint8_t *code, size_t code_len, |
445 | | uint16_t *param_size, MCInst *MI) |
446 | 6.34k | { |
447 | 6.34k | size_t tmp, len = 0; |
448 | 6.34k | uint32_t data[2]; |
449 | | |
450 | 6.34k | if (MI->flat_insn->detail) { |
451 | 6.34k | MI->flat_insn->detail->wasm.op_count = 2; |
452 | 6.34k | } |
453 | | |
454 | 6.34k | data[0] = get_varuint32(code, code_len, &tmp); |
455 | 6.34k | if (tmp == -1) { |
456 | 33 | return false; |
457 | 33 | } |
458 | | |
459 | 6.30k | if (MI->flat_insn->detail) { |
460 | 6.30k | MI->flat_insn->detail->wasm.operands[0].type = |
461 | 6.30k | WASM_OP_VARUINT32; |
462 | 6.30k | MI->flat_insn->detail->wasm.operands[0].size = tmp; |
463 | 6.30k | MI->flat_insn->detail->wasm.operands[0].varuint32 = data[0]; |
464 | 6.30k | } |
465 | | |
466 | 6.30k | len = tmp; |
467 | 6.30k | data[1] = get_varuint32(&code[len], code_len - len, &tmp); |
468 | | |
469 | 6.30k | if (MI->flat_insn->detail) { |
470 | 6.30k | MI->flat_insn->detail->wasm.operands[1].type = |
471 | 6.30k | WASM_OP_VARUINT32; |
472 | 6.30k | MI->flat_insn->detail->wasm.operands[1].size = tmp; |
473 | 6.30k | MI->flat_insn->detail->wasm.operands[1].varuint32 = data[1]; |
474 | 6.30k | } |
475 | | |
476 | 6.30k | len += tmp; |
477 | 6.30k | MI->wasm_data.size = len; |
478 | 6.30k | MI->wasm_data.type = WASM_OP_IMM; |
479 | 6.30k | MI->wasm_data.immediate[0] = data[0]; |
480 | 6.30k | MI->wasm_data.immediate[1] = data[1]; |
481 | 6.30k | *param_size = len; |
482 | | |
483 | 6.30k | return true; |
484 | 6.34k | } |
485 | | |
486 | | // input | code : code pointer start from uint32 |
487 | | // | code_len : start from the code pointer to the end, how long is it |
488 | | // | param_size : pointer of the param size |
489 | | // | MI : Mcinst handler in this round of disasm |
490 | | // return | true/false if the function successfully finished |
491 | | static bool read_uint32(const uint8_t *code, size_t code_len, |
492 | | uint16_t *param_size, MCInst *MI) |
493 | 456 | { |
494 | 456 | if (code_len < 4) { |
495 | 9 | return false; |
496 | 9 | } |
497 | | |
498 | 447 | get_uint32(code, &(MI->wasm_data.uint32)); |
499 | | |
500 | 447 | if (MI->flat_insn->detail) { |
501 | 447 | MI->flat_insn->detail->wasm.op_count = 1; |
502 | 447 | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_UINT32; |
503 | 447 | MI->flat_insn->detail->wasm.operands[0].size = 4; |
504 | 447 | get_uint32(code, |
505 | 447 | &(MI->flat_insn->detail->wasm.operands[0].uint32)); |
506 | 447 | } |
507 | | |
508 | 447 | MI->wasm_data.size = 4; |
509 | 447 | MI->wasm_data.type = WASM_OP_UINT32; |
510 | 447 | *param_size = 4; |
511 | | |
512 | 447 | return true; |
513 | 456 | } |
514 | | |
515 | | // input | code : code pointer start from uint64 |
516 | | // | code_len : start from the code pointer to the end, how long is it |
517 | | // | param_size : pointer of the param size |
518 | | // | MI : Mcinst handler in this round of disasm |
519 | | // return | true/false if the function successfully finished |
520 | | static bool read_uint64(const uint8_t *code, size_t code_len, |
521 | | uint16_t *param_size, MCInst *MI) |
522 | 388 | { |
523 | 388 | if (code_len < 8) { |
524 | 11 | return false; |
525 | 11 | } |
526 | | |
527 | 377 | get_uint64(code, &(MI->wasm_data.uint64)); |
528 | | |
529 | 377 | if (MI->flat_insn->detail) { |
530 | 377 | MI->flat_insn->detail->wasm.op_count = 1; |
531 | 377 | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_UINT64; |
532 | 377 | MI->flat_insn->detail->wasm.operands[0].size = 8; |
533 | 377 | get_uint64(code, |
534 | 377 | &(MI->flat_insn->detail->wasm.operands[0].uint64)); |
535 | 377 | } |
536 | | |
537 | 377 | MI->wasm_data.size = 8; |
538 | 377 | MI->wasm_data.type = WASM_OP_UINT64; |
539 | 377 | *param_size = 8; |
540 | | |
541 | 377 | return true; |
542 | 388 | } |
543 | | |
544 | | // input | code : code pointer start from brtable |
545 | | // | code_len : start from the code pointer to the end, how long is it |
546 | | // | param_size : pointer of the param size (sum of all param) |
547 | | // | MI : Mcinst handler in this round of disasm |
548 | | // return | true/false if the function successfully finished |
549 | | static bool read_brtable(const uint8_t *code, size_t code_len, |
550 | | uint16_t *param_size, MCInst *MI) |
551 | 2.53k | { |
552 | 2.53k | uint32_t length, default_target; |
553 | 2.53k | int tmp_len = 0, i; |
554 | 2.53k | size_t var_len; |
555 | | |
556 | | // read length |
557 | 2.53k | length = get_varuint32(code, code_len, &var_len); |
558 | 2.53k | if (var_len == -1) { |
559 | 13 | return false; |
560 | 13 | } |
561 | | |
562 | 2.52k | tmp_len += var_len; |
563 | 2.52k | MI->wasm_data.brtable.length = length; |
564 | 2.52k | if (length >= UINT32_MAX - tmp_len) { |
565 | | // integer overflow check |
566 | 2 | return false; |
567 | 2 | } |
568 | 2.51k | if (code_len < tmp_len + length) { |
569 | | // safety check that we have minimum enough data to read |
570 | 84 | return false; |
571 | 84 | } |
572 | | // base address + 1 byte opcode + tmp_len for number of cases = start of targets |
573 | 2.43k | MI->wasm_data.brtable.address = MI->address + 1 + tmp_len; |
574 | | |
575 | 2.43k | if (MI->flat_insn->detail) { |
576 | 2.43k | MI->flat_insn->detail->wasm.op_count = 1; |
577 | 2.43k | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_BRTABLE; |
578 | 2.43k | MI->flat_insn->detail->wasm.operands[0].brtable.length = |
579 | 2.43k | MI->wasm_data.brtable.length; |
580 | 2.43k | MI->flat_insn->detail->wasm.operands[0].brtable.address = |
581 | 2.43k | MI->wasm_data.brtable.address; |
582 | 2.43k | } |
583 | | |
584 | | // read data |
585 | 13.6k | for (i = 0; i < length; i++) { |
586 | 11.2k | if (code_len < tmp_len) { |
587 | 0 | return false; |
588 | 0 | } |
589 | | |
590 | 11.2k | get_varuint32(code + tmp_len, code_len - tmp_len, &var_len); |
591 | 11.2k | if (var_len == -1) { |
592 | 29 | return false; |
593 | 29 | } |
594 | | |
595 | 11.2k | tmp_len += var_len; |
596 | 11.2k | } |
597 | | |
598 | | // read default target |
599 | 2.40k | default_target = |
600 | 2.40k | get_varuint32(code + tmp_len, code_len - tmp_len, &var_len); |
601 | 2.40k | if (var_len == -1) { |
602 | 31 | return false; |
603 | 31 | } |
604 | | |
605 | 2.37k | MI->wasm_data.brtable.default_target = default_target; |
606 | 2.37k | MI->wasm_data.type = WASM_OP_BRTABLE; |
607 | 2.37k | *param_size = tmp_len + var_len; |
608 | | |
609 | 2.37k | if (MI->flat_insn->detail) { |
610 | 2.37k | MI->flat_insn->detail->wasm.operands[0].size = *param_size; |
611 | 2.37k | MI->flat_insn->detail->wasm.operands[0].brtable.default_target = |
612 | 2.37k | MI->wasm_data.brtable.default_target; |
613 | 2.37k | } |
614 | | |
615 | 2.37k | return true; |
616 | 2.40k | } |
617 | | |
618 | | // input | code : code pointer start from varint7 |
619 | | // | code_len : start from the code pointer to the end, how long is it |
620 | | // | param_size : pointer of the param size |
621 | | // | MI : Mcinst handler in this round of disasm |
622 | | // return | true/false if the function successfully finished |
623 | | static bool read_varint7(const uint8_t *code, size_t code_len, |
624 | | uint16_t *param_size, MCInst *MI) |
625 | 2.33k | { |
626 | 2.33k | size_t len = 0; |
627 | | |
628 | 2.33k | MI->wasm_data.type = WASM_OP_INT7; |
629 | 2.33k | MI->wasm_data.int7 = get_varint7(code, code_len, &len); |
630 | 2.33k | if (len == -1) { |
631 | 0 | return false; |
632 | 0 | } |
633 | | |
634 | 2.33k | if (MI->flat_insn->detail) { |
635 | 2.33k | MI->flat_insn->detail->wasm.op_count = 1; |
636 | 2.33k | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_INT7; |
637 | 2.33k | MI->flat_insn->detail->wasm.operands[0].size = 1; |
638 | 2.33k | MI->flat_insn->detail->wasm.operands[0].int7 = |
639 | 2.33k | MI->wasm_data.int7; |
640 | 2.33k | } |
641 | | |
642 | 2.33k | *param_size = len; |
643 | | |
644 | 2.33k | return true; |
645 | 2.33k | } |
646 | | |
647 | | bool WASM_getInstruction(csh ud, const uint8_t *code, size_t code_len, |
648 | | MCInst *MI, uint16_t *size, uint64_t address, |
649 | | void *inst_info) |
650 | 136k | { |
651 | 136k | unsigned char opcode; |
652 | 136k | uint16_t param_size; |
653 | | |
654 | 136k | if (code_len == 0) |
655 | 0 | return false; |
656 | | |
657 | 136k | opcode = code[0]; |
658 | 136k | if (opcodes[opcode] == -1) { |
659 | | // invalid opcode |
660 | 401 | return false; |
661 | 401 | } |
662 | | |
663 | | // valid opcode |
664 | 135k | MI->address = address; |
665 | 135k | MI->OpcodePub = MI->Opcode = opcode; |
666 | | |
667 | 135k | if (MI->flat_insn->detail) { |
668 | 135k | memset(MI->flat_insn->detail, 0, |
669 | 135k | offsetof(cs_detail, wasm) + sizeof(cs_wasm)); |
670 | 135k | WASM_get_insn_id((cs_struct *)ud, MI->flat_insn, opcode); |
671 | 135k | } |
672 | | |
673 | | // setup groups |
674 | 135k | switch (opcode) { |
675 | 0 | default: |
676 | 0 | return false; |
677 | | |
678 | 728 | case WASM_INS_I32_CONST: |
679 | 728 | if (code_len == 1 || |
680 | 728 | !read_varuint32(&code[1], code_len - 1, ¶m_size, MI)) { |
681 | 13 | return false; |
682 | 13 | } |
683 | | |
684 | 715 | if (MI->flat_insn->detail) { |
685 | 715 | MI->flat_insn->detail->wasm.op_count = 1; |
686 | 715 | MI->flat_insn->detail |
687 | 715 | ->groups[MI->flat_insn->detail->groups_count] = |
688 | 715 | WASM_GRP_NUMBERIC; |
689 | 715 | MI->flat_insn->detail->groups_count++; |
690 | 715 | } |
691 | | |
692 | 715 | *size = param_size + 1; |
693 | | |
694 | 715 | break; |
695 | | |
696 | 1.24k | case WASM_INS_I64_CONST: |
697 | 1.24k | if (code_len == 1 || |
698 | 1.24k | !read_varuint64(&code[1], code_len - 1, ¶m_size, MI)) { |
699 | 13 | return false; |
700 | 13 | } |
701 | | |
702 | 1.23k | if (MI->flat_insn->detail) { |
703 | 1.23k | MI->flat_insn->detail->wasm.op_count = 1; |
704 | 1.23k | MI->flat_insn->detail |
705 | 1.23k | ->groups[MI->flat_insn->detail->groups_count] = |
706 | 1.23k | WASM_GRP_NUMBERIC; |
707 | 1.23k | MI->flat_insn->detail->groups_count++; |
708 | 1.23k | } |
709 | | |
710 | 1.23k | *size = param_size + 1; |
711 | | |
712 | 1.23k | break; |
713 | | |
714 | 460 | case WASM_INS_F32_CONST: |
715 | 460 | if (code_len == 1 || |
716 | 460 | !read_uint32(&code[1], code_len - 1, ¶m_size, MI)) { |
717 | 13 | return false; |
718 | 13 | } |
719 | | |
720 | 447 | if (MI->flat_insn->detail) { |
721 | 447 | MI->flat_insn->detail->wasm.op_count = 1; |
722 | 447 | MI->flat_insn->detail |
723 | 447 | ->groups[MI->flat_insn->detail->groups_count] = |
724 | 447 | WASM_GRP_NUMBERIC; |
725 | 447 | MI->flat_insn->detail->groups_count++; |
726 | 447 | } |
727 | | |
728 | 447 | *size = param_size + 1; |
729 | | |
730 | 447 | break; |
731 | | |
732 | 389 | case WASM_INS_F64_CONST: |
733 | 389 | if (code_len == 1 || |
734 | 389 | !read_uint64(&code[1], code_len - 1, ¶m_size, MI)) { |
735 | 12 | return false; |
736 | 12 | } |
737 | | |
738 | 377 | if (MI->flat_insn->detail) { |
739 | 377 | MI->flat_insn->detail->wasm.op_count = 1; |
740 | 377 | MI->flat_insn->detail |
741 | 377 | ->groups[MI->flat_insn->detail->groups_count] = |
742 | 377 | WASM_GRP_NUMBERIC; |
743 | 377 | MI->flat_insn->detail->groups_count++; |
744 | 377 | } |
745 | | |
746 | 377 | *size = param_size + 1; |
747 | | |
748 | 377 | break; |
749 | | |
750 | 1.90k | case WASM_INS_I32_EQZ: |
751 | 2.46k | case WASM_INS_I32_EQ: |
752 | 3.07k | case WASM_INS_I32_NE: |
753 | 3.82k | case WASM_INS_I32_LT_S: |
754 | 4.38k | case WASM_INS_I32_LT_U: |
755 | 4.79k | case WASM_INS_I32_GT_S: |
756 | 5.34k | case WASM_INS_I32_GT_U: |
757 | 6.02k | case WASM_INS_I32_LE_S: |
758 | 6.86k | case WASM_INS_I32_LE_U: |
759 | 7.62k | case WASM_INS_I32_GE_S: |
760 | 7.99k | case WASM_INS_I32_GE_U: |
761 | 8.77k | case WASM_INS_I64_EQZ: |
762 | 10.6k | case WASM_INS_I64_EQ: |
763 | 12.3k | case WASM_INS_I64_NE: |
764 | 12.7k | case WASM_INS_I64_LT_S: |
765 | 13.9k | case WASM_INS_I64_LT_U: |
766 | 14.2k | case WASN_INS_I64_GT_S: |
767 | 15.0k | case WASM_INS_I64_GT_U: |
768 | 15.8k | case WASM_INS_I64_LE_S: |
769 | 16.5k | case WASM_INS_I64_LE_U: |
770 | 17.1k | case WASM_INS_I64_GE_S: |
771 | 17.5k | case WASM_INS_I64_GE_U: |
772 | 18.1k | case WASM_INS_F32_EQ: |
773 | 18.7k | case WASM_INS_F32_NE: |
774 | 20.0k | case WASM_INS_F32_LT: |
775 | 20.4k | case WASM_INS_F32_GT: |
776 | 21.1k | case WASM_INS_F32_LE: |
777 | 21.7k | case WASM_INS_F32_GE: |
778 | 22.8k | case WASM_INS_F64_EQ: |
779 | 23.7k | case WASM_INS_F64_NE: |
780 | 24.7k | case WASM_INS_F64_LT: |
781 | 25.2k | case WASM_INS_F64_GT: |
782 | 25.9k | case WASM_INS_F64_LE: |
783 | 26.7k | case WASM_INS_F64_GE: |
784 | 27.2k | case WASM_INS_I32_CLZ: |
785 | 27.8k | case WASM_INS_I32_CTZ: |
786 | 28.3k | case WASM_INS_I32_POPCNT: |
787 | 28.6k | case WASM_INS_I32_ADD: |
788 | 28.9k | case WASM_INS_I32_SUB: |
789 | 29.7k | case WASM_INS_I32_MUL: |
790 | 30.2k | case WASM_INS_I32_DIV_S: |
791 | 33.9k | case WASM_INS_I32_DIV_U: |
792 | 34.2k | case WASM_INS_I32_REM_S: |
793 | 34.6k | case WASM_INS_I32_REM_U: |
794 | 35.9k | case WASM_INS_I32_AND: |
795 | 36.3k | case WASM_INS_I32_OR: |
796 | 36.7k | case WASM_INS_I32_XOR: |
797 | 37.5k | case WASM_INS_I32_SHL: |
798 | 38.1k | case WASM_INS_I32_SHR_S: |
799 | 38.5k | case WASM_INS_I32_SHR_U: |
800 | 38.9k | case WASM_INS_I32_ROTL: |
801 | 39.8k | case WASM_INS_I32_ROTR: |
802 | 40.3k | case WASM_INS_I64_CLZ: |
803 | 40.8k | case WASM_INS_I64_CTZ: |
804 | 42.3k | case WASM_INS_I64_POPCNT: |
805 | 42.9k | case WASM_INS_I64_ADD: |
806 | 43.5k | case WASM_INS_I64_SUB: |
807 | 44.5k | case WASM_INS_I64_MUL: |
808 | 45.3k | case WASM_INS_I64_DIV_S: |
809 | 46.7k | case WASM_INS_I64_DIV_U: |
810 | 47.1k | case WASM_INS_I64_REM_S: |
811 | 47.5k | case WASM_INS_I64_REM_U: |
812 | 47.9k | case WASM_INS_I64_AND: |
813 | 49.3k | case WASM_INS_I64_OR: |
814 | 49.7k | case WASM_INS_I64_XOR: |
815 | 50.7k | case WASM_INS_I64_SHL: |
816 | 51.4k | case WASM_INS_I64_SHR_S: |
817 | 53.6k | case WASM_INS_I64_SHR_U: |
818 | 54.8k | case WASM_INS_I64_ROTL: |
819 | 55.6k | case WASM_INS_I64_ROTR: |
820 | 56.5k | case WASM_INS_F32_ABS: |
821 | 56.8k | case WASM_INS_F32_NEG: |
822 | 57.5k | case WASM_INS_F32_CEIL: |
823 | 58.0k | case WASM_INS_F32_FLOOR: |
824 | 60.4k | case WASM_INS_F32_TRUNC: |
825 | 61.1k | case WASM_INS_F32_NEAREST: |
826 | 61.4k | case WASM_INS_F32_SQRT: |
827 | 62.1k | case WASM_INS_F32_ADD: |
828 | 62.5k | case WASM_INS_F32_SUB: |
829 | 63.0k | case WASM_INS_F32_MUL: |
830 | 63.7k | case WASM_INS_F32_DIV: |
831 | 64.2k | case WASM_INS_F32_MIN: |
832 | 64.5k | case WASM_INS_F32_MAX: |
833 | 64.7k | case WASM_INS_F32_COPYSIGN: |
834 | 65.3k | case WASM_INS_F64_ABS: |
835 | 65.7k | case WASM_INS_F64_NEG: |
836 | 66.2k | case WASM_INS_F64_CEIL: |
837 | 66.5k | case WASM_INS_F64_FLOOR: |
838 | 68.7k | case WASM_INS_F64_TRUNC: |
839 | 69.3k | case WASM_INS_F64_NEAREST: |
840 | 69.8k | case WASM_INS_F64_SQRT: |
841 | 70.4k | case WASM_INS_F64_ADD: |
842 | 71.4k | case WASM_INS_F64_SUB: |
843 | 71.8k | case WASM_INS_F64_MUL: |
844 | 72.1k | case WASM_INS_F64_DIV: |
845 | 72.7k | case WASM_INS_F64_MIN: |
846 | 73.2k | case WASM_INS_F64_MAX: |
847 | 74.1k | case WASM_INS_F64_COPYSIGN: |
848 | 74.6k | case WASM_INS_I32_WARP_I64: |
849 | 74.9k | case WASP_INS_I32_TRUNC_S_F32: |
850 | 75.6k | case WASM_INS_I32_TRUNC_U_F32: |
851 | 75.8k | case WASM_INS_I32_TRUNC_S_F64: |
852 | 76.4k | case WASM_INS_I32_TRUNC_U_F64: |
853 | 77.1k | case WASM_INS_I64_EXTEND_S_I32: |
854 | 77.7k | case WASM_INS_I64_EXTEND_U_I32: |
855 | 78.3k | case WASM_INS_I64_TRUNC_S_F32: |
856 | 78.6k | case WASM_INS_I64_TRUNC_U_F32: |
857 | 79.3k | case WASM_INS_I64_TRUNC_S_F64: |
858 | 80.1k | case WASM_INS_I64_TRUNC_U_F64: |
859 | 80.6k | case WASM_INS_F32_CONVERT_S_I32: |
860 | 80.9k | case WASM_INS_F32_CONVERT_U_I32: |
861 | 81.3k | case WASM_INS_F32_CONVERT_S_I64: |
862 | 82.9k | case WASM_INS_F32_CONVERT_U_I64: |
863 | 83.4k | case WASM_INS_F32_DEMOTE_F64: |
864 | 83.9k | case WASM_INS_F64_CONVERT_S_I32: |
865 | 84.4k | case WASM_INS_F64_CONVERT_U_I32: |
866 | 85.0k | case WASM_INS_F64_CONVERT_S_I64: |
867 | 85.3k | case WASM_INS_F64_CONVERT_U_I64: |
868 | 85.9k | case WASM_INS_F64_PROMOTE_F32: |
869 | 86.2k | case WASM_INS_I32_REINTERPRET_F32: |
870 | 86.7k | case WASM_INS_I64_REINTERPRET_F64: |
871 | 87.2k | case WASM_INS_F32_REINTERPRET_I32: |
872 | 87.4k | case WASM_INS_F64_REINTERPRET_I64: |
873 | 87.4k | MI->wasm_data.type = WASM_OP_NONE; |
874 | | |
875 | 87.4k | if (MI->flat_insn->detail) { |
876 | 87.4k | MI->flat_insn->detail->wasm.op_count = 0; |
877 | 87.4k | MI->flat_insn->detail |
878 | 87.4k | ->groups[MI->flat_insn->detail->groups_count] = |
879 | 87.4k | WASM_GRP_NUMBERIC; |
880 | 87.4k | MI->flat_insn->detail->groups_count++; |
881 | 87.4k | } |
882 | | |
883 | 87.4k | *size = 1; |
884 | | |
885 | 87.4k | break; |
886 | | |
887 | 311 | case WASM_INS_DROP: |
888 | 632 | case WASM_INS_SELECT: |
889 | 632 | MI->wasm_data.type = WASM_OP_NONE; |
890 | | |
891 | 632 | if (MI->flat_insn->detail) { |
892 | 632 | MI->flat_insn->detail->wasm.op_count = 0; |
893 | 632 | MI->flat_insn->detail |
894 | 632 | ->groups[MI->flat_insn->detail->groups_count] = |
895 | 632 | WASM_GRP_PARAMETRIC; |
896 | 632 | MI->flat_insn->detail->groups_count++; |
897 | 632 | } |
898 | | |
899 | 632 | *size = 1; |
900 | | |
901 | 632 | break; |
902 | | |
903 | 672 | case WASM_INS_GET_LOCAL: |
904 | 1.00k | case WASM_INS_SET_LOCAL: |
905 | 1.67k | case WASM_INS_TEE_LOCAL: |
906 | 2.04k | case WASM_INS_GET_GLOBAL: |
907 | 2.51k | case WASM_INS_SET_GLOBAL: |
908 | 2.51k | if (code_len == 1 || |
909 | 2.51k | !read_varuint32(&code[1], code_len - 1, ¶m_size, MI)) { |
910 | 58 | return false; |
911 | 58 | } |
912 | | |
913 | 2.45k | if (MI->flat_insn->detail) { |
914 | 2.45k | MI->flat_insn->detail->wasm.op_count = 1; |
915 | 2.45k | MI->flat_insn->detail |
916 | 2.45k | ->groups[MI->flat_insn->detail->groups_count] = |
917 | 2.45k | WASM_GRP_VARIABLE; |
918 | 2.45k | MI->flat_insn->detail->groups_count++; |
919 | 2.45k | } |
920 | | |
921 | 2.45k | *size = param_size + 1; |
922 | | |
923 | 2.45k | break; |
924 | | |
925 | 512 | case WASM_INS_I32_LOAD: |
926 | 1.64k | case WASM_INS_I64_LOAD: |
927 | 2.02k | case WASM_INS_F32_LOAD: |
928 | 2.53k | case WASM_INS_F64_LOAD: |
929 | 3.10k | case WASM_INS_I32_LOAD8_S: |
930 | 3.71k | case WASM_INS_I32_LOAD8_U: |
931 | 4.20k | case WASM_INS_I32_LOAD16_S: |
932 | 4.58k | case WASM_INS_I32_LOAD16_U: |
933 | 6.05k | case WASM_INS_I64_LOAD8_S: |
934 | 6.75k | case WASM_INS_I64_LOAD8_U: |
935 | 7.40k | case WASM_INS_I64_LOAD16_S: |
936 | 7.97k | case WASM_INS_I64_LOAD16_U: |
937 | 8.54k | case WASM_INS_I64_LOAD32_S: |
938 | 9.15k | case WASM_INS_I64_LOAD32_U: |
939 | 10.2k | case WASM_INS_I32_STORE: |
940 | 10.8k | case WASM_INS_I64_STORE: |
941 | 11.7k | case WASM_INS_F32_STORE: |
942 | 11.9k | case WASM_INS_F64_STORE: |
943 | 12.4k | case WASM_INS_I32_STORE8: |
944 | 13.0k | case WASM_INS_I32_STORE16: |
945 | 13.4k | case WASM_INS_I64_STORE8: |
946 | 14.2k | case WASM_INS_I64_STORE16: |
947 | 14.6k | case WASM_INS_I64_STORE32: |
948 | 14.6k | if (code_len == 1 || |
949 | 14.6k | !read_memoryimmediate(&code[1], code_len - 1, ¶m_size, |
950 | 14.4k | MI)) { |
951 | 279 | return false; |
952 | 279 | } |
953 | | |
954 | 14.3k | if (MI->flat_insn->detail) { |
955 | 14.3k | MI->flat_insn->detail->wasm.op_count = 2; |
956 | 14.3k | MI->flat_insn->detail |
957 | 14.3k | ->groups[MI->flat_insn->detail->groups_count] = |
958 | 14.3k | WASM_GRP_MEMORY; |
959 | 14.3k | MI->flat_insn->detail->groups_count++; |
960 | 14.3k | } |
961 | | |
962 | 14.3k | *size = param_size + 1; |
963 | | |
964 | 14.3k | break; |
965 | | |
966 | 369 | case WASM_INS_CURRENT_MEMORY: |
967 | 1.03k | case WASM_INS_GROW_MEMORY: |
968 | 1.03k | MI->wasm_data.type = WASM_OP_NONE; |
969 | | |
970 | 1.03k | if (MI->flat_insn->detail) { |
971 | 1.03k | MI->flat_insn->detail->wasm.op_count = 0; |
972 | 1.03k | MI->flat_insn->detail |
973 | 1.03k | ->groups[MI->flat_insn->detail->groups_count] = |
974 | 1.03k | WASM_GRP_MEMORY; |
975 | 1.03k | MI->flat_insn->detail->groups_count++; |
976 | 1.03k | } |
977 | | |
978 | 1.03k | *size = 1; |
979 | | |
980 | 1.03k | break; |
981 | | |
982 | 14.5k | case WASM_INS_UNREACHABLE: |
983 | 15.5k | case WASM_INS_NOP: |
984 | 16.1k | case WASM_INS_ELSE: |
985 | 16.7k | case WASM_INS_END: |
986 | 17.6k | case WASM_INS_RETURN: |
987 | 17.6k | MI->wasm_data.type = WASM_OP_NONE; |
988 | | |
989 | 17.6k | if (MI->flat_insn->detail) { |
990 | 17.6k | MI->flat_insn->detail->wasm.op_count = 0; |
991 | 17.6k | MI->flat_insn->detail |
992 | 17.6k | ->groups[MI->flat_insn->detail->groups_count] = |
993 | 17.6k | WASM_GRP_CONTROL; |
994 | 17.6k | MI->flat_insn->detail->groups_count++; |
995 | 17.6k | } |
996 | | |
997 | 17.6k | *size = 1; |
998 | | |
999 | 17.6k | break; |
1000 | | |
1001 | 630 | case WASM_INS_BLOCK: |
1002 | 1.85k | case WASM_INS_LOOP: |
1003 | 2.36k | case WASM_INS_IF: |
1004 | 2.36k | if (code_len == 1 || |
1005 | 2.36k | !read_varint7(&code[1], code_len - 1, ¶m_size, MI)) { |
1006 | 25 | return false; |
1007 | 25 | } |
1008 | | |
1009 | 2.33k | if (MI->flat_insn->detail) { |
1010 | 2.33k | MI->flat_insn->detail->wasm.op_count = 1; |
1011 | 2.33k | MI->flat_insn->detail |
1012 | 2.33k | ->groups[MI->flat_insn->detail->groups_count] = |
1013 | 2.33k | WASM_GRP_CONTROL; |
1014 | 2.33k | MI->flat_insn->detail->groups_count++; |
1015 | 2.33k | } |
1016 | | |
1017 | 2.33k | *size = param_size + 1; |
1018 | | |
1019 | 2.33k | break; |
1020 | | |
1021 | 818 | case WASM_INS_BR: |
1022 | 1.52k | case WASM_INS_BR_IF: |
1023 | 2.00k | case WASM_INS_CALL: |
1024 | 4.19k | case WASM_INS_CALL_INDIRECT: |
1025 | 4.19k | if (code_len == 1 || |
1026 | 4.19k | !read_varuint32(&code[1], code_len - 1, ¶m_size, MI)) { |
1027 | 51 | return false; |
1028 | 51 | } |
1029 | | |
1030 | 4.14k | if (MI->flat_insn->detail) { |
1031 | 4.14k | MI->flat_insn->detail->wasm.op_count = 1; |
1032 | 4.14k | MI->flat_insn->detail |
1033 | 4.14k | ->groups[MI->flat_insn->detail->groups_count] = |
1034 | 4.14k | WASM_GRP_CONTROL; |
1035 | 4.14k | MI->flat_insn->detail->groups_count++; |
1036 | 4.14k | } |
1037 | | |
1038 | 4.14k | *size = param_size + 1; |
1039 | | |
1040 | 4.14k | break; |
1041 | | |
1042 | 2.54k | case WASM_INS_BR_TABLE: |
1043 | 2.54k | if (code_len == 1 || |
1044 | 2.54k | !read_brtable(&code[1], code_len - 1, ¶m_size, MI)) { |
1045 | 167 | return false; |
1046 | 167 | } |
1047 | | |
1048 | 2.37k | if (MI->flat_insn->detail) { |
1049 | 2.37k | MI->flat_insn->detail->wasm.op_count = 1; |
1050 | 2.37k | MI->flat_insn->detail |
1051 | 2.37k | ->groups[MI->flat_insn->detail->groups_count] = |
1052 | 2.37k | WASM_GRP_CONTROL; |
1053 | 2.37k | MI->flat_insn->detail->groups_count++; |
1054 | 2.37k | } |
1055 | | |
1056 | 2.37k | *size = param_size + 1; |
1057 | | |
1058 | 2.37k | break; |
1059 | 135k | } |
1060 | | |
1061 | 135k | return true; |
1062 | 135k | } |