/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> // offsetof macro |
6 | | // alternatively #include "../../utils.h" like everyone else |
7 | | |
8 | | #include "WASMDisassembler.h" |
9 | | #include "WASMMapping.h" |
10 | | #include "../../cs_priv.h" |
11 | | |
12 | | static const short opcodes[256] = { |
13 | | WASM_INS_UNREACHABLE, |
14 | | WASM_INS_NOP, |
15 | | WASM_INS_BLOCK, |
16 | | WASM_INS_LOOP, |
17 | | WASM_INS_IF, |
18 | | WASM_INS_ELSE, |
19 | | -1, |
20 | | -1, |
21 | | -1, |
22 | | -1, |
23 | | -1, |
24 | | WASM_INS_END, |
25 | | WASM_INS_BR, |
26 | | WASM_INS_BR_IF, |
27 | | WASM_INS_BR_TABLE, |
28 | | WASM_INS_RETURN, |
29 | | WASM_INS_CALL, |
30 | | WASM_INS_CALL_INDIRECT, |
31 | | -1, |
32 | | -1, |
33 | | -1, |
34 | | -1, |
35 | | -1, |
36 | | -1, |
37 | | -1, |
38 | | -1, |
39 | | WASM_INS_DROP, |
40 | | WASM_INS_SELECT, |
41 | | -1, |
42 | | -1, |
43 | | -1, |
44 | | -1, |
45 | | WASM_INS_GET_LOCAL, |
46 | | WASM_INS_SET_LOCAL, |
47 | | WASM_INS_TEE_LOCAL, |
48 | | WASM_INS_GET_GLOBAL, |
49 | | WASM_INS_SET_GLOBAL, |
50 | | -1, |
51 | | -1, |
52 | | -1, |
53 | | WASM_INS_I32_LOAD, |
54 | | WASM_INS_I64_LOAD, |
55 | | WASM_INS_F32_LOAD, |
56 | | WASM_INS_F64_LOAD, |
57 | | WASM_INS_I32_LOAD8_S, |
58 | | WASM_INS_I32_LOAD8_U, |
59 | | WASM_INS_I32_LOAD16_S, |
60 | | WASM_INS_I32_LOAD16_U, |
61 | | WASM_INS_I64_LOAD8_S, |
62 | | WASM_INS_I64_LOAD8_U, |
63 | | WASM_INS_I64_LOAD16_S, |
64 | | WASM_INS_I64_LOAD16_U, |
65 | | WASM_INS_I64_LOAD32_S, |
66 | | WASM_INS_I64_LOAD32_U, |
67 | | WASM_INS_I32_STORE, |
68 | | WASM_INS_I64_STORE, |
69 | | WASM_INS_F32_STORE, |
70 | | WASM_INS_F64_STORE, |
71 | | WASM_INS_I32_STORE8, |
72 | | WASM_INS_I32_STORE16, |
73 | | WASM_INS_I64_STORE8, |
74 | | WASM_INS_I64_STORE16, |
75 | | WASM_INS_I64_STORE32, |
76 | | WASM_INS_CURRENT_MEMORY, |
77 | | WASM_INS_GROW_MEMORY, |
78 | | WASM_INS_I32_CONST, |
79 | | WASM_INS_I64_CONST, |
80 | | WASM_INS_F32_CONST, |
81 | | WASM_INS_F64_CONST, |
82 | | WASM_INS_I32_EQZ, |
83 | | WASM_INS_I32_EQ, |
84 | | WASM_INS_I32_NE, |
85 | | WASM_INS_I32_LT_S, |
86 | | WASM_INS_I32_LT_U, |
87 | | WASM_INS_I32_GT_S, |
88 | | WASM_INS_I32_GT_U, |
89 | | WASM_INS_I32_LE_S, |
90 | | WASM_INS_I32_LE_U, |
91 | | WASM_INS_I32_GE_S, |
92 | | WASM_INS_I32_GE_U, |
93 | | WASM_INS_I64_EQZ, |
94 | | WASM_INS_I64_EQ, |
95 | | WASM_INS_I64_NE, |
96 | | WASM_INS_I64_LT_S, |
97 | | WASM_INS_I64_LT_U, |
98 | | WASN_INS_I64_GT_S, |
99 | | WASM_INS_I64_GT_U, |
100 | | WASM_INS_I64_LE_S, |
101 | | WASM_INS_I64_LE_U, |
102 | | WASM_INS_I64_GE_S, |
103 | | WASM_INS_I64_GE_U, |
104 | | WASM_INS_F32_EQ, |
105 | | WASM_INS_F32_NE, |
106 | | WASM_INS_F32_LT, |
107 | | WASM_INS_F32_GT, |
108 | | WASM_INS_F32_LE, |
109 | | WASM_INS_F32_GE, |
110 | | WASM_INS_F64_EQ, |
111 | | WASM_INS_F64_NE, |
112 | | WASM_INS_F64_LT, |
113 | | WASM_INS_F64_GT, |
114 | | WASM_INS_F64_LE, |
115 | | WASM_INS_F64_GE, |
116 | | WASM_INS_I32_CLZ, |
117 | | WASM_INS_I32_CTZ, |
118 | | WASM_INS_I32_POPCNT, |
119 | | WASM_INS_I32_ADD, |
120 | | WASM_INS_I32_SUB, |
121 | | WASM_INS_I32_MUL, |
122 | | WASM_INS_I32_DIV_S, |
123 | | WASM_INS_I32_DIV_U, |
124 | | WASM_INS_I32_REM_S, |
125 | | WASM_INS_I32_REM_U, |
126 | | WASM_INS_I32_AND, |
127 | | WASM_INS_I32_OR, |
128 | | WASM_INS_I32_XOR, |
129 | | WASM_INS_I32_SHL, |
130 | | WASM_INS_I32_SHR_S, |
131 | | WASM_INS_I32_SHR_U, |
132 | | WASM_INS_I32_ROTL, |
133 | | WASM_INS_I32_ROTR, |
134 | | WASM_INS_I64_CLZ, |
135 | | WASM_INS_I64_CTZ, |
136 | | WASM_INS_I64_POPCNT, |
137 | | WASM_INS_I64_ADD, |
138 | | WASM_INS_I64_SUB, |
139 | | WASM_INS_I64_MUL, |
140 | | WASM_INS_I64_DIV_S, |
141 | | WASM_INS_I64_DIV_U, |
142 | | WASM_INS_I64_REM_S, |
143 | | WASM_INS_I64_REM_U, |
144 | | WASM_INS_I64_AND, |
145 | | WASM_INS_I64_OR, |
146 | | WASM_INS_I64_XOR, |
147 | | WASM_INS_I64_SHL, |
148 | | WASM_INS_I64_SHR_S, |
149 | | WASM_INS_I64_SHR_U, |
150 | | WASM_INS_I64_ROTL, |
151 | | WASM_INS_I64_ROTR, |
152 | | WASM_INS_F32_ABS, |
153 | | WASM_INS_F32_NEG, |
154 | | WASM_INS_F32_CEIL, |
155 | | WASM_INS_F32_FLOOR, |
156 | | WASM_INS_F32_TRUNC, |
157 | | WASM_INS_F32_NEAREST, |
158 | | WASM_INS_F32_SQRT, |
159 | | WASM_INS_F32_ADD, |
160 | | WASM_INS_F32_SUB, |
161 | | WASM_INS_F32_MUL, |
162 | | WASM_INS_F32_DIV, |
163 | | WASM_INS_F32_MIN, |
164 | | WASM_INS_F32_MAX, |
165 | | WASM_INS_F32_COPYSIGN, |
166 | | WASM_INS_F64_ABS, |
167 | | WASM_INS_F64_NEG, |
168 | | WASM_INS_F64_CEIL, |
169 | | WASM_INS_F64_FLOOR, |
170 | | WASM_INS_F64_TRUNC, |
171 | | WASM_INS_F64_NEAREST, |
172 | | WASM_INS_F64_SQRT, |
173 | | WASM_INS_F64_ADD, |
174 | | WASM_INS_F64_SUB, |
175 | | WASM_INS_F64_MUL, |
176 | | WASM_INS_F64_DIV, |
177 | | WASM_INS_F64_MIN, |
178 | | WASM_INS_F64_MAX, |
179 | | WASM_INS_F64_COPYSIGN, |
180 | | WASM_INS_I32_WARP_I64, |
181 | | WASP_INS_I32_TRUNC_S_F32, |
182 | | WASM_INS_I32_TRUNC_U_F32, |
183 | | WASM_INS_I32_TRUNC_S_F64, |
184 | | WASM_INS_I32_TRUNC_U_F64, |
185 | | WASM_INS_I64_EXTEND_S_I32, |
186 | | WASM_INS_I64_EXTEND_U_I32, |
187 | | WASM_INS_I64_TRUNC_S_F32, |
188 | | WASM_INS_I64_TRUNC_U_F32, |
189 | | WASM_INS_I64_TRUNC_S_F64, |
190 | | WASM_INS_I64_TRUNC_U_F64, |
191 | | WASM_INS_F32_CONVERT_S_I32, |
192 | | WASM_INS_F32_CONVERT_U_I32, |
193 | | WASM_INS_F32_CONVERT_S_I64, |
194 | | WASM_INS_F32_CONVERT_U_I64, |
195 | | WASM_INS_F32_DEMOTE_F64, |
196 | | WASM_INS_F64_CONVERT_S_I32, |
197 | | WASM_INS_F64_CONVERT_U_I32, |
198 | | WASM_INS_F64_CONVERT_S_I64, |
199 | | WASM_INS_F64_CONVERT_U_I64, |
200 | | WASM_INS_F64_PROMOTE_F32, |
201 | | WASM_INS_I32_REINTERPRET_F32, |
202 | | WASM_INS_I64_REINTERPRET_F64, |
203 | | WASM_INS_F32_REINTERPRET_I32, |
204 | | WASM_INS_F64_REINTERPRET_I64, |
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 | | -1, |
269 | | }; |
270 | | |
271 | | // input | code: code pointer start from varuint32 |
272 | | // | code_len: real code len count from varint |
273 | | // | leng: return value, means length of varint. -1 means error |
274 | | // return | varint |
275 | | static uint32_t get_varuint32(const uint8_t *code, size_t code_len, size_t *leng) |
276 | 63.2k | { |
277 | 63.2k | uint32_t data = 0; |
278 | 63.2k | int i; |
279 | | |
280 | 77.7k | for(i = 0;; i++) { |
281 | 77.7k | if (code_len < i + 1) { |
282 | 356 | *leng = -1; |
283 | 356 | return 0; |
284 | 356 | } |
285 | | |
286 | | |
287 | 77.3k | if (i > 4 || (i == 4 && (code[i] & 0x7f) > 0x0f)) { |
288 | 582 | *leng = -1; |
289 | 582 | return 0; |
290 | 582 | } |
291 | | |
292 | 76.8k | data = data + (((uint32_t) code[i] & 0x7f) << (i * 7)); |
293 | 76.8k | if (code[i] >> 7 == 0) { |
294 | 62.3k | break; |
295 | 62.3k | } |
296 | 76.8k | } |
297 | | |
298 | 62.3k | *leng = i + 1; |
299 | | |
300 | 62.3k | return data; |
301 | 63.2k | } |
302 | | |
303 | | // input | code : code pointer start from varuint64 |
304 | | // | code_len : real code len count from varint |
305 | | // | leng: return value, means length of varint. -1 means error |
306 | | // return | varint |
307 | | static uint64_t get_varuint64(const uint8_t *code, size_t code_len, size_t *leng) |
308 | 1.93k | { |
309 | 1.93k | uint64_t data; |
310 | 1.93k | int i; |
311 | | |
312 | 1.93k | data = 0; |
313 | 4.04k | for(i = 0;; i++){ |
314 | 4.04k | if (code_len < i + 1) { |
315 | 9 | *leng = -1; |
316 | 9 | return 0; |
317 | 9 | } |
318 | | |
319 | 4.03k | if (i > 9 || (i == 9 && (code[i] & 0x7f) > 0x01)) { |
320 | 3 | *leng = -1; |
321 | 3 | return 0; |
322 | 3 | } |
323 | | |
324 | 4.03k | data = data + (((uint64_t) code[i] & 0x7f) << (i * 7)); |
325 | 4.03k | if (code[i] >> 7 == 0) { |
326 | 1.91k | break; |
327 | 1.91k | } |
328 | 4.03k | } |
329 | | |
330 | 1.91k | *leng = i + 1; |
331 | | |
332 | 1.91k | return data; |
333 | 1.93k | } |
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 | 806 | { |
340 | 806 | memcpy(dest, code, 4); |
341 | 806 | } |
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 | 1.01k | { |
348 | 1.01k | memcpy(dest, code, 8); |
349 | 1.01k | } |
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 | 3.40k | { |
357 | 3.40k | int8_t data; |
358 | | |
359 | 3.40k | if (code_len < 1) { |
360 | 0 | *leng = -1; |
361 | 0 | return -1; |
362 | 0 | } |
363 | | |
364 | 3.40k | *leng = 1; |
365 | | |
366 | 3.40k | if (code[0] == 0x40) { |
367 | 118 | return -1; |
368 | 118 | } |
369 | | |
370 | 3.28k | data = code[0] & 0x7f; |
371 | | |
372 | 3.28k | return data; |
373 | 3.40k | } |
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, uint16_t *param_size, MCInst *MI) |
381 | 6.66k | { |
382 | 6.66k | size_t len = 0; |
383 | 6.66k | uint32_t data; |
384 | | |
385 | 6.66k | data = get_varuint32(code, code_len, &len); |
386 | 6.66k | if (len == -1) { |
387 | 47 | return false; |
388 | 47 | } |
389 | | |
390 | 6.61k | if (MI->flat_insn->detail) { |
391 | 6.61k | MI->flat_insn->detail->wasm.op_count = 1; |
392 | 6.61k | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_VARUINT32; |
393 | 6.61k | MI->flat_insn->detail->wasm.operands[0].size= len; |
394 | 6.61k | MI->flat_insn->detail->wasm.operands[0].varuint32= data; |
395 | 6.61k | } |
396 | | |
397 | 6.61k | MI->wasm_data.size = len; |
398 | 6.61k | MI->wasm_data.type = WASM_OP_VARUINT32; |
399 | 6.61k | MI->wasm_data.uint32 = data; |
400 | 6.61k | *param_size = len; |
401 | | |
402 | 6.61k | return true; |
403 | 6.66k | } |
404 | | |
405 | | // input | code : code pointer start from varuint64 |
406 | | // | code_len : start from the code pointer to the end, how long is it |
407 | | // | param_size : pointer of the param size |
408 | | // | MI : Mcinst handler in this round of disasm |
409 | | // return | true/false if the function successfully finished |
410 | | static bool read_varuint64(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) |
411 | 1.93k | { |
412 | 1.93k | size_t len = 0; |
413 | 1.93k | uint64_t data; |
414 | | |
415 | 1.93k | data = get_varuint64(code, code_len, &len); |
416 | 1.93k | if (len == -1) { |
417 | 12 | return false; |
418 | 12 | } |
419 | | |
420 | 1.91k | if (MI->flat_insn->detail) { |
421 | 1.91k | MI->flat_insn->detail->wasm.op_count = 1; |
422 | 1.91k | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_VARUINT64; |
423 | 1.91k | MI->flat_insn->detail->wasm.operands[0].size = len; |
424 | 1.91k | MI->flat_insn->detail->wasm.operands[0].varuint64 = data; |
425 | 1.91k | } |
426 | | |
427 | 1.91k | MI->wasm_data.size = len; |
428 | 1.91k | MI->wasm_data.type = WASM_OP_VARUINT64; |
429 | 1.91k | MI->wasm_data.uint64 = data; |
430 | 1.91k | *param_size = len; |
431 | | |
432 | 1.91k | return true; |
433 | 1.93k | } |
434 | | |
435 | | // input | code : code pointer start from memoryimmediate |
436 | | // | code_len : start from the code pointer to the end, how long is it |
437 | | // | param_size : pointer of the param size (sum of two params) |
438 | | // | MI : Mcinst handler in this round of disasm |
439 | | // return | true/false if the function successfully finished |
440 | | static bool read_memoryimmediate(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) |
441 | 15.7k | { |
442 | 15.7k | size_t tmp, len = 0; |
443 | 15.7k | uint32_t data[2]; |
444 | | |
445 | 15.7k | if (MI->flat_insn->detail) { |
446 | 15.7k | MI->flat_insn->detail->wasm.op_count = 2; |
447 | 15.7k | } |
448 | | |
449 | 15.7k | data[0] = get_varuint32(code, code_len, &tmp); |
450 | 15.7k | if (tmp == -1) { |
451 | 98 | return false; |
452 | 98 | } |
453 | | |
454 | 15.6k | if (MI->flat_insn->detail) { |
455 | 15.6k | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_VARUINT32; |
456 | 15.6k | MI->flat_insn->detail->wasm.operands[0].size = tmp; |
457 | 15.6k | MI->flat_insn->detail->wasm.operands[0].varuint32 = data[0]; |
458 | 15.6k | } |
459 | | |
460 | 15.6k | len = tmp; |
461 | 15.6k | data[1] = get_varuint32(&code[len], code_len - len, &tmp); |
462 | 15.6k | if (len == -1) { |
463 | 0 | return false; |
464 | 0 | } |
465 | | |
466 | 15.6k | if (MI->flat_insn->detail) { |
467 | 15.6k | MI->flat_insn->detail->wasm.operands[1].type = WASM_OP_VARUINT32; |
468 | 15.6k | MI->flat_insn->detail->wasm.operands[1].size = tmp; |
469 | 15.6k | MI->flat_insn->detail->wasm.operands[1].varuint32 = data[1]; |
470 | 15.6k | } |
471 | | |
472 | 15.6k | len += tmp; |
473 | 15.6k | MI->wasm_data.size = len; |
474 | 15.6k | MI->wasm_data.type = WASM_OP_IMM; |
475 | 15.6k | MI->wasm_data.immediate[0] = data[0]; |
476 | 15.6k | MI->wasm_data.immediate[1] = data[1]; |
477 | 15.6k | *param_size = len; |
478 | | |
479 | 15.6k | return true; |
480 | 15.6k | } |
481 | | |
482 | | // input | code : code pointer start from uint32 |
483 | | // | code_len : start from the code pointer to the end, how long is it |
484 | | // | param_size : pointer of the param size |
485 | | // | MI : Mcinst handler in this round of disasm |
486 | | // return | true/false if the function successfully finished |
487 | | static bool read_uint32(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) |
488 | 412 | { |
489 | 412 | if (code_len < 4) { |
490 | 9 | return false; |
491 | 9 | } |
492 | | |
493 | 403 | get_uint32(code, &(MI->wasm_data.uint32)); |
494 | | |
495 | 403 | if (MI->flat_insn->detail) { |
496 | 403 | MI->flat_insn->detail->wasm.op_count = 1; |
497 | 403 | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_UINT32; |
498 | 403 | MI->flat_insn->detail->wasm.operands[0].size = 4; |
499 | 403 | get_uint32(code, &(MI->flat_insn->detail->wasm.operands[0].uint32)); |
500 | 403 | } |
501 | | |
502 | 403 | MI->wasm_data.size = 4; |
503 | 403 | MI->wasm_data.type = WASM_OP_UINT32; |
504 | 403 | *param_size = 4; |
505 | | |
506 | 403 | return true; |
507 | 412 | } |
508 | | |
509 | | // input | code : code pointer start from uint64 |
510 | | // | code_len : start from the code pointer to the end, how long is it |
511 | | // | param_size : pointer of the param size |
512 | | // | MI : Mcinst handler in this round of disasm |
513 | | // return | true/false if the function successfully finished |
514 | | static bool read_uint64(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) |
515 | 518 | { |
516 | 518 | if (code_len < 8) { |
517 | 10 | return false; |
518 | 10 | } |
519 | | |
520 | 508 | get_uint64(code, &(MI->wasm_data.uint64)); |
521 | | |
522 | 508 | if (MI->flat_insn->detail) { |
523 | 508 | MI->flat_insn->detail->wasm.op_count = 1; |
524 | 508 | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_UINT64; |
525 | 508 | MI->flat_insn->detail->wasm.operands[0].size = 8; |
526 | 508 | get_uint64(code, &(MI->flat_insn->detail->wasm.operands[0].uint64)); |
527 | 508 | } |
528 | | |
529 | 508 | MI->wasm_data.size = 8; |
530 | 508 | MI->wasm_data.type = WASM_OP_UINT64; |
531 | 508 | *param_size = 8; |
532 | | |
533 | 508 | return true; |
534 | 518 | } |
535 | | |
536 | | // input | code : code pointer start from brtable |
537 | | // | code_len : start from the code pointer to the end, how long is it |
538 | | // | param_size : pointer of the param size (sum of all param) |
539 | | // | MI : Mcinst handler in this round of disasm |
540 | | // return | true/false if the function successfully finished |
541 | | static bool read_brtable(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) |
542 | 2.34k | { |
543 | 2.34k | uint32_t length, default_target; |
544 | 2.34k | int tmp_len = 0, i; |
545 | 2.34k | size_t var_len; |
546 | | |
547 | | // read length |
548 | 2.34k | length = get_varuint32(code, code_len, &var_len); |
549 | 2.34k | if (var_len == -1) { |
550 | 14 | return false; |
551 | 14 | } |
552 | | |
553 | 2.33k | tmp_len += var_len; |
554 | 2.33k | MI->wasm_data.brtable.length = length; |
555 | 2.33k | if (length >= UINT32_MAX - tmp_len) { |
556 | | // integer overflow check |
557 | 1 | return false; |
558 | 1 | } |
559 | 2.33k | if (code_len < tmp_len + length) { |
560 | | // safety check that we have minimum enough data to read |
561 | 89 | return false; |
562 | 89 | } |
563 | | // base address + 1 byte opcode + tmp_len for number of cases = start of targets |
564 | 2.24k | MI->wasm_data.brtable.address = MI->address + 1 + tmp_len; |
565 | | |
566 | 2.24k | if (MI->flat_insn->detail) { |
567 | 2.24k | MI->flat_insn->detail->wasm.op_count = 1; |
568 | 2.24k | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_BRTABLE; |
569 | 2.24k | MI->flat_insn->detail->wasm.operands[0].brtable.length = MI->wasm_data.brtable.length; |
570 | 2.24k | MI->flat_insn->detail->wasm.operands[0].brtable.address = MI->wasm_data.brtable.address; |
571 | 2.24k | } |
572 | | |
573 | | // read data |
574 | 22.7k | for(i = 0; i < length; i++){ |
575 | 20.5k | if (code_len < tmp_len) { |
576 | 0 | return false; |
577 | 0 | } |
578 | | |
579 | 20.5k | get_varuint32(code + tmp_len, code_len - tmp_len, &var_len); |
580 | 20.5k | if (var_len == -1) { |
581 | 33 | return false; |
582 | 33 | } |
583 | | |
584 | 20.4k | tmp_len += var_len; |
585 | 20.4k | } |
586 | | |
587 | | // read default target |
588 | 2.21k | default_target = get_varuint32(code + tmp_len, code_len - tmp_len, &var_len); |
589 | 2.21k | if (var_len == -1) { |
590 | 30 | return false; |
591 | 30 | } |
592 | | |
593 | 2.18k | MI->wasm_data.brtable.default_target = default_target; |
594 | 2.18k | MI->wasm_data.type = WASM_OP_BRTABLE; |
595 | 2.18k | *param_size = tmp_len + var_len; |
596 | | |
597 | 2.18k | if (MI->flat_insn->detail) { |
598 | 2.18k | MI->flat_insn->detail->wasm.operands[0].size = *param_size; |
599 | 2.18k | MI->flat_insn->detail->wasm.operands[0].brtable.default_target = MI->wasm_data.brtable.default_target; |
600 | 2.18k | } |
601 | | |
602 | 2.18k | return true; |
603 | 2.21k | } |
604 | | |
605 | | // input | code : code pointer start from varint7 |
606 | | // | code_len : start from the code pointer to the end, how long is it |
607 | | // | param_size : pointer of the param size |
608 | | // | MI : Mcinst handler in this round of disasm |
609 | | // return | true/false if the function successfully finished |
610 | | static bool read_varint7(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) |
611 | 3.40k | { |
612 | 3.40k | size_t len = 0; |
613 | | |
614 | 3.40k | MI->wasm_data.type = WASM_OP_INT7; |
615 | 3.40k | MI->wasm_data.int7 = get_varint7(code, code_len, &len); |
616 | 3.40k | if (len == -1) { |
617 | 0 | return false; |
618 | 0 | } |
619 | | |
620 | 3.40k | if (MI->flat_insn->detail) { |
621 | 3.40k | MI->flat_insn->detail->wasm.op_count = 1; |
622 | 3.40k | MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_INT7; |
623 | 3.40k | MI->flat_insn->detail->wasm.operands[0].size = 1; |
624 | 3.40k | MI->flat_insn->detail->wasm.operands[0].int7 = MI->wasm_data.int7; |
625 | 3.40k | } |
626 | | |
627 | 3.40k | *param_size = len; |
628 | | |
629 | 3.40k | return true; |
630 | 3.40k | } |
631 | | |
632 | | bool WASM_getInstruction(csh ud, const uint8_t *code, size_t code_len, |
633 | | MCInst *MI, uint16_t *size, uint64_t address, void *inst_info) |
634 | 177k | { |
635 | 177k | unsigned char opcode; |
636 | 177k | uint16_t param_size; |
637 | | |
638 | 177k | if (code_len == 0) |
639 | 0 | return false; |
640 | | |
641 | 177k | opcode = code[0]; |
642 | 177k | if (opcodes[opcode] == -1) { |
643 | | // invalid opcode |
644 | 557 | return false; |
645 | 557 | } |
646 | | |
647 | | // valid opcode |
648 | 177k | MI->address = address; |
649 | 177k | MI->OpcodePub = MI->Opcode = opcode; |
650 | | |
651 | 177k | if (MI->flat_insn->detail) { |
652 | 177k | memset(MI->flat_insn->detail, 0, offsetof(cs_detail, wasm)+sizeof(cs_wasm)); |
653 | 177k | WASM_get_insn_id((cs_struct *)ud, MI->flat_insn, opcode); |
654 | 177k | } |
655 | | |
656 | | // setup groups |
657 | 177k | switch(opcode) { |
658 | 0 | default: |
659 | 0 | return false; |
660 | | |
661 | 638 | case WASM_INS_I32_CONST: |
662 | 638 | if (code_len == 1 || !read_varuint32(&code[1], code_len - 1, ¶m_size, MI)) { |
663 | 15 | return false; |
664 | 15 | } |
665 | | |
666 | 623 | if (MI->flat_insn->detail) { |
667 | 623 | MI->flat_insn->detail->wasm.op_count = 1; |
668 | 623 | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_NUMBERIC; |
669 | 623 | MI->flat_insn->detail->groups_count++; |
670 | 623 | } |
671 | | |
672 | 623 | *size = param_size + 1; |
673 | | |
674 | 623 | break; |
675 | | |
676 | 1.94k | case WASM_INS_I64_CONST: |
677 | 1.94k | if (code_len == 1 || !read_varuint64(&code[1], code_len - 1, ¶m_size, MI)) { |
678 | 22 | return false; |
679 | 22 | } |
680 | | |
681 | 1.91k | if (MI->flat_insn->detail) { |
682 | 1.91k | MI->flat_insn->detail->wasm.op_count = 1; |
683 | 1.91k | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_NUMBERIC; |
684 | 1.91k | MI->flat_insn->detail->groups_count++; |
685 | 1.91k | } |
686 | | |
687 | 1.91k | *size = param_size + 1; |
688 | | |
689 | 1.91k | break; |
690 | | |
691 | 418 | case WASM_INS_F32_CONST: |
692 | 418 | if (code_len == 1 || !read_uint32(&code[1], code_len - 1, ¶m_size, MI)) { |
693 | 15 | return false; |
694 | 15 | } |
695 | | |
696 | 403 | if (MI->flat_insn->detail) { |
697 | 403 | MI->flat_insn->detail->wasm.op_count = 1; |
698 | 403 | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_NUMBERIC; |
699 | 403 | MI->flat_insn->detail->groups_count++; |
700 | 403 | } |
701 | | |
702 | 403 | *size = param_size + 1; |
703 | | |
704 | 403 | break; |
705 | | |
706 | 523 | case WASM_INS_F64_CONST: |
707 | 523 | if (code_len == 1 || !read_uint64(&code[1], code_len - 1, ¶m_size, MI)) { |
708 | 15 | return false; |
709 | 15 | } |
710 | | |
711 | 508 | if (MI->flat_insn->detail) { |
712 | 508 | MI->flat_insn->detail->wasm.op_count = 1; |
713 | 508 | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_NUMBERIC; |
714 | 508 | MI->flat_insn->detail->groups_count++; |
715 | 508 | } |
716 | | |
717 | 508 | *size = param_size + 1; |
718 | | |
719 | 508 | break; |
720 | | |
721 | 1.12k | case WASM_INS_I32_EQZ: |
722 | 2.20k | case WASM_INS_I32_EQ: |
723 | 2.74k | case WASM_INS_I32_NE: |
724 | 3.20k | case WASM_INS_I32_LT_S: |
725 | 4.00k | case WASM_INS_I32_LT_U: |
726 | 5.24k | case WASM_INS_I32_GT_S: |
727 | 5.70k | case WASM_INS_I32_GT_U: |
728 | 6.50k | case WASM_INS_I32_LE_S: |
729 | 8.00k | case WASM_INS_I32_LE_U: |
730 | 8.68k | case WASM_INS_I32_GE_S: |
731 | 10.1k | case WASM_INS_I32_GE_U: |
732 | 10.6k | case WASM_INS_I64_EQZ: |
733 | 11.2k | case WASM_INS_I64_EQ: |
734 | 12.0k | case WASM_INS_I64_NE: |
735 | 13.2k | case WASM_INS_I64_LT_S: |
736 | 13.6k | case WASM_INS_I64_LT_U: |
737 | 14.2k | case WASN_INS_I64_GT_S: |
738 | 14.7k | case WASM_INS_I64_GT_U: |
739 | 15.3k | case WASM_INS_I64_LE_S: |
740 | 16.0k | case WASM_INS_I64_LE_U: |
741 | 16.4k | case WASM_INS_I64_GE_S: |
742 | 18.6k | case WASM_INS_I64_GE_U: |
743 | 20.6k | case WASM_INS_F32_EQ: |
744 | 21.2k | case WASM_INS_F32_NE: |
745 | 21.7k | case WASM_INS_F32_LT: |
746 | 22.4k | case WASM_INS_F32_GT: |
747 | 23.5k | case WASM_INS_F32_LE: |
748 | 24.4k | case WASM_INS_F32_GE: |
749 | 27.3k | case WASM_INS_F64_EQ: |
750 | 28.3k | case WASM_INS_F64_NE: |
751 | 29.9k | case WASM_INS_F64_LT: |
752 | 31.1k | case WASM_INS_F64_GT: |
753 | 31.8k | case WASM_INS_F64_LE: |
754 | 32.6k | case WASM_INS_F64_GE: |
755 | 33.7k | case WASM_INS_I32_CLZ: |
756 | 34.7k | case WASM_INS_I32_CTZ: |
757 | 35.6k | case WASM_INS_I32_POPCNT: |
758 | 36.4k | case WASM_INS_I32_ADD: |
759 | 36.7k | case WASM_INS_I32_SUB: |
760 | 37.4k | case WASM_INS_I32_MUL: |
761 | 38.1k | case WASM_INS_I32_DIV_S: |
762 | 39.2k | case WASM_INS_I32_DIV_U: |
763 | 40.1k | case WASM_INS_I32_REM_S: |
764 | 40.9k | case WASM_INS_I32_REM_U: |
765 | 41.7k | case WASM_INS_I32_AND: |
766 | 42.8k | case WASM_INS_I32_OR: |
767 | 44.0k | case WASM_INS_I32_XOR: |
768 | 45.0k | case WASM_INS_I32_SHL: |
769 | 45.6k | case WASM_INS_I32_SHR_S: |
770 | 47.2k | case WASM_INS_I32_SHR_U: |
771 | 48.1k | case WASM_INS_I32_ROTL: |
772 | 49.3k | case WASM_INS_I32_ROTR: |
773 | 50.8k | case WASM_INS_I64_CLZ: |
774 | 51.9k | case WASM_INS_I64_CTZ: |
775 | 52.8k | case WASM_INS_I64_POPCNT: |
776 | 54.0k | case WASM_INS_I64_ADD: |
777 | 55.0k | case WASM_INS_I64_SUB: |
778 | 55.8k | case WASM_INS_I64_MUL: |
779 | 57.6k | case WASM_INS_I64_DIV_S: |
780 | 59.3k | case WASM_INS_I64_DIV_U: |
781 | 60.0k | case WASM_INS_I64_REM_S: |
782 | 60.4k | case WASM_INS_I64_REM_U: |
783 | 61.2k | case WASM_INS_I64_AND: |
784 | 61.7k | case WASM_INS_I64_OR: |
785 | 62.5k | case WASM_INS_I64_XOR: |
786 | 64.0k | case WASM_INS_I64_SHL: |
787 | 64.5k | case WASM_INS_I64_SHR_S: |
788 | 65.5k | case WASM_INS_I64_SHR_U: |
789 | 66.0k | case WASM_INS_I64_ROTL: |
790 | 67.5k | case WASM_INS_I64_ROTR: |
791 | 68.3k | case WASM_INS_F32_ABS: |
792 | 70.1k | case WASM_INS_F32_NEG: |
793 | 71.5k | case WASM_INS_F32_CEIL: |
794 | 72.2k | case WASM_INS_F32_FLOOR: |
795 | 72.7k | case WASM_INS_F32_TRUNC: |
796 | 73.2k | case WASM_INS_F32_NEAREST: |
797 | 73.6k | case WASM_INS_F32_SQRT: |
798 | 74.3k | case WASM_INS_F32_ADD: |
799 | 75.3k | case WASM_INS_F32_SUB: |
800 | 76.0k | case WASM_INS_F32_MUL: |
801 | 76.5k | case WASM_INS_F32_DIV: |
802 | 77.2k | case WASM_INS_F32_MIN: |
803 | 77.8k | case WASM_INS_F32_MAX: |
804 | 78.3k | case WASM_INS_F32_COPYSIGN: |
805 | 79.4k | case WASM_INS_F64_ABS: |
806 | 80.2k | case WASM_INS_F64_NEG: |
807 | 80.9k | case WASM_INS_F64_CEIL: |
808 | 81.8k | case WASM_INS_F64_FLOOR: |
809 | 82.4k | case WASM_INS_F64_TRUNC: |
810 | 83.8k | case WASM_INS_F64_NEAREST: |
811 | 85.1k | case WASM_INS_F64_SQRT: |
812 | 85.5k | case WASM_INS_F64_ADD: |
813 | 86.4k | case WASM_INS_F64_SUB: |
814 | 87.3k | case WASM_INS_F64_MUL: |
815 | 87.9k | case WASM_INS_F64_DIV: |
816 | 89.0k | case WASM_INS_F64_MIN: |
817 | 89.8k | case WASM_INS_F64_MAX: |
818 | 90.3k | case WASM_INS_F64_COPYSIGN: |
819 | 90.7k | case WASM_INS_I32_WARP_I64: |
820 | 91.4k | case WASP_INS_I32_TRUNC_S_F32: |
821 | 91.8k | case WASM_INS_I32_TRUNC_U_F32: |
822 | 92.7k | case WASM_INS_I32_TRUNC_S_F64: |
823 | 93.2k | case WASM_INS_I32_TRUNC_U_F64: |
824 | 93.7k | case WASM_INS_I64_EXTEND_S_I32: |
825 | 96.4k | case WASM_INS_I64_EXTEND_U_I32: |
826 | 97.1k | case WASM_INS_I64_TRUNC_S_F32: |
827 | 98.0k | case WASM_INS_I64_TRUNC_U_F32: |
828 | 98.6k | case WASM_INS_I64_TRUNC_S_F64: |
829 | 99.5k | case WASM_INS_I64_TRUNC_U_F64: |
830 | 100k | case WASM_INS_F32_CONVERT_S_I32: |
831 | 102k | case WASM_INS_F32_CONVERT_U_I32: |
832 | 103k | case WASM_INS_F32_CONVERT_S_I64: |
833 | 103k | case WASM_INS_F32_CONVERT_U_I64: |
834 | 104k | case WASM_INS_F32_DEMOTE_F64: |
835 | 105k | case WASM_INS_F64_CONVERT_S_I32: |
836 | 105k | case WASM_INS_F64_CONVERT_U_I32: |
837 | 106k | case WASM_INS_F64_CONVERT_S_I64: |
838 | 111k | case WASM_INS_F64_CONVERT_U_I64: |
839 | 111k | case WASM_INS_F64_PROMOTE_F32: |
840 | 112k | case WASM_INS_I32_REINTERPRET_F32: |
841 | 113k | case WASM_INS_I64_REINTERPRET_F64: |
842 | 114k | case WASM_INS_F32_REINTERPRET_I32: |
843 | 114k | case WASM_INS_F64_REINTERPRET_I64: |
844 | 114k | MI->wasm_data.type = WASM_OP_NONE; |
845 | | |
846 | 114k | if (MI->flat_insn->detail) { |
847 | 114k | MI->flat_insn->detail->wasm.op_count = 0; |
848 | 114k | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_NUMBERIC; |
849 | 114k | MI->flat_insn->detail->groups_count++; |
850 | 114k | } |
851 | | |
852 | 114k | *size = 1; |
853 | | |
854 | 114k | break; |
855 | | |
856 | 656 | case WASM_INS_DROP: |
857 | 2.36k | case WASM_INS_SELECT: |
858 | 2.36k | MI->wasm_data.type = WASM_OP_NONE; |
859 | | |
860 | 2.36k | if (MI->flat_insn->detail) { |
861 | 2.36k | MI->flat_insn->detail->wasm.op_count = 0; |
862 | 2.36k | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_PARAMETRIC; |
863 | 2.36k | MI->flat_insn->detail->groups_count++; |
864 | 2.36k | } |
865 | | |
866 | 2.36k | *size = 1; |
867 | | |
868 | 2.36k | break; |
869 | | |
870 | 892 | case WASM_INS_GET_LOCAL: |
871 | 1.40k | case WASM_INS_SET_LOCAL: |
872 | 1.80k | case WASM_INS_TEE_LOCAL: |
873 | 2.69k | case WASM_INS_GET_GLOBAL: |
874 | 3.33k | case WASM_INS_SET_GLOBAL: |
875 | 3.33k | if (code_len == 1 || !read_varuint32(&code[1], code_len - 1, ¶m_size, MI)) { |
876 | 55 | return false; |
877 | 55 | } |
878 | | |
879 | 3.28k | if (MI->flat_insn->detail) { |
880 | 3.28k | MI->flat_insn->detail->wasm.op_count = 1; |
881 | 3.28k | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_VARIABLE; |
882 | 3.28k | MI->flat_insn->detail->groups_count++; |
883 | 3.28k | } |
884 | | |
885 | 3.28k | *size = param_size + 1; |
886 | | |
887 | 3.28k | break; |
888 | | |
889 | 957 | case WASM_INS_I32_LOAD: |
890 | 1.45k | case WASM_INS_I64_LOAD: |
891 | 1.92k | case WASM_INS_F32_LOAD: |
892 | 2.41k | case WASM_INS_F64_LOAD: |
893 | 3.26k | case WASM_INS_I32_LOAD8_S: |
894 | 3.92k | case WASM_INS_I32_LOAD8_U: |
895 | 4.83k | case WASM_INS_I32_LOAD16_S: |
896 | 5.67k | case WASM_INS_I32_LOAD16_U: |
897 | 6.42k | case WASM_INS_I64_LOAD8_S: |
898 | 7.43k | case WASM_INS_I64_LOAD8_U: |
899 | 8.16k | case WASM_INS_I64_LOAD16_S: |
900 | 8.91k | case WASM_INS_I64_LOAD16_U: |
901 | 9.57k | case WASM_INS_I64_LOAD32_S: |
902 | 10.2k | case WASM_INS_I64_LOAD32_U: |
903 | 11.0k | case WASM_INS_I32_STORE: |
904 | 11.4k | case WASM_INS_I64_STORE: |
905 | 11.8k | case WASM_INS_F32_STORE: |
906 | 12.6k | case WASM_INS_F64_STORE: |
907 | 13.8k | case WASM_INS_I32_STORE8: |
908 | 14.2k | case WASM_INS_I32_STORE16: |
909 | 14.8k | case WASM_INS_I64_STORE8: |
910 | 15.4k | case WASM_INS_I64_STORE16: |
911 | 15.9k | case WASM_INS_I64_STORE32: |
912 | 15.9k | if (code_len == 1 || !read_memoryimmediate(&code[1], code_len - 1, ¶m_size, MI)) { |
913 | 290 | return false; |
914 | 290 | } |
915 | | |
916 | 15.6k | if (MI->flat_insn->detail) { |
917 | 15.6k | MI->flat_insn->detail->wasm.op_count = 2; |
918 | 15.6k | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_MEMORY; |
919 | 15.6k | MI->flat_insn->detail->groups_count++; |
920 | 15.6k | } |
921 | | |
922 | 15.6k | *size = param_size + 1; |
923 | | |
924 | 15.6k | break; |
925 | | |
926 | 3.89k | case WASM_INS_CURRENT_MEMORY: |
927 | 4.65k | case WASM_INS_GROW_MEMORY: |
928 | 4.65k | MI->wasm_data.type = WASM_OP_NONE; |
929 | | |
930 | 4.65k | if (MI->flat_insn->detail) { |
931 | 4.65k | MI->flat_insn->detail->wasm.op_count = 0; |
932 | 4.65k | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_MEMORY; |
933 | 4.65k | MI->flat_insn->detail->groups_count++; |
934 | 4.65k | } |
935 | | |
936 | 4.65k | *size = 1; |
937 | | |
938 | 4.65k | break; |
939 | | |
940 | 19.9k | case WASM_INS_UNREACHABLE: |
941 | 21.8k | case WASM_INS_NOP: |
942 | 22.4k | case WASM_INS_ELSE: |
943 | 23.0k | case WASM_INS_END: |
944 | 23.9k | case WASM_INS_RETURN: |
945 | 23.9k | MI->wasm_data.type = WASM_OP_NONE; |
946 | | |
947 | 23.9k | if (MI->flat_insn->detail) { |
948 | 23.9k | MI->flat_insn->detail->wasm.op_count = 0; |
949 | 23.9k | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_CONTROL; |
950 | 23.9k | MI->flat_insn->detail->groups_count++; |
951 | 23.9k | } |
952 | | |
953 | 23.9k | *size = 1; |
954 | | |
955 | 23.9k | break; |
956 | | |
957 | 1.55k | case WASM_INS_BLOCK: |
958 | 2.35k | case WASM_INS_LOOP: |
959 | 3.43k | case WASM_INS_IF: |
960 | 3.43k | if (code_len == 1 || !read_varint7(&code[1], code_len - 1, ¶m_size, MI)) { |
961 | 30 | return false; |
962 | 30 | } |
963 | | |
964 | 3.40k | if (MI->flat_insn->detail) { |
965 | 3.40k | MI->flat_insn->detail->wasm.op_count = 1; |
966 | 3.40k | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_CONTROL; |
967 | 3.40k | MI->flat_insn->detail->groups_count++; |
968 | 3.40k | } |
969 | | |
970 | 3.40k | *size = param_size + 1; |
971 | | |
972 | 3.40k | break; |
973 | | |
974 | 877 | case WASM_INS_BR: |
975 | 1.35k | case WASM_INS_BR_IF: |
976 | 2.14k | case WASM_INS_CALL: |
977 | 2.75k | case WASM_INS_CALL_INDIRECT: |
978 | 2.75k | if (code_len == 1 || !read_varuint32(&code[1], code_len - 1, ¶m_size, MI)) { |
979 | 48 | return false; |
980 | 48 | } |
981 | | |
982 | 2.71k | if (MI->flat_insn->detail) { |
983 | 2.71k | MI->flat_insn->detail->wasm.op_count = 1; |
984 | 2.71k | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_CONTROL; |
985 | 2.71k | MI->flat_insn->detail->groups_count++; |
986 | 2.71k | } |
987 | | |
988 | 2.71k | *size = param_size + 1; |
989 | | |
990 | 2.71k | break; |
991 | | |
992 | 2.35k | case WASM_INS_BR_TABLE: |
993 | 2.35k | if (code_len == 1 || !read_brtable(&code[1], code_len - 1, ¶m_size, MI)) { |
994 | 175 | return false; |
995 | 175 | } |
996 | | |
997 | 2.18k | if (MI->flat_insn->detail) { |
998 | 2.18k | MI->flat_insn->detail->wasm.op_count = 1; |
999 | 2.18k | MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_CONTROL; |
1000 | 2.18k | MI->flat_insn->detail->groups_count++; |
1001 | 2.18k | } |
1002 | | |
1003 | 2.18k | *size = param_size + 1; |
1004 | | |
1005 | 2.18k | break; |
1006 | 177k | } |
1007 | | |
1008 | 176k | return true; |
1009 | 177k | } |