?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
audio: make playback packet length calculation exact
[qemu/ar7.git] / tcg / tci.c
blobfc67e7e767a011cc5acb7cec8d96bb4b7aa74843
1 /*
2 * Tiny Code Interpreter for QEMU
3 *
4 * Copyright (c) 2009, 2011, 2016 Stefan Weil
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "qemu/osdep.h"
21 #include "exec/cpu_ldst.h"
22 #include "tcg/tcg-op.h"
23 #include "tcg/tcg-ldst.h"
24 #include <ffi.h>
25
26
27 /*
28 * Enable TCI assertions only when debugging TCG (and without NDEBUG defined).
29 * Without assertions, the interpreter runs much faster.
30 */
31 #if defined(CONFIG_DEBUG_TCG)
32 # define tci_assert(cond) assert(cond)
33 #else
34 # define tci_assert(cond) ((void)(cond))
35 #endif
36
37 __thread uintptr_t tci_tb_ptr;
38
39 static void tci_write_reg64(tcg_target_ulong *regs, uint32_t high_index,
40 uint32_t low_index, uint64_t value)
41 {
42 regs[low_index] = (uint32_t)value;
43 regs[high_index] = value >> 32;
44 }
45
46 /* Create a 64 bit value from two 32 bit values. */
47 static uint64_t tci_uint64(uint32_t high, uint32_t low)
48 {
49 return ((uint64_t)high << 32) + low;
50 }
51
52 /*
53 * Load sets of arguments all at once. The naming convention is:
54 * tci_args_<arguments>
55 * where arguments is a sequence of
56 *
57 * b = immediate (bit position)
58 * c = condition (TCGCond)
59 * i = immediate (uint32_t)
60 * I = immediate (tcg_target_ulong)
61 * l = label or pointer
62 * m = immediate (MemOpIdx)
63 * n = immediate (call return length)
64 * r = register
65 * s = signed ldst offset
66 */
67
68 static void tci_args_l(uint32_t insn, const void *tb_ptr, void **l0)
69 {
70 int diff = sextract32(insn, 12, 20);
71 *l0 = diff ? (void *)tb_ptr + diff : NULL;
72 }
73
74 static void tci_args_r(uint32_t insn, TCGReg *r0)
75 {
76 *r0 = extract32(insn, 8, 4);
77 }
78
79 static void tci_args_nl(uint32_t insn, const void *tb_ptr,
80 uint8_t *n0, void **l1)
81 {
82 *n0 = extract32(insn, 8, 4);
83 *l1 = sextract32(insn, 12, 20) + (void *)tb_ptr;
84 }
85
86 static void tci_args_rl(uint32_t insn, const void *tb_ptr,
87 TCGReg *r0, void **l1)
88 {
89 *r0 = extract32(insn, 8, 4);
90 *l1 = sextract32(insn, 12, 20) + (void *)tb_ptr;
91 }
92
93 static void tci_args_rr(uint32_t insn, TCGReg *r0, TCGReg *r1)
94 {
95 *r0 = extract32(insn, 8, 4);
96 *r1 = extract32(insn, 12, 4);
97 }
98
99 static void tci_args_ri(uint32_t insn, TCGReg *r0, tcg_target_ulong *i1)
100 {
101 *r0 = extract32(insn, 8, 4);
102 *i1 = sextract32(insn, 12, 20);
103 }
104
105 static void tci_args_rrm(uint32_t insn, TCGReg *r0,
106 TCGReg *r1, MemOpIdx *m2)
107 {
108 *r0 = extract32(insn, 8, 4);
109 *r1 = extract32(insn, 12, 4);
110 *m2 = extract32(insn, 20, 12);
111 }
112
113 static void tci_args_rrr(uint32_t insn, TCGReg *r0, TCGReg *r1, TCGReg *r2)
114 {
115 *r0 = extract32(insn, 8, 4);
116 *r1 = extract32(insn, 12, 4);
117 *r2 = extract32(insn, 16, 4);
118 }
119
120 static void tci_args_rrs(uint32_t insn, TCGReg *r0, TCGReg *r1, int32_t *i2)
121 {
122 *r0 = extract32(insn, 8, 4);
123 *r1 = extract32(insn, 12, 4);
124 *i2 = sextract32(insn, 16, 16);
125 }
126
127 static void tci_args_rrbb(uint32_t insn, TCGReg *r0, TCGReg *r1,
128 uint8_t *i2, uint8_t *i3)
129 {
130 *r0 = extract32(insn, 8, 4);
131 *r1 = extract32(insn, 12, 4);
132 *i2 = extract32(insn, 16, 6);
133 *i3 = extract32(insn, 22, 6);
134 }
135
136 static void tci_args_rrrc(uint32_t insn,
137 TCGReg *r0, TCGReg *r1, TCGReg *r2, TCGCond *c3)
138 {
139 *r0 = extract32(insn, 8, 4);
140 *r1 = extract32(insn, 12, 4);
141 *r2 = extract32(insn, 16, 4);
142 *c3 = extract32(insn, 20, 4);
143 }
144
145 static void tci_args_rrrm(uint32_t insn,
146 TCGReg *r0, TCGReg *r1, TCGReg *r2, MemOpIdx *m3)
147 {
148 *r0 = extract32(insn, 8, 4);
149 *r1 = extract32(insn, 12, 4);
150 *r2 = extract32(insn, 16, 4);
151 *m3 = extract32(insn, 20, 12);
152 }
153
154 static void tci_args_rrrbb(uint32_t insn, TCGReg *r0, TCGReg *r1,
155 TCGReg *r2, uint8_t *i3, uint8_t *i4)
156 {
157 *r0 = extract32(insn, 8, 4);
158 *r1 = extract32(insn, 12, 4);
159 *r2 = extract32(insn, 16, 4);
160 *i3 = extract32(insn, 20, 6);
161 *i4 = extract32(insn, 26, 6);
162 }
163
164 static void tci_args_rrrrr(uint32_t insn, TCGReg *r0, TCGReg *r1,
165 TCGReg *r2, TCGReg *r3, TCGReg *r4)
166 {
167 *r0 = extract32(insn, 8, 4);
168 *r1 = extract32(insn, 12, 4);
169 *r2 = extract32(insn, 16, 4);
170 *r3 = extract32(insn, 20, 4);
171 *r4 = extract32(insn, 24, 4);
172 }
173
174 static void tci_args_rrrr(uint32_t insn,
175 TCGReg *r0, TCGReg *r1, TCGReg *r2, TCGReg *r3)
176 {
177 *r0 = extract32(insn, 8, 4);
178 *r1 = extract32(insn, 12, 4);
179 *r2 = extract32(insn, 16, 4);
180 *r3 = extract32(insn, 20, 4);
181 }
182
183 static void tci_args_rrrrrc(uint32_t insn, TCGReg *r0, TCGReg *r1,
184 TCGReg *r2, TCGReg *r3, TCGReg *r4, TCGCond *c5)
185 {
186 *r0 = extract32(insn, 8, 4);
187 *r1 = extract32(insn, 12, 4);
188 *r2 = extract32(insn, 16, 4);
189 *r3 = extract32(insn, 20, 4);
190 *r4 = extract32(insn, 24, 4);
191 *c5 = extract32(insn, 28, 4);
192 }
193
194 static void tci_args_rrrrrr(uint32_t insn, TCGReg *r0, TCGReg *r1,
195 TCGReg *r2, TCGReg *r3, TCGReg *r4, TCGReg *r5)
196 {
197 *r0 = extract32(insn, 8, 4);
198 *r1 = extract32(insn, 12, 4);
199 *r2 = extract32(insn, 16, 4);
200 *r3 = extract32(insn, 20, 4);
201 *r4 = extract32(insn, 24, 4);
202 *r5 = extract32(insn, 28, 4);
203 }
204
205 static bool tci_compare32(uint32_t u0, uint32_t u1, TCGCond condition)
206 {
207 bool result = false;
208 int32_t i0 = u0;
209 int32_t i1 = u1;
210 switch (condition) {
211 case TCG_COND_EQ:
212 result = (u0 == u1);
213 break;
214 case TCG_COND_NE:
215 result = (u0 != u1);
216 break;
217 case TCG_COND_LT:
218 result = (i0 < i1);
219 break;
220 case TCG_COND_GE:
221 result = (i0 >= i1);
222 break;
223 case TCG_COND_LE:
224 result = (i0 <= i1);
225 break;
226 case TCG_COND_GT:
227 result = (i0 > i1);
228 break;
229 case TCG_COND_LTU:
230 result = (u0 < u1);
231 break;
232 case TCG_COND_GEU:
233 result = (u0 >= u1);
234 break;
235 case TCG_COND_LEU:
236 result = (u0 <= u1);
237 break;
238 case TCG_COND_GTU:
239 result = (u0 > u1);
240 break;
241 default:
242 g_assert_not_reached();
243 }
244 return result;
245 }
246
247 static bool tci_compare64(uint64_t u0, uint64_t u1, TCGCond condition)
248 {
249 bool result = false;
250 int64_t i0 = u0;
251 int64_t i1 = u1;
252 switch (condition) {
253 case TCG_COND_EQ:
254 result = (u0 == u1);
255 break;
256 case TCG_COND_NE:
257 result = (u0 != u1);
258 break;
259 case TCG_COND_LT:
260 result = (i0 < i1);
261 break;
262 case TCG_COND_GE:
263 result = (i0 >= i1);
264 break;
265 case TCG_COND_LE:
266 result = (i0 <= i1);
267 break;
268 case TCG_COND_GT:
269 result = (i0 > i1);
270 break;
271 case TCG_COND_LTU:
272 result = (u0 < u1);
273 break;
274 case TCG_COND_GEU:
275 result = (u0 >= u1);
276 break;
277 case TCG_COND_LEU:
278 result = (u0 <= u1);
279 break;
280 case TCG_COND_GTU:
281 result = (u0 > u1);
282 break;
283 default:
284 g_assert_not_reached();
285 }
286 return result;
287 }
288
289 static uint64_t tci_qemu_ld(CPUArchState *env, target_ulong taddr,
290 MemOpIdx oi, const void *tb_ptr)
291 {
292 MemOp mop = get_memop(oi);
293 uintptr_t ra = (uintptr_t)tb_ptr;
294
295 #ifdef CONFIG_SOFTMMU
296 switch (mop & (MO_BSWAP | MO_SSIZE)) {
297 case MO_UB:
298 return helper_ret_ldub_mmu(env, taddr, oi, ra);
299 case MO_SB:
300 return helper_ret_ldsb_mmu(env, taddr, oi, ra);
301 case MO_LEUW:
302 return helper_le_lduw_mmu(env, taddr, oi, ra);
303 case MO_LESW:
304 return helper_le_ldsw_mmu(env, taddr, oi, ra);
305 case MO_LEUL:
306 return helper_le_ldul_mmu(env, taddr, oi, ra);
307 case MO_LESL:
308 return helper_le_ldsl_mmu(env, taddr, oi, ra);
309 case MO_LEUQ:
310 return helper_le_ldq_mmu(env, taddr, oi, ra);
311 case MO_BEUW:
312 return helper_be_lduw_mmu(env, taddr, oi, ra);
313 case MO_BESW:
314 return helper_be_ldsw_mmu(env, taddr, oi, ra);
315 case MO_BEUL:
316 return helper_be_ldul_mmu(env, taddr, oi, ra);
317 case MO_BESL:
318 return helper_be_ldsl_mmu(env, taddr, oi, ra);
319 case MO_BEUQ:
320 return helper_be_ldq_mmu(env, taddr, oi, ra);
321 default:
322 g_assert_not_reached();
323 }
324 #else
325 void *haddr = g2h(env_cpu(env), taddr);
326 unsigned a_mask = (1u << get_alignment_bits(mop)) - 1;
327 uint64_t ret;
328
329 set_helper_retaddr(ra);
330 if (taddr & a_mask) {
331 helper_unaligned_ld(env, taddr);
332 }
333 switch (mop & (MO_BSWAP | MO_SSIZE)) {
334 case MO_UB:
335 ret = ldub_p(haddr);
336 break;
337 case MO_SB:
338 ret = ldsb_p(haddr);
339 break;
340 case MO_LEUW:
341 ret = lduw_le_p(haddr);
342 break;
343 case MO_LESW:
344 ret = ldsw_le_p(haddr);
345 break;
346 case MO_LEUL:
347 ret = (uint32_t)ldl_le_p(haddr);
348 break;
349 case MO_LESL:
350 ret = (int32_t)ldl_le_p(haddr);
351 break;
352 case MO_LEUQ:
353 ret = ldq_le_p(haddr);
354 break;
355 case MO_BEUW:
356 ret = lduw_be_p(haddr);
357 break;
358 case MO_BESW:
359 ret = ldsw_be_p(haddr);
360 break;
361 case MO_BEUL:
362 ret = (uint32_t)ldl_be_p(haddr);
363 break;
364 case MO_BESL:
365 ret = (int32_t)ldl_be_p(haddr);
366 break;
367 case MO_BEUQ:
368 ret = ldq_be_p(haddr);
369 break;
370 default:
371 g_assert_not_reached();
372 }
373 clear_helper_retaddr();
374 return ret;
375 #endif
376 }
377
378 static void tci_qemu_st(CPUArchState *env, target_ulong taddr, uint64_t val,
379 MemOpIdx oi, const void *tb_ptr)
380 {
381 MemOp mop = get_memop(oi);
382 uintptr_t ra = (uintptr_t)tb_ptr;
383
384 #ifdef CONFIG_SOFTMMU
385 switch (mop & (MO_BSWAP | MO_SIZE)) {
386 case MO_UB:
387 helper_ret_stb_mmu(env, taddr, val, oi, ra);
388 break;
389 case MO_LEUW:
390 helper_le_stw_mmu(env, taddr, val, oi, ra);
391 break;
392 case MO_LEUL:
393 helper_le_stl_mmu(env, taddr, val, oi, ra);
394 break;
395 case MO_LEUQ:
396 helper_le_stq_mmu(env, taddr, val, oi, ra);
397 break;
398 case MO_BEUW:
399 helper_be_stw_mmu(env, taddr, val, oi, ra);
400 break;
401 case MO_BEUL:
402 helper_be_stl_mmu(env, taddr, val, oi, ra);
403 break;
404 case MO_BEUQ:
405 helper_be_stq_mmu(env, taddr, val, oi, ra);
406 break;
407 default:
408 g_assert_not_reached();
409 }
410 #else
411 void *haddr = g2h(env_cpu(env), taddr);
412 unsigned a_mask = (1u << get_alignment_bits(mop)) - 1;
413
414 set_helper_retaddr(ra);
415 if (taddr & a_mask) {
416 helper_unaligned_st(env, taddr);
417 }
418 switch (mop & (MO_BSWAP | MO_SIZE)) {
419 case MO_UB:
420 stb_p(haddr, val);
421 break;
422 case MO_LEUW:
423 stw_le_p(haddr, val);
424 break;
425 case MO_LEUL:
426 stl_le_p(haddr, val);
427 break;
428 case MO_LEUQ:
429 stq_le_p(haddr, val);
430 break;
431 case MO_BEUW:
432 stw_be_p(haddr, val);
433 break;
434 case MO_BEUL:
435 stl_be_p(haddr, val);
436 break;
437 case MO_BEUQ:
438 stq_be_p(haddr, val);
439 break;
440 default:
441 g_assert_not_reached();
442 }
443 clear_helper_retaddr();
444 #endif
445 }
446
447 #if TCG_TARGET_REG_BITS == 64
448 # define CASE_32_64(x) \
449 case glue(glue(INDEX_op_, x), _i64): \
450 case glue(glue(INDEX_op_, x), _i32):
451 # define CASE_64(x) \
452 case glue(glue(INDEX_op_, x), _i64):
453 #else
454 # define CASE_32_64(x) \
455 case glue(glue(INDEX_op_, x), _i32):
456 # define CASE_64(x)
457 #endif
458
459 /* Interpret pseudo code in tb. */
460 /*
461 * Disable CFI checks.
462 * One possible operation in the pseudo code is a call to binary code.
463 * Therefore, disable CFI checks in the interpreter function
464 */
465 uintptr_t QEMU_DISABLE_CFI tcg_qemu_tb_exec(CPUArchState *env,
466 const void *v_tb_ptr)
467 {
468 const uint32_t *tb_ptr = v_tb_ptr;
469 tcg_target_ulong regs[TCG_TARGET_NB_REGS];
470 uint64_t stack[(TCG_STATIC_CALL_ARGS_SIZE + TCG_STATIC_FRAME_SIZE)
471 / sizeof(uint64_t)];
472
473 regs[TCG_AREG0] = (tcg_target_ulong)env;
474 regs[TCG_REG_CALL_STACK] = (uintptr_t)stack;
475 tci_assert(tb_ptr);
476
477 for (;;) {
478 uint32_t insn;
479 TCGOpcode opc;
480 TCGReg r0, r1, r2, r3, r4, r5;
481 tcg_target_ulong t1;
482 TCGCond condition;
483 target_ulong taddr;
484 uint8_t pos, len;
485 uint32_t tmp32;
486 uint64_t tmp64;
487 uint64_t T1, T2;
488 MemOpIdx oi;
489 int32_t ofs;
490 void *ptr;
491
492 insn = *tb_ptr++;
493 opc = extract32(insn, 0, 8);
494
495 switch (opc) {
496 case INDEX_op_call:
497 {
498 void *call_slots[MAX_CALL_IARGS];
499 ffi_cif *cif;
500 void *func;
501 unsigned i, s, n;
502
503 tci_args_nl(insn, tb_ptr, &len, &ptr);
504 func = ((void **)ptr)[0];
505 cif = ((void **)ptr)[1];
506
507 n = cif->nargs;
508 for (i = s = 0; i < n; ++i) {
509 ffi_type *t = cif->arg_types[i];
510 call_slots[i] = &stack[s];
511 s += DIV_ROUND_UP(t->size, 8);
512 }
513
514 /* Helper functions may need to access the "return address" */
515 tci_tb_ptr = (uintptr_t)tb_ptr;
516 ffi_call(cif, func, stack, call_slots);
517 }
518
519 switch (len) {
520 case 0: /* void */
521 break;
522 case 1: /* uint32_t */
523 /*
524 * The result winds up "left-aligned" in the stack[0] slot.
525 * Note that libffi has an odd special case in that it will
526 * always widen an integral result to ffi_arg.
527 */
528 if (sizeof(ffi_arg) == 8) {
529 regs[TCG_REG_R0] = (uint32_t)stack[0];
530 } else {
531 regs[TCG_REG_R0] = *(uint32_t *)stack;
532 }
533 break;
534 case 2: /* uint64_t */
535 /*
536 * For TCG_TARGET_REG_BITS == 32, the register pair
537 * must stay in host memory order.
538 */
539 memcpy(&regs[TCG_REG_R0], stack, 8);
540 break;
541 case 3: /* Int128 */
542 memcpy(&regs[TCG_REG_R0], stack, 16);
543 break;
544 default:
545 g_assert_not_reached();
546 }
547 break;
548
549 case INDEX_op_br:
550 tci_args_l(insn, tb_ptr, &ptr);
551 tb_ptr = ptr;
552 continue;
553 case INDEX_op_setcond_i32:
554 tci_args_rrrc(insn, &r0, &r1, &r2, &condition);
555 regs[r0] = tci_compare32(regs[r1], regs[r2], condition);
556 break;
557 case INDEX_op_movcond_i32:
558 tci_args_rrrrrc(insn, &r0, &r1, &r2, &r3, &r4, &condition);
559 tmp32 = tci_compare32(regs[r1], regs[r2], condition);
560 regs[r0] = regs[tmp32 ? r3 : r4];
561 break;
562 #if TCG_TARGET_REG_BITS == 32
563 case INDEX_op_setcond2_i32:
564 tci_args_rrrrrc(insn, &r0, &r1, &r2, &r3, &r4, &condition);
565 T1 = tci_uint64(regs[r2], regs[r1]);
566 T2 = tci_uint64(regs[r4], regs[r3]);
567 regs[r0] = tci_compare64(T1, T2, condition);
568 break;
569 #elif TCG_TARGET_REG_BITS == 64
570 case INDEX_op_setcond_i64:
571 tci_args_rrrc(insn, &r0, &r1, &r2, &condition);
572 regs[r0] = tci_compare64(regs[r1], regs[r2], condition);
573 break;
574 case INDEX_op_movcond_i64:
575 tci_args_rrrrrc(insn, &r0, &r1, &r2, &r3, &r4, &condition);
576 tmp32 = tci_compare64(regs[r1], regs[r2], condition);
577 regs[r0] = regs[tmp32 ? r3 : r4];
578 break;
579 #endif
580 CASE_32_64(mov)
581 tci_args_rr(insn, &r0, &r1);
582 regs[r0] = regs[r1];
583 break;
584 case INDEX_op_tci_movi:
585 tci_args_ri(insn, &r0, &t1);
586 regs[r0] = t1;
587 break;
588 case INDEX_op_tci_movl:
589 tci_args_rl(insn, tb_ptr, &r0, &ptr);
590 regs[r0] = *(tcg_target_ulong *)ptr;
591 break;
592
593 /* Load/store operations (32 bit). */
594
595 CASE_32_64(ld8u)
596 tci_args_rrs(insn, &r0, &r1, &ofs);
597 ptr = (void *)(regs[r1] + ofs);
598 regs[r0] = *(uint8_t *)ptr;
599 break;
600 CASE_32_64(ld8s)
601 tci_args_rrs(insn, &r0, &r1, &ofs);
602 ptr = (void *)(regs[r1] + ofs);
603 regs[r0] = *(int8_t *)ptr;
604 break;
605 CASE_32_64(ld16u)
606 tci_args_rrs(insn, &r0, &r1, &ofs);
607 ptr = (void *)(regs[r1] + ofs);
608 regs[r0] = *(uint16_t *)ptr;
609 break;
610 CASE_32_64(ld16s)
611 tci_args_rrs(insn, &r0, &r1, &ofs);
612 ptr = (void *)(regs[r1] + ofs);
613 regs[r0] = *(int16_t *)ptr;
614 break;
615 case INDEX_op_ld_i32:
616 CASE_64(ld32u)
617 tci_args_rrs(insn, &r0, &r1, &ofs);
618 ptr = (void *)(regs[r1] + ofs);
619 regs[r0] = *(uint32_t *)ptr;
620 break;
621 CASE_32_64(st8)
622 tci_args_rrs(insn, &r0, &r1, &ofs);
623 ptr = (void *)(regs[r1] + ofs);
624 *(uint8_t *)ptr = regs[r0];
625 break;
626 CASE_32_64(st16)
627 tci_args_rrs(insn, &r0, &r1, &ofs);
628 ptr = (void *)(regs[r1] + ofs);
629 *(uint16_t *)ptr = regs[r0];
630 break;
631 case INDEX_op_st_i32:
632 CASE_64(st32)
633 tci_args_rrs(insn, &r0, &r1, &ofs);
634 ptr = (void *)(regs[r1] + ofs);
635 *(uint32_t *)ptr = regs[r0];
636 break;
637
638 /* Arithmetic operations (mixed 32/64 bit). */
639
640 CASE_32_64(add)
641 tci_args_rrr(insn, &r0, &r1, &r2);
642 regs[r0] = regs[r1] + regs[r2];
643 break;
644 CASE_32_64(sub)
645 tci_args_rrr(insn, &r0, &r1, &r2);
646 regs[r0] = regs[r1] - regs[r2];
647 break;
648 CASE_32_64(mul)
649 tci_args_rrr(insn, &r0, &r1, &r2);
650 regs[r0] = regs[r1] * regs[r2];
651 break;
652 CASE_32_64(and)
653 tci_args_rrr(insn, &r0, &r1, &r2);
654 regs[r0] = regs[r1] & regs[r2];
655 break;
656 CASE_32_64(or)
657 tci_args_rrr(insn, &r0, &r1, &r2);
658 regs[r0] = regs[r1] | regs[r2];
659 break;
660 CASE_32_64(xor)
661 tci_args_rrr(insn, &r0, &r1, &r2);
662 regs[r0] = regs[r1] ^ regs[r2];
663 break;
664 #if TCG_TARGET_HAS_andc_i32 || TCG_TARGET_HAS_andc_i64
665 CASE_32_64(andc)
666 tci_args_rrr(insn, &r0, &r1, &r2);
667 regs[r0] = regs[r1] & ~regs[r2];
668 break;
669 #endif
670 #if TCG_TARGET_HAS_orc_i32 || TCG_TARGET_HAS_orc_i64
671 CASE_32_64(orc)
672 tci_args_rrr(insn, &r0, &r1, &r2);
673 regs[r0] = regs[r1] | ~regs[r2];
674 break;
675 #endif
676 #if TCG_TARGET_HAS_eqv_i32 || TCG_TARGET_HAS_eqv_i64
677 CASE_32_64(eqv)
678 tci_args_rrr(insn, &r0, &r1, &r2);
679 regs[r0] = ~(regs[r1] ^ regs[r2]);
680 break;
681 #endif
682 #if TCG_TARGET_HAS_nand_i32 || TCG_TARGET_HAS_nand_i64
683 CASE_32_64(nand)
684 tci_args_rrr(insn, &r0, &r1, &r2);
685 regs[r0] = ~(regs[r1] & regs[r2]);
686 break;
687 #endif
688 #if TCG_TARGET_HAS_nor_i32 || TCG_TARGET_HAS_nor_i64
689 CASE_32_64(nor)
690 tci_args_rrr(insn, &r0, &r1, &r2);
691 regs[r0] = ~(regs[r1] | regs[r2]);
692 break;
693 #endif
694
695 /* Arithmetic operations (32 bit). */
696
697 case INDEX_op_div_i32:
698 tci_args_rrr(insn, &r0, &r1, &r2);
699 regs[r0] = (int32_t)regs[r1] / (int32_t)regs[r2];
700 break;
701 case INDEX_op_divu_i32:
702 tci_args_rrr(insn, &r0, &r1, &r2);
703 regs[r0] = (uint32_t)regs[r1] / (uint32_t)regs[r2];
704 break;
705 case INDEX_op_rem_i32:
706 tci_args_rrr(insn, &r0, &r1, &r2);
707 regs[r0] = (int32_t)regs[r1] % (int32_t)regs[r2];
708 break;
709 case INDEX_op_remu_i32:
710 tci_args_rrr(insn, &r0, &r1, &r2);
711 regs[r0] = (uint32_t)regs[r1] % (uint32_t)regs[r2];
712 break;
713 #if TCG_TARGET_HAS_clz_i32
714 case INDEX_op_clz_i32:
715 tci_args_rrr(insn, &r0, &r1, &r2);
716 tmp32 = regs[r1];
717 regs[r0] = tmp32 ? clz32(tmp32) : regs[r2];
718 break;
719 #endif
720 #if TCG_TARGET_HAS_ctz_i32
721 case INDEX_op_ctz_i32:
722 tci_args_rrr(insn, &r0, &r1, &r2);
723 tmp32 = regs[r1];
724 regs[r0] = tmp32 ? ctz32(tmp32) : regs[r2];
725 break;
726 #endif
727 #if TCG_TARGET_HAS_ctpop_i32
728 case INDEX_op_ctpop_i32:
729 tci_args_rr(insn, &r0, &r1);
730 regs[r0] = ctpop32(regs[r1]);
731 break;
732 #endif
733
734 /* Shift/rotate operations (32 bit). */
735
736 case INDEX_op_shl_i32:
737 tci_args_rrr(insn, &r0, &r1, &r2);
738 regs[r0] = (uint32_t)regs[r1] << (regs[r2] & 31);
739 break;
740 case INDEX_op_shr_i32:
741 tci_args_rrr(insn, &r0, &r1, &r2);
742 regs[r0] = (uint32_t)regs[r1] >> (regs[r2] & 31);
743 break;
744 case INDEX_op_sar_i32:
745 tci_args_rrr(insn, &r0, &r1, &r2);
746 regs[r0] = (int32_t)regs[r1] >> (regs[r2] & 31);
747 break;
748 #if TCG_TARGET_HAS_rot_i32
749 case INDEX_op_rotl_i32:
750 tci_args_rrr(insn, &r0, &r1, &r2);
751 regs[r0] = rol32(regs[r1], regs[r2] & 31);
752 break;
753 case INDEX_op_rotr_i32:
754 tci_args_rrr(insn, &r0, &r1, &r2);
755 regs[r0] = ror32(regs[r1], regs[r2] & 31);
756 break;
757 #endif
758 #if TCG_TARGET_HAS_deposit_i32
759 case INDEX_op_deposit_i32:
760 tci_args_rrrbb(insn, &r0, &r1, &r2, &pos, &len);
761 regs[r0] = deposit32(regs[r1], pos, len, regs[r2]);
762 break;
763 #endif
764 #if TCG_TARGET_HAS_extract_i32
765 case INDEX_op_extract_i32:
766 tci_args_rrbb(insn, &r0, &r1, &pos, &len);
767 regs[r0] = extract32(regs[r1], pos, len);
768 break;
769 #endif
770 #if TCG_TARGET_HAS_sextract_i32
771 case INDEX_op_sextract_i32:
772 tci_args_rrbb(insn, &r0, &r1, &pos, &len);
773 regs[r0] = sextract32(regs[r1], pos, len);
774 break;
775 #endif
776 case INDEX_op_brcond_i32:
777 tci_args_rl(insn, tb_ptr, &r0, &ptr);
778 if ((uint32_t)regs[r0]) {
779 tb_ptr = ptr;
780 }
781 break;
782 #if TCG_TARGET_REG_BITS == 32 || TCG_TARGET_HAS_add2_i32
783 case INDEX_op_add2_i32:
784 tci_args_rrrrrr(insn, &r0, &r1, &r2, &r3, &r4, &r5);
785 T1 = tci_uint64(regs[r3], regs[r2]);
786 T2 = tci_uint64(regs[r5], regs[r4]);
787 tci_write_reg64(regs, r1, r0, T1 + T2);
788 break;
789 #endif
790 #if TCG_TARGET_REG_BITS == 32 || TCG_TARGET_HAS_sub2_i32
791 case INDEX_op_sub2_i32:
792 tci_args_rrrrrr(insn, &r0, &r1, &r2, &r3, &r4, &r5);
793 T1 = tci_uint64(regs[r3], regs[r2]);
794 T2 = tci_uint64(regs[r5], regs[r4]);
795 tci_write_reg64(regs, r1, r0, T1 - T2);
796 break;
797 #endif
798 #if TCG_TARGET_HAS_mulu2_i32
799 case INDEX_op_mulu2_i32:
800 tci_args_rrrr(insn, &r0, &r1, &r2, &r3);
801 tmp64 = (uint64_t)(uint32_t)regs[r2] * (uint32_t)regs[r3];
802 tci_write_reg64(regs, r1, r0, tmp64);
803 break;
804 #endif
805 #if TCG_TARGET_HAS_muls2_i32
806 case INDEX_op_muls2_i32:
807 tci_args_rrrr(insn, &r0, &r1, &r2, &r3);
808 tmp64 = (int64_t)(int32_t)regs[r2] * (int32_t)regs[r3];
809 tci_write_reg64(regs, r1, r0, tmp64);
810 break;
811 #endif
812 #if TCG_TARGET_HAS_ext8s_i32 || TCG_TARGET_HAS_ext8s_i64
813 CASE_32_64(ext8s)
814 tci_args_rr(insn, &r0, &r1);
815 regs[r0] = (int8_t)regs[r1];
816 break;
817 #endif
818 #if TCG_TARGET_HAS_ext16s_i32 || TCG_TARGET_HAS_ext16s_i64 || \
819 TCG_TARGET_HAS_bswap16_i32 || TCG_TARGET_HAS_bswap16_i64
820 CASE_32_64(ext16s)
821 tci_args_rr(insn, &r0, &r1);
822 regs[r0] = (int16_t)regs[r1];
823 break;
824 #endif
825 #if TCG_TARGET_HAS_ext8u_i32 || TCG_TARGET_HAS_ext8u_i64
826 CASE_32_64(ext8u)
827 tci_args_rr(insn, &r0, &r1);
828 regs[r0] = (uint8_t)regs[r1];
829 break;
830 #endif
831 #if TCG_TARGET_HAS_ext16u_i32 || TCG_TARGET_HAS_ext16u_i64
832 CASE_32_64(ext16u)
833 tci_args_rr(insn, &r0, &r1);
834 regs[r0] = (uint16_t)regs[r1];
835 break;
836 #endif
837 #if TCG_TARGET_HAS_bswap16_i32 || TCG_TARGET_HAS_bswap16_i64
838 CASE_32_64(bswap16)
839 tci_args_rr(insn, &r0, &r1);
840 regs[r0] = bswap16(regs[r1]);
841 break;
842 #endif
843 #if TCG_TARGET_HAS_bswap32_i32 || TCG_TARGET_HAS_bswap32_i64
844 CASE_32_64(bswap32)
845 tci_args_rr(insn, &r0, &r1);
846 regs[r0] = bswap32(regs[r1]);
847 break;
848 #endif
849 #if TCG_TARGET_HAS_not_i32 || TCG_TARGET_HAS_not_i64
850 CASE_32_64(not)
851 tci_args_rr(insn, &r0, &r1);
852 regs[r0] = ~regs[r1];
853 break;
854 #endif
855 #if TCG_TARGET_HAS_neg_i32 || TCG_TARGET_HAS_neg_i64
856 CASE_32_64(neg)
857 tci_args_rr(insn, &r0, &r1);
858 regs[r0] = -regs[r1];
859 break;
860 #endif
861 #if TCG_TARGET_REG_BITS == 64
862 /* Load/store operations (64 bit). */
863
864 case INDEX_op_ld32s_i64:
865 tci_args_rrs(insn, &r0, &r1, &ofs);
866 ptr = (void *)(regs[r1] + ofs);
867 regs[r0] = *(int32_t *)ptr;
868 break;
869 case INDEX_op_ld_i64:
870 tci_args_rrs(insn, &r0, &r1, &ofs);
871 ptr = (void *)(regs[r1] + ofs);
872 regs[r0] = *(uint64_t *)ptr;
873 break;
874 case INDEX_op_st_i64:
875 tci_args_rrs(insn, &r0, &r1, &ofs);
876 ptr = (void *)(regs[r1] + ofs);
877 *(uint64_t *)ptr = regs[r0];
878 break;
879
880 /* Arithmetic operations (64 bit). */
881
882 case INDEX_op_div_i64:
883 tci_args_rrr(insn, &r0, &r1, &r2);
884 regs[r0] = (int64_t)regs[r1] / (int64_t)regs[r2];
885 break;
886 case INDEX_op_divu_i64:
887 tci_args_rrr(insn, &r0, &r1, &r2);
888 regs[r0] = (uint64_t)regs[r1] / (uint64_t)regs[r2];
889 break;
890 case INDEX_op_rem_i64:
891 tci_args_rrr(insn, &r0, &r1, &r2);
892 regs[r0] = (int64_t)regs[r1] % (int64_t)regs[r2];
893 break;
894 case INDEX_op_remu_i64:
895 tci_args_rrr(insn, &r0, &r1, &r2);
896 regs[r0] = (uint64_t)regs[r1] % (uint64_t)regs[r2];
897 break;
898 #if TCG_TARGET_HAS_clz_i64
899 case INDEX_op_clz_i64:
900 tci_args_rrr(insn, &r0, &r1, &r2);
901 regs[r0] = regs[r1] ? clz64(regs[r1]) : regs[r2];
902 break;
903 #endif
904 #if TCG_TARGET_HAS_ctz_i64
905 case INDEX_op_ctz_i64:
906 tci_args_rrr(insn, &r0, &r1, &r2);
907 regs[r0] = regs[r1] ? ctz64(regs[r1]) : regs[r2];
908 break;
909 #endif
910 #if TCG_TARGET_HAS_ctpop_i64
911 case INDEX_op_ctpop_i64:
912 tci_args_rr(insn, &r0, &r1);
913 regs[r0] = ctpop64(regs[r1]);
914 break;
915 #endif
916 #if TCG_TARGET_HAS_mulu2_i64
917 case INDEX_op_mulu2_i64:
918 tci_args_rrrr(insn, &r0, &r1, &r2, &r3);
919 mulu64(&regs[r0], &regs[r1], regs[r2], regs[r3]);
920 break;
921 #endif
922 #if TCG_TARGET_HAS_muls2_i64
923 case INDEX_op_muls2_i64:
924 tci_args_rrrr(insn, &r0, &r1, &r2, &r3);
925 muls64(&regs[r0], &regs[r1], regs[r2], regs[r3]);
926 break;
927 #endif
928 #if TCG_TARGET_HAS_add2_i64
929 case INDEX_op_add2_i64:
930 tci_args_rrrrrr(insn, &r0, &r1, &r2, &r3, &r4, &r5);
931 T1 = regs[r2] + regs[r4];
932 T2 = regs[r3] + regs[r5] + (T1 < regs[r2]);
933 regs[r0] = T1;
934 regs[r1] = T2;
935 break;
936 #endif
937 #if TCG_TARGET_HAS_add2_i64
938 case INDEX_op_sub2_i64:
939 tci_args_rrrrrr(insn, &r0, &r1, &r2, &r3, &r4, &r5);
940 T1 = regs[r2] - regs[r4];
941 T2 = regs[r3] - regs[r5] - (regs[r2] < regs[r4]);
942 regs[r0] = T1;
943 regs[r1] = T2;
944 break;
945 #endif
946
947 /* Shift/rotate operations (64 bit). */
948
949 case INDEX_op_shl_i64:
950 tci_args_rrr(insn, &r0, &r1, &r2);
951 regs[r0] = regs[r1] << (regs[r2] & 63);
952 break;
953 case INDEX_op_shr_i64:
954 tci_args_rrr(insn, &r0, &r1, &r2);
955 regs[r0] = regs[r1] >> (regs[r2] & 63);
956 break;
957 case INDEX_op_sar_i64:
958 tci_args_rrr(insn, &r0, &r1, &r2);
959 regs[r0] = (int64_t)regs[r1] >> (regs[r2] & 63);
960 break;
961 #if TCG_TARGET_HAS_rot_i64
962 case INDEX_op_rotl_i64:
963 tci_args_rrr(insn, &r0, &r1, &r2);
964 regs[r0] = rol64(regs[r1], regs[r2] & 63);
965 break;
966 case INDEX_op_rotr_i64:
967 tci_args_rrr(insn, &r0, &r1, &r2);
968 regs[r0] = ror64(regs[r1], regs[r2] & 63);
969 break;
970 #endif
971 #if TCG_TARGET_HAS_deposit_i64
972 case INDEX_op_deposit_i64:
973 tci_args_rrrbb(insn, &r0, &r1, &r2, &pos, &len);
974 regs[r0] = deposit64(regs[r1], pos, len, regs[r2]);
975 break;
976 #endif
977 #if TCG_TARGET_HAS_extract_i64
978 case INDEX_op_extract_i64:
979 tci_args_rrbb(insn, &r0, &r1, &pos, &len);
980 regs[r0] = extract64(regs[r1], pos, len);
981 break;
982 #endif
983 #if TCG_TARGET_HAS_sextract_i64
984 case INDEX_op_sextract_i64:
985 tci_args_rrbb(insn, &r0, &r1, &pos, &len);
986 regs[r0] = sextract64(regs[r1], pos, len);
987 break;
988 #endif
989 case INDEX_op_brcond_i64:
990 tci_args_rl(insn, tb_ptr, &r0, &ptr);
991 if (regs[r0]) {
992 tb_ptr = ptr;
993 }
994 break;
995 case INDEX_op_ext32s_i64:
996 case INDEX_op_ext_i32_i64:
997 tci_args_rr(insn, &r0, &r1);
998 regs[r0] = (int32_t)regs[r1];
999 break;
1000 case INDEX_op_ext32u_i64:
1001 case INDEX_op_extu_i32_i64:
1002 tci_args_rr(insn, &r0, &r1);
1003 regs[r0] = (uint32_t)regs[r1];
1004 break;
1005 #if TCG_TARGET_HAS_bswap64_i64
1006 case INDEX_op_bswap64_i64:
1007 tci_args_rr(insn, &r0, &r1);
1008 regs[r0] = bswap64(regs[r1]);
1009 break;
1010 #endif
1011 #endif /* TCG_TARGET_REG_BITS == 64 */
1012
1013 /* QEMU specific operations. */
1014
1015 case INDEX_op_exit_tb:
1016 tci_args_l(insn, tb_ptr, &ptr);
1017 return (uintptr_t)ptr;
1018
1019 case INDEX_op_goto_tb:
1020 tci_args_l(insn, tb_ptr, &ptr);
1021 tb_ptr = *(void **)ptr;
1022 break;
1023
1024 case INDEX_op_goto_ptr:
1025 tci_args_r(insn, &r0);
1026 ptr = (void *)regs[r0];
1027 if (!ptr) {
1028 return 0;
1029 }
1030 tb_ptr = ptr;
1031 break;
1032
1033 case INDEX_op_qemu_ld_i32:
1034 if (TARGET_LONG_BITS <= TCG_TARGET_REG_BITS) {
1035 tci_args_rrm(insn, &r0, &r1, &oi);
1036 taddr = regs[r1];
1037 } else {
1038 tci_args_rrrm(insn, &r0, &r1, &r2, &oi);
1039 taddr = tci_uint64(regs[r2], regs[r1]);
1040 }
1041 tmp32 = tci_qemu_ld(env, taddr, oi, tb_ptr);
1042 regs[r0] = tmp32;
1043 break;
1044
1045 case INDEX_op_qemu_ld_i64:
1046 if (TCG_TARGET_REG_BITS == 64) {
1047 tci_args_rrm(insn, &r0, &r1, &oi);
1048 taddr = regs[r1];
1049 } else if (TARGET_LONG_BITS <= TCG_TARGET_REG_BITS) {
1050 tci_args_rrrm(insn, &r0, &r1, &r2, &oi);
1051 taddr = regs[r2];
1052 } else {
1053 tci_args_rrrrr(insn, &r0, &r1, &r2, &r3, &r4);
1054 taddr = tci_uint64(regs[r3], regs[r2]);
1055 oi = regs[r4];
1056 }
1057 tmp64 = tci_qemu_ld(env, taddr, oi, tb_ptr);
1058 if (TCG_TARGET_REG_BITS == 32) {
1059 tci_write_reg64(regs, r1, r0, tmp64);
1060 } else {
1061 regs[r0] = tmp64;
1062 }
1063 break;
1064
1065 case INDEX_op_qemu_st_i32:
1066 if (TARGET_LONG_BITS <= TCG_TARGET_REG_BITS) {
1067 tci_args_rrm(insn, &r0, &r1, &oi);
1068 taddr = regs[r1];
1069 } else {
1070 tci_args_rrrm(insn, &r0, &r1, &r2, &oi);
1071 taddr = tci_uint64(regs[r2], regs[r1]);
1072 }
1073 tmp32 = regs[r0];
1074 tci_qemu_st(env, taddr, tmp32, oi, tb_ptr);
1075 break;
1076
1077 case INDEX_op_qemu_st_i64:
1078 if (TCG_TARGET_REG_BITS == 64) {
1079 tci_args_rrm(insn, &r0, &r1, &oi);
1080 taddr = regs[r1];
1081 tmp64 = regs[r0];
1082 } else {
1083 if (TARGET_LONG_BITS <= TCG_TARGET_REG_BITS) {
1084 tci_args_rrrm(insn, &r0, &r1, &r2, &oi);
1085 taddr = regs[r2];
1086 } else {
1087 tci_args_rrrrr(insn, &r0, &r1, &r2, &r3, &r4);
1088 taddr = tci_uint64(regs[r3], regs[r2]);
1089 oi = regs[r4];
1090 }
1091 tmp64 = tci_uint64(regs[r1], regs[r0]);
1092 }
1093 tci_qemu_st(env, taddr, tmp64, oi, tb_ptr);
1094 break;
1095
1096 case INDEX_op_mb:
1097 /* Ensure ordering for all kinds */
1098 smp_mb();
1099 break;
1100 default:
1101 g_assert_not_reached();
1102 }
1103 }
1104 }
1105
1106 /*
1107 * Disassembler that matches the interpreter
1108 */
1109
1110 static const char *str_r(TCGReg r)
1111 {
1112 static const char regs[TCG_TARGET_NB_REGS][4] = {
1113 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1114 "r8", "r9", "r10", "r11", "r12", "r13", "env", "sp"
1115 };
1116
1117 QEMU_BUILD_BUG_ON(TCG_AREG0 != TCG_REG_R14);
1118 QEMU_BUILD_BUG_ON(TCG_REG_CALL_STACK != TCG_REG_R15);
1119
1120 assert((unsigned)r < TCG_TARGET_NB_REGS);
1121 return regs[r];
1122 }
1123
1124 static const char *str_c(TCGCond c)
1125 {
1126 static const char cond[16][8] = {
1127 [TCG_COND_NEVER] = "never",
1128 [TCG_COND_ALWAYS] = "always",
1129 [TCG_COND_EQ] = "eq",
1130 [TCG_COND_NE] = "ne",
1131 [TCG_COND_LT] = "lt",
1132 [TCG_COND_GE] = "ge",
1133 [TCG_COND_LE] = "le",
1134 [TCG_COND_GT] = "gt",
1135 [TCG_COND_LTU] = "ltu",
1136 [TCG_COND_GEU] = "geu",
1137 [TCG_COND_LEU] = "leu",
1138 [TCG_COND_GTU] = "gtu",
1139 };
1140
1141 assert((unsigned)c < ARRAY_SIZE(cond));
1142 assert(cond[c][0] != 0);
1143 return cond[c];
1144 }
1145
1146 /* Disassemble TCI bytecode. */
1147 int print_insn_tci(bfd_vma addr, disassemble_info *info)
1148 {
1149 const uint32_t *tb_ptr = (const void *)(uintptr_t)addr;
1150 const TCGOpDef *def;
1151 const char *op_name;
1152 uint32_t insn;
1153 TCGOpcode op;
1154 TCGReg r0, r1, r2, r3, r4, r5;
1155 tcg_target_ulong i1;
1156 int32_t s2;
1157 TCGCond c;
1158 MemOpIdx oi;
1159 uint8_t pos, len;
1160 void *ptr;
1161
1162 /* TCI is always the host, so we don't need to load indirect. */
1163 insn = *tb_ptr++;
1164
1165 info->fprintf_func(info->stream, "%08x ", insn);
1166
1167 op = extract32(insn, 0, 8);
1168 def = &tcg_op_defs[op];
1169 op_name = def->name;
1170
1171 switch (op) {
1172 case INDEX_op_br:
1173 case INDEX_op_exit_tb:
1174 case INDEX_op_goto_tb:
1175 tci_args_l(insn, tb_ptr, &ptr);
1176 info->fprintf_func(info->stream, "%-12s %p", op_name, ptr);
1177 break;
1178
1179 case INDEX_op_goto_ptr:
1180 tci_args_r(insn, &r0);
1181 info->fprintf_func(info->stream, "%-12s %s", op_name, str_r(r0));
1182 break;
1183
1184 case INDEX_op_call:
1185 tci_args_nl(insn, tb_ptr, &len, &ptr);
1186 info->fprintf_func(info->stream, "%-12s %d, %p", op_name, len, ptr);
1187 break;
1188
1189 case INDEX_op_brcond_i32:
1190 case INDEX_op_brcond_i64:
1191 tci_args_rl(insn, tb_ptr, &r0, &ptr);
1192 info->fprintf_func(info->stream, "%-12s %s, 0, ne, %p",
1193 op_name, str_r(r0), ptr);
1194 break;
1195
1196 case INDEX_op_setcond_i32:
1197 case INDEX_op_setcond_i64:
1198 tci_args_rrrc(insn, &r0, &r1, &r2, &c);
1199 info->fprintf_func(info->stream, "%-12s %s, %s, %s, %s",
1200 op_name, str_r(r0), str_r(r1), str_r(r2), str_c(c));
1201 break;
1202
1203 case INDEX_op_tci_movi:
1204 tci_args_ri(insn, &r0, &i1);
1205 info->fprintf_func(info->stream, "%-12s %s, 0x%" TCG_PRIlx,
1206 op_name, str_r(r0), i1);
1207 break;
1208
1209 case INDEX_op_tci_movl:
1210 tci_args_rl(insn, tb_ptr, &r0, &ptr);
1211 info->fprintf_func(info->stream, "%-12s %s, %p",
1212 op_name, str_r(r0), ptr);
1213 break;
1214
1215 case INDEX_op_ld8u_i32:
1216 case INDEX_op_ld8u_i64:
1217 case INDEX_op_ld8s_i32:
1218 case INDEX_op_ld8s_i64:
1219 case INDEX_op_ld16u_i32:
1220 case INDEX_op_ld16u_i64:
1221 case INDEX_op_ld16s_i32:
1222 case INDEX_op_ld16s_i64:
1223 case INDEX_op_ld32u_i64:
1224 case INDEX_op_ld32s_i64:
1225 case INDEX_op_ld_i32:
1226 case INDEX_op_ld_i64:
1227 case INDEX_op_st8_i32:
1228 case INDEX_op_st8_i64:
1229 case INDEX_op_st16_i32:
1230 case INDEX_op_st16_i64:
1231 case INDEX_op_st32_i64:
1232 case INDEX_op_st_i32:
1233 case INDEX_op_st_i64:
1234 tci_args_rrs(insn, &r0, &r1, &s2);
1235 info->fprintf_func(info->stream, "%-12s %s, %s, %d",
1236 op_name, str_r(r0), str_r(r1), s2);
1237 break;
1238
1239 case INDEX_op_mov_i32:
1240 case INDEX_op_mov_i64:
1241 case INDEX_op_ext8s_i32:
1242 case INDEX_op_ext8s_i64:
1243 case INDEX_op_ext8u_i32:
1244 case INDEX_op_ext8u_i64:
1245 case INDEX_op_ext16s_i32:
1246 case INDEX_op_ext16s_i64:
1247 case INDEX_op_ext16u_i32:
1248 case INDEX_op_ext32s_i64:
1249 case INDEX_op_ext32u_i64:
1250 case INDEX_op_ext_i32_i64:
1251 case INDEX_op_extu_i32_i64:
1252 case INDEX_op_bswap16_i32:
1253 case INDEX_op_bswap16_i64:
1254 case INDEX_op_bswap32_i32:
1255 case INDEX_op_bswap32_i64:
1256 case INDEX_op_bswap64_i64:
1257 case INDEX_op_not_i32:
1258 case INDEX_op_not_i64:
1259 case INDEX_op_neg_i32:
1260 case INDEX_op_neg_i64:
1261 case INDEX_op_ctpop_i32:
1262 case INDEX_op_ctpop_i64:
1263 tci_args_rr(insn, &r0, &r1);
1264 info->fprintf_func(info->stream, "%-12s %s, %s",
1265 op_name, str_r(r0), str_r(r1));
1266 break;
1267
1268 case INDEX_op_add_i32:
1269 case INDEX_op_add_i64:
1270 case INDEX_op_sub_i32:
1271 case INDEX_op_sub_i64:
1272 case INDEX_op_mul_i32:
1273 case INDEX_op_mul_i64:
1274 case INDEX_op_and_i32:
1275 case INDEX_op_and_i64:
1276 case INDEX_op_or_i32:
1277 case INDEX_op_or_i64:
1278 case INDEX_op_xor_i32:
1279 case INDEX_op_xor_i64:
1280 case INDEX_op_andc_i32:
1281 case INDEX_op_andc_i64:
1282 case INDEX_op_orc_i32:
1283 case INDEX_op_orc_i64:
1284 case INDEX_op_eqv_i32:
1285 case INDEX_op_eqv_i64:
1286 case INDEX_op_nand_i32:
1287 case INDEX_op_nand_i64:
1288 case INDEX_op_nor_i32:
1289 case INDEX_op_nor_i64:
1290 case INDEX_op_div_i32:
1291 case INDEX_op_div_i64:
1292 case INDEX_op_rem_i32:
1293 case INDEX_op_rem_i64:
1294 case INDEX_op_divu_i32:
1295 case INDEX_op_divu_i64:
1296 case INDEX_op_remu_i32:
1297 case INDEX_op_remu_i64:
1298 case INDEX_op_shl_i32:
1299 case INDEX_op_shl_i64:
1300 case INDEX_op_shr_i32:
1301 case INDEX_op_shr_i64:
1302 case INDEX_op_sar_i32:
1303 case INDEX_op_sar_i64:
1304 case INDEX_op_rotl_i32:
1305 case INDEX_op_rotl_i64:
1306 case INDEX_op_rotr_i32:
1307 case INDEX_op_rotr_i64:
1308 case INDEX_op_clz_i32:
1309 case INDEX_op_clz_i64:
1310 case INDEX_op_ctz_i32:
1311 case INDEX_op_ctz_i64:
1312 tci_args_rrr(insn, &r0, &r1, &r2);
1313 info->fprintf_func(info->stream, "%-12s %s, %s, %s",
1314 op_name, str_r(r0), str_r(r1), str_r(r2));
1315 break;
1316
1317 case INDEX_op_deposit_i32:
1318 case INDEX_op_deposit_i64:
1319 tci_args_rrrbb(insn, &r0, &r1, &r2, &pos, &len);
1320 info->fprintf_func(info->stream, "%-12s %s, %s, %s, %d, %d",
1321 op_name, str_r(r0), str_r(r1), str_r(r2), pos, len);
1322 break;
1323
1324 case INDEX_op_extract_i32:
1325 case INDEX_op_extract_i64:
1326 case INDEX_op_sextract_i32:
1327 case INDEX_op_sextract_i64:
1328 tci_args_rrbb(insn, &r0, &r1, &pos, &len);
1329 info->fprintf_func(info->stream, "%-12s %s,%s,%d,%d",
1330 op_name, str_r(r0), str_r(r1), pos, len);
1331 break;
1332
1333 case INDEX_op_movcond_i32:
1334 case INDEX_op_movcond_i64:
1335 case INDEX_op_setcond2_i32:
1336 tci_args_rrrrrc(insn, &r0, &r1, &r2, &r3, &r4, &c);
1337 info->fprintf_func(info->stream, "%-12s %s, %s, %s, %s, %s, %s",
1338 op_name, str_r(r0), str_r(r1), str_r(r2),
1339 str_r(r3), str_r(r4), str_c(c));
1340 break;
1341
1342 case INDEX_op_mulu2_i32:
1343 case INDEX_op_mulu2_i64:
1344 case INDEX_op_muls2_i32:
1345 case INDEX_op_muls2_i64:
1346 tci_args_rrrr(insn, &r0, &r1, &r2, &r3);
1347 info->fprintf_func(info->stream, "%-12s %s, %s, %s, %s",
1348 op_name, str_r(r0), str_r(r1),
1349 str_r(r2), str_r(r3));
1350 break;
1351
1352 case INDEX_op_add2_i32:
1353 case INDEX_op_add2_i64:
1354 case INDEX_op_sub2_i32:
1355 case INDEX_op_sub2_i64:
1356 tci_args_rrrrrr(insn, &r0, &r1, &r2, &r3, &r4, &r5);
1357 info->fprintf_func(info->stream, "%-12s %s, %s, %s, %s, %s, %s",
1358 op_name, str_r(r0), str_r(r1), str_r(r2),
1359 str_r(r3), str_r(r4), str_r(r5));
1360 break;
1361
1362 case INDEX_op_qemu_ld_i64:
1363 case INDEX_op_qemu_st_i64:
1364 len = DIV_ROUND_UP(64, TCG_TARGET_REG_BITS);
1365 goto do_qemu_ldst;
1366 case INDEX_op_qemu_ld_i32:
1367 case INDEX_op_qemu_st_i32:
1368 len = 1;
1369 do_qemu_ldst:
1370 len += DIV_ROUND_UP(TARGET_LONG_BITS, TCG_TARGET_REG_BITS);
1371 switch (len) {
1372 case 2:
1373 tci_args_rrm(insn, &r0, &r1, &oi);
1374 info->fprintf_func(info->stream, "%-12s %s, %s, %x",
1375 op_name, str_r(r0), str_r(r1), oi);
1376 break;
1377 case 3:
1378 tci_args_rrrm(insn, &r0, &r1, &r2, &oi);
1379 info->fprintf_func(info->stream, "%-12s %s, %s, %s, %x",
1380 op_name, str_r(r0), str_r(r1), str_r(r2), oi);
1381 break;
1382 case 4:
1383 tci_args_rrrrr(insn, &r0, &r1, &r2, &r3, &r4);
1384 info->fprintf_func(info->stream, "%-12s %s, %s, %s, %s, %s",
1385 op_name, str_r(r0), str_r(r1),
1386 str_r(r2), str_r(r3), str_r(r4));
1387 break;
1388 default:
1389 g_assert_not_reached();
1390 }
1391 break;
1392
1393 case 0:
1394 /* tcg_out_nop_fill uses zeros */
1395 if (insn == 0) {
1396 info->fprintf_func(info->stream, "align");
1397 break;
1398 }
1399 /* fall through */
1400
1401 default:
1402 info->fprintf_func(info->stream, "illegal opcode %d", op);
1403 break;
1404 }
1405
1406 return sizeof(insn);
1407 }
AR7 emulation for QEMU