]> git.proxmox.com Git - qemu.git/blame_incremental - tci.c
projects / qemu.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
pflash_cfi01: remove unused total_len field
[qemu.git] / tci.c
... / ...
CommitLineData
1/*
2 * Tiny Code Interpreter for QEMU
3 *
4 * Copyright (c) 2009, 2011 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 "config.h"
21
22/* Defining NDEBUG disables assertions (which makes the code faster). */
23#if !defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG)
24# define NDEBUG
25#endif
26
27#include "qemu-common.h"
28#include "exec-all.h" /* MAX_OPC_PARAM_IARGS */
29#include "tcg-op.h"
30
31/* Marker for missing code. */
32#define TODO() \
33 do { \
34 fprintf(stderr, "TODO %s:%u: %s()\n", \
35 __FILE__, __LINE__, __func__); \
36 tcg_abort(); \
37 } while (0)
38
39#if MAX_OPC_PARAM_IARGS != 5
40# error Fix needed, number of supported input arguments changed!
41#endif
42#if TCG_TARGET_REG_BITS == 32
43typedef uint64_t (*helper_function)(tcg_target_ulong, tcg_target_ulong,
44 tcg_target_ulong, tcg_target_ulong,
45 tcg_target_ulong, tcg_target_ulong,
46 tcg_target_ulong, tcg_target_ulong,
47 tcg_target_ulong, tcg_target_ulong);
48#else
49typedef uint64_t (*helper_function)(tcg_target_ulong, tcg_target_ulong,
50 tcg_target_ulong, tcg_target_ulong,
51 tcg_target_ulong);
52#endif
53
54/* TCI can optionally use a global register variable for env. */
55#if !defined(AREG0)
56CPUArchState *env;
57#endif
58
59/* Targets which don't use GETPC also don't need tci_tb_ptr
60 which makes them a little faster. */
61#if defined(GETPC)
62uintptr_t tci_tb_ptr;
63#endif
64
65static tcg_target_ulong tci_reg[TCG_TARGET_NB_REGS];
66
67static tcg_target_ulong tci_read_reg(TCGReg index)
68{
69 assert(index < ARRAY_SIZE(tci_reg));
70 return tci_reg[index];
71}
72
73#if TCG_TARGET_HAS_ext8s_i32 || TCG_TARGET_HAS_ext8s_i64
74static int8_t tci_read_reg8s(TCGReg index)
75{
76 return (int8_t)tci_read_reg(index);
77}
78#endif
79
80#if TCG_TARGET_HAS_ext16s_i32 || TCG_TARGET_HAS_ext16s_i64
81static int16_t tci_read_reg16s(TCGReg index)
82{
83 return (int16_t)tci_read_reg(index);
84}
85#endif
86
87#if TCG_TARGET_REG_BITS == 64
88static int32_t tci_read_reg32s(TCGReg index)
89{
90 return (int32_t)tci_read_reg(index);
91}
92#endif
93
94static uint8_t tci_read_reg8(TCGReg index)
95{
96 return (uint8_t)tci_read_reg(index);
97}
98
99static uint16_t tci_read_reg16(TCGReg index)
100{
101 return (uint16_t)tci_read_reg(index);
102}
103
104static uint32_t tci_read_reg32(TCGReg index)
105{
106 return (uint32_t)tci_read_reg(index);
107}
108
109#if TCG_TARGET_REG_BITS == 64
110static uint64_t tci_read_reg64(TCGReg index)
111{
112 return tci_read_reg(index);
113}
114#endif
115
116static void tci_write_reg(TCGReg index, tcg_target_ulong value)
117{
118 assert(index < ARRAY_SIZE(tci_reg));
119 assert(index != TCG_AREG0);
120 tci_reg[index] = value;
121}
122
123static void tci_write_reg8s(TCGReg index, int8_t value)
124{
125 tci_write_reg(index, value);
126}
127
128static void tci_write_reg16s(TCGReg index, int16_t value)
129{
130 tci_write_reg(index, value);
131}
132
133#if TCG_TARGET_REG_BITS == 64
134static void tci_write_reg32s(TCGReg index, int32_t value)
135{
136 tci_write_reg(index, value);
137}
138#endif
139
140static void tci_write_reg8(TCGReg index, uint8_t value)
141{
142 tci_write_reg(index, value);
143}
144
145static void tci_write_reg16(TCGReg index, uint16_t value)
146{
147 tci_write_reg(index, value);
148}
149
150static void tci_write_reg32(TCGReg index, uint32_t value)
151{
152 tci_write_reg(index, value);
153}
154
155#if TCG_TARGET_REG_BITS == 32
156static void tci_write_reg64(uint32_t high_index, uint32_t low_index,
157 uint64_t value)
158{
159 tci_write_reg(low_index, value);
160 tci_write_reg(high_index, value >> 32);
161}
162#elif TCG_TARGET_REG_BITS == 64
163static void tci_write_reg64(TCGReg index, uint64_t value)
164{
165 tci_write_reg(index, value);
166}
167#endif
168
169#if TCG_TARGET_REG_BITS == 32
170/* Create a 64 bit value from two 32 bit values. */
171static uint64_t tci_uint64(uint32_t high, uint32_t low)
172{
173 return ((uint64_t)high << 32) + low;
174}
175#endif
176
177/* Read constant (native size) from bytecode. */
178static tcg_target_ulong tci_read_i(uint8_t **tb_ptr)
179{
180 tcg_target_ulong value = *(tcg_target_ulong *)(*tb_ptr);
181 *tb_ptr += sizeof(value);
182 return value;
183}
184
185/* Read constant (32 bit) from bytecode. */
186static uint32_t tci_read_i32(uint8_t **tb_ptr)
187{
188 uint32_t value = *(uint32_t *)(*tb_ptr);
189 *tb_ptr += sizeof(value);
190 return value;
191}
192
193#if TCG_TARGET_REG_BITS == 64
194/* Read constant (64 bit) from bytecode. */
195static uint64_t tci_read_i64(uint8_t **tb_ptr)
196{
197 uint64_t value = *(uint64_t *)(*tb_ptr);
198 *tb_ptr += sizeof(value);
199 return value;
200}
201#endif
202
203/* Read indexed register (native size) from bytecode. */
204static tcg_target_ulong tci_read_r(uint8_t **tb_ptr)
205{
206 tcg_target_ulong value = tci_read_reg(**tb_ptr);
207 *tb_ptr += 1;
208 return value;
209}
210
211/* Read indexed register (8 bit) from bytecode. */
212static uint8_t tci_read_r8(uint8_t **tb_ptr)
213{
214 uint8_t value = tci_read_reg8(**tb_ptr);
215 *tb_ptr += 1;
216 return value;
217}
218
219#if TCG_TARGET_HAS_ext8s_i32 || TCG_TARGET_HAS_ext8s_i64
220/* Read indexed register (8 bit signed) from bytecode. */
221static int8_t tci_read_r8s(uint8_t **tb_ptr)
222{
223 int8_t value = tci_read_reg8s(**tb_ptr);
224 *tb_ptr += 1;
225 return value;
226}
227#endif
228
229/* Read indexed register (16 bit) from bytecode. */
230static uint16_t tci_read_r16(uint8_t **tb_ptr)
231{
232 uint16_t value = tci_read_reg16(**tb_ptr);
233 *tb_ptr += 1;
234 return value;
235}
236
237#if TCG_TARGET_HAS_ext16s_i32 || TCG_TARGET_HAS_ext16s_i64
238/* Read indexed register (16 bit signed) from bytecode. */
239static int16_t tci_read_r16s(uint8_t **tb_ptr)
240{
241 int16_t value = tci_read_reg16s(**tb_ptr);
242 *tb_ptr += 1;
243 return value;
244}
245#endif
246
247/* Read indexed register (32 bit) from bytecode. */
248static uint32_t tci_read_r32(uint8_t **tb_ptr)
249{
250 uint32_t value = tci_read_reg32(**tb_ptr);
251 *tb_ptr += 1;
252 return value;
253}
254
255#if TCG_TARGET_REG_BITS == 32
256/* Read two indexed registers (2 * 32 bit) from bytecode. */
257static uint64_t tci_read_r64(uint8_t **tb_ptr)
258{
259 uint32_t low = tci_read_r32(tb_ptr);
260 return tci_uint64(tci_read_r32(tb_ptr), low);
261}
262#elif TCG_TARGET_REG_BITS == 64
263/* Read indexed register (32 bit signed) from bytecode. */
264static int32_t tci_read_r32s(uint8_t **tb_ptr)
265{
266 int32_t value = tci_read_reg32s(**tb_ptr);
267 *tb_ptr += 1;
268 return value;
269}
270
271/* Read indexed register (64 bit) from bytecode. */
272static uint64_t tci_read_r64(uint8_t **tb_ptr)
273{
274 uint64_t value = tci_read_reg64(**tb_ptr);
275 *tb_ptr += 1;
276 return value;
277}
278#endif
279
280/* Read indexed register(s) with target address from bytecode. */
281static target_ulong tci_read_ulong(uint8_t **tb_ptr)
282{
283 target_ulong taddr = tci_read_r(tb_ptr);
284#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
285 taddr += (uint64_t)tci_read_r(tb_ptr) << 32;
286#endif
287 return taddr;
288}
289
290/* Read indexed register or constant (native size) from bytecode. */
291static tcg_target_ulong tci_read_ri(uint8_t **tb_ptr)
292{
293 tcg_target_ulong value;
294 TCGReg r = **tb_ptr;
295 *tb_ptr += 1;
296 if (r == TCG_CONST) {
297 value = tci_read_i(tb_ptr);
298 } else {
299 value = tci_read_reg(r);
300 }
301 return value;
302}
303
304/* Read indexed register or constant (32 bit) from bytecode. */
305static uint32_t tci_read_ri32(uint8_t **tb_ptr)
306{
307 uint32_t value;
308 TCGReg r = **tb_ptr;
309 *tb_ptr += 1;
310 if (r == TCG_CONST) {
311 value = tci_read_i32(tb_ptr);
312 } else {
313 value = tci_read_reg32(r);
314 }
315 return value;
316}
317
318#if TCG_TARGET_REG_BITS == 32
319/* Read two indexed registers or constants (2 * 32 bit) from bytecode. */
320static uint64_t tci_read_ri64(uint8_t **tb_ptr)
321{
322 uint32_t low = tci_read_ri32(tb_ptr);
323 return tci_uint64(tci_read_ri32(tb_ptr), low);
324}
325#elif TCG_TARGET_REG_BITS == 64
326/* Read indexed register or constant (64 bit) from bytecode. */
327static uint64_t tci_read_ri64(uint8_t **tb_ptr)
328{
329 uint64_t value;
330 TCGReg r = **tb_ptr;
331 *tb_ptr += 1;
332 if (r == TCG_CONST) {
333 value = tci_read_i64(tb_ptr);
334 } else {
335 value = tci_read_reg64(r);
336 }
337 return value;
338}
339#endif
340
341static target_ulong tci_read_label(uint8_t **tb_ptr)
342{
343 target_ulong label = tci_read_i(tb_ptr);
344 assert(label != 0);
345 return label;
346}
347
348static bool tci_compare32(uint32_t u0, uint32_t u1, TCGCond condition)
349{
350 bool result = false;
351 int32_t i0 = u0;
352 int32_t i1 = u1;
353 switch (condition) {
354 case TCG_COND_EQ:
355 result = (u0 == u1);
356 break;
357 case TCG_COND_NE:
358 result = (u0 != u1);
359 break;
360 case TCG_COND_LT:
361 result = (i0 < i1);
362 break;
363 case TCG_COND_GE:
364 result = (i0 >= i1);
365 break;
366 case TCG_COND_LE:
367 result = (i0 <= i1);
368 break;
369 case TCG_COND_GT:
370 result = (i0 > i1);
371 break;
372 case TCG_COND_LTU:
373 result = (u0 < u1);
374 break;
375 case TCG_COND_GEU:
376 result = (u0 >= u1);
377 break;
378 case TCG_COND_LEU:
379 result = (u0 <= u1);
380 break;
381 case TCG_COND_GTU:
382 result = (u0 > u1);
383 break;
384 default:
385 TODO();
386 }
387 return result;
388}
389
390static bool tci_compare64(uint64_t u0, uint64_t u1, TCGCond condition)
391{
392 bool result = false;
393 int64_t i0 = u0;
394 int64_t i1 = u1;
395 switch (condition) {
396 case TCG_COND_EQ:
397 result = (u0 == u1);
398 break;
399 case TCG_COND_NE:
400 result = (u0 != u1);
401 break;
402 case TCG_COND_LT:
403 result = (i0 < i1);
404 break;
405 case TCG_COND_GE:
406 result = (i0 >= i1);
407 break;
408 case TCG_COND_LE:
409 result = (i0 <= i1);
410 break;
411 case TCG_COND_GT:
412 result = (i0 > i1);
413 break;
414 case TCG_COND_LTU:
415 result = (u0 < u1);
416 break;
417 case TCG_COND_GEU:
418 result = (u0 >= u1);
419 break;
420 case TCG_COND_LEU:
421 result = (u0 <= u1);
422 break;
423 case TCG_COND_GTU:
424 result = (u0 > u1);
425 break;
426 default:
427 TODO();
428 }
429 return result;
430}
431
432/* Interpret pseudo code in tb. */
433tcg_target_ulong tcg_qemu_tb_exec(CPUArchState *cpustate, uint8_t *tb_ptr)
434{
435 tcg_target_ulong next_tb = 0;
436
437 env = cpustate;
438 tci_reg[TCG_AREG0] = (tcg_target_ulong)env;
439 assert(tb_ptr);
440
441 for (;;) {
442#if defined(GETPC)
443 tci_tb_ptr = (uintptr_t)tb_ptr;
444#endif
445 TCGOpcode opc = tb_ptr[0];
446#if !defined(NDEBUG)
447 uint8_t op_size = tb_ptr[1];
448 uint8_t *old_code_ptr = tb_ptr;
449#endif
450 tcg_target_ulong t0;
451 tcg_target_ulong t1;
452 tcg_target_ulong t2;
453 tcg_target_ulong label;
454 TCGCond condition;
455 target_ulong taddr;
456#ifndef CONFIG_SOFTMMU
457 tcg_target_ulong host_addr;
458#endif
459 uint8_t tmp8;
460 uint16_t tmp16;
461 uint32_t tmp32;
462 uint64_t tmp64;
463#if TCG_TARGET_REG_BITS == 32
464 uint64_t v64;
465#endif
466
467 /* Skip opcode and size entry. */
468 tb_ptr += 2;
469
470 switch (opc) {
471 case INDEX_op_end:
472 case INDEX_op_nop:
473 break;
474 case INDEX_op_nop1:
475 case INDEX_op_nop2:
476 case INDEX_op_nop3:
477 case INDEX_op_nopn:
478 case INDEX_op_discard:
479 TODO();
480 break;
481 case INDEX_op_set_label:
482 TODO();
483 break;
484 case INDEX_op_call:
485 t0 = tci_read_ri(&tb_ptr);
486#if TCG_TARGET_REG_BITS == 32
487 tmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),
488 tci_read_reg(TCG_REG_R1),
489 tci_read_reg(TCG_REG_R2),
490 tci_read_reg(TCG_REG_R3),
491 tci_read_reg(TCG_REG_R5),
492 tci_read_reg(TCG_REG_R6),
493 tci_read_reg(TCG_REG_R7),
494 tci_read_reg(TCG_REG_R8),
495 tci_read_reg(TCG_REG_R9),
496 tci_read_reg(TCG_REG_R10));
497 tci_write_reg(TCG_REG_R0, tmp64);
498 tci_write_reg(TCG_REG_R1, tmp64 >> 32);
499#else
500 tmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),
501 tci_read_reg(TCG_REG_R1),
502 tci_read_reg(TCG_REG_R2),
503 tci_read_reg(TCG_REG_R3),
504 tci_read_reg(TCG_REG_R5));
505 tci_write_reg(TCG_REG_R0, tmp64);
506#endif
507 break;
508 case INDEX_op_br:
509 label = tci_read_label(&tb_ptr);
510 assert(tb_ptr == old_code_ptr + op_size);
511 tb_ptr = (uint8_t *)label;
512 continue;
513 case INDEX_op_setcond_i32:
514 t0 = *tb_ptr++;
515 t1 = tci_read_r32(&tb_ptr);
516 t2 = tci_read_ri32(&tb_ptr);
517 condition = *tb_ptr++;
518 tci_write_reg32(t0, tci_compare32(t1, t2, condition));
519 break;
520#if TCG_TARGET_REG_BITS == 32
521 case INDEX_op_setcond2_i32:
522 t0 = *tb_ptr++;
523 tmp64 = tci_read_r64(&tb_ptr);
524 v64 = tci_read_ri64(&tb_ptr);
525 condition = *tb_ptr++;
526 tci_write_reg32(t0, tci_compare64(tmp64, v64, condition));
527 break;
528#elif TCG_TARGET_REG_BITS == 64
529 case INDEX_op_setcond_i64:
530 t0 = *tb_ptr++;
531 t1 = tci_read_r64(&tb_ptr);
532 t2 = tci_read_ri64(&tb_ptr);
533 condition = *tb_ptr++;
534 tci_write_reg64(t0, tci_compare64(t1, t2, condition));
535 break;
536#endif
537 case INDEX_op_mov_i32:
538 t0 = *tb_ptr++;
539 t1 = tci_read_r32(&tb_ptr);
540 tci_write_reg32(t0, t1);
541 break;
542 case INDEX_op_movi_i32:
543 t0 = *tb_ptr++;
544 t1 = tci_read_i32(&tb_ptr);
545 tci_write_reg32(t0, t1);
546 break;
547
548 /* Load/store operations (32 bit). */
549
550 case INDEX_op_ld8u_i32:
551 t0 = *tb_ptr++;
552 t1 = tci_read_r(&tb_ptr);
553 t2 = tci_read_i32(&tb_ptr);
554 tci_write_reg8(t0, *(uint8_t *)(t1 + t2));
555 break;
556 case INDEX_op_ld8s_i32:
557 case INDEX_op_ld16u_i32:
558 TODO();
559 break;
560 case INDEX_op_ld16s_i32:
561 TODO();
562 break;
563 case INDEX_op_ld_i32:
564 t0 = *tb_ptr++;
565 t1 = tci_read_r(&tb_ptr);
566 t2 = tci_read_i32(&tb_ptr);
567 tci_write_reg32(t0, *(uint32_t *)(t1 + t2));
568 break;
569 case INDEX_op_st8_i32:
570 t0 = tci_read_r8(&tb_ptr);
571 t1 = tci_read_r(&tb_ptr);
572 t2 = tci_read_i32(&tb_ptr);
573 *(uint8_t *)(t1 + t2) = t0;
574 break;
575 case INDEX_op_st16_i32:
576 t0 = tci_read_r16(&tb_ptr);
577 t1 = tci_read_r(&tb_ptr);
578 t2 = tci_read_i32(&tb_ptr);
579 *(uint16_t *)(t1 + t2) = t0;
580 break;
581 case INDEX_op_st_i32:
582 t0 = tci_read_r32(&tb_ptr);
583 t1 = tci_read_r(&tb_ptr);
584 t2 = tci_read_i32(&tb_ptr);
585 *(uint32_t *)(t1 + t2) = t0;
586 break;
587
588 /* Arithmetic operations (32 bit). */
589
590 case INDEX_op_add_i32:
591 t0 = *tb_ptr++;
592 t1 = tci_read_ri32(&tb_ptr);
593 t2 = tci_read_ri32(&tb_ptr);
594 tci_write_reg32(t0, t1 + t2);
595 break;
596 case INDEX_op_sub_i32:
597 t0 = *tb_ptr++;
598 t1 = tci_read_ri32(&tb_ptr);
599 t2 = tci_read_ri32(&tb_ptr);
600 tci_write_reg32(t0, t1 - t2);
601 break;
602 case INDEX_op_mul_i32:
603 t0 = *tb_ptr++;
604 t1 = tci_read_ri32(&tb_ptr);
605 t2 = tci_read_ri32(&tb_ptr);
606 tci_write_reg32(t0, t1 * t2);
607 break;
608#if TCG_TARGET_HAS_div_i32
609 case INDEX_op_div_i32:
610 t0 = *tb_ptr++;
611 t1 = tci_read_ri32(&tb_ptr);
612 t2 = tci_read_ri32(&tb_ptr);
613 tci_write_reg32(t0, (int32_t)t1 / (int32_t)t2);
614 break;
615 case INDEX_op_divu_i32:
616 t0 = *tb_ptr++;
617 t1 = tci_read_ri32(&tb_ptr);
618 t2 = tci_read_ri32(&tb_ptr);
619 tci_write_reg32(t0, t1 / t2);
620 break;
621 case INDEX_op_rem_i32:
622 t0 = *tb_ptr++;
623 t1 = tci_read_ri32(&tb_ptr);
624 t2 = tci_read_ri32(&tb_ptr);
625 tci_write_reg32(t0, (int32_t)t1 % (int32_t)t2);
626 break;
627 case INDEX_op_remu_i32:
628 t0 = *tb_ptr++;
629 t1 = tci_read_ri32(&tb_ptr);
630 t2 = tci_read_ri32(&tb_ptr);
631 tci_write_reg32(t0, t1 % t2);
632 break;
633#elif TCG_TARGET_HAS_div2_i32
634 case INDEX_op_div2_i32:
635 case INDEX_op_divu2_i32:
636 TODO();
637 break;
638#endif
639 case INDEX_op_and_i32:
640 t0 = *tb_ptr++;
641 t1 = tci_read_ri32(&tb_ptr);
642 t2 = tci_read_ri32(&tb_ptr);
643 tci_write_reg32(t0, t1 & t2);
644 break;
645 case INDEX_op_or_i32:
646 t0 = *tb_ptr++;
647 t1 = tci_read_ri32(&tb_ptr);
648 t2 = tci_read_ri32(&tb_ptr);
649 tci_write_reg32(t0, t1 | t2);
650 break;
651 case INDEX_op_xor_i32:
652 t0 = *tb_ptr++;
653 t1 = tci_read_ri32(&tb_ptr);
654 t2 = tci_read_ri32(&tb_ptr);
655 tci_write_reg32(t0, t1 ^ t2);
656 break;
657
658 /* Shift/rotate operations (32 bit). */
659
660 case INDEX_op_shl_i32:
661 t0 = *tb_ptr++;
662 t1 = tci_read_ri32(&tb_ptr);
663 t2 = tci_read_ri32(&tb_ptr);
664 tci_write_reg32(t0, t1 << t2);
665 break;
666 case INDEX_op_shr_i32:
667 t0 = *tb_ptr++;
668 t1 = tci_read_ri32(&tb_ptr);
669 t2 = tci_read_ri32(&tb_ptr);
670 tci_write_reg32(t0, t1 >> t2);
671 break;
672 case INDEX_op_sar_i32:
673 t0 = *tb_ptr++;
674 t1 = tci_read_ri32(&tb_ptr);
675 t2 = tci_read_ri32(&tb_ptr);
676 tci_write_reg32(t0, ((int32_t)t1 >> t2));
677 break;
678#if TCG_TARGET_HAS_rot_i32
679 case INDEX_op_rotl_i32:
680 t0 = *tb_ptr++;
681 t1 = tci_read_ri32(&tb_ptr);
682 t2 = tci_read_ri32(&tb_ptr);
683 tci_write_reg32(t0, (t1 << t2) | (t1 >> (32 - t2)));
684 break;
685 case INDEX_op_rotr_i32:
686 t0 = *tb_ptr++;
687 t1 = tci_read_ri32(&tb_ptr);
688 t2 = tci_read_ri32(&tb_ptr);
689 tci_write_reg32(t0, (t1 >> t2) | (t1 << (32 - t2)));
690 break;
691#endif
692 case INDEX_op_brcond_i32:
693 t0 = tci_read_r32(&tb_ptr);
694 t1 = tci_read_ri32(&tb_ptr);
695 condition = *tb_ptr++;
696 label = tci_read_label(&tb_ptr);
697 if (tci_compare32(t0, t1, condition)) {
698 assert(tb_ptr == old_code_ptr + op_size);
699 tb_ptr = (uint8_t *)label;
700 continue;
701 }
702 break;
703#if TCG_TARGET_REG_BITS == 32
704 case INDEX_op_add2_i32:
705 t0 = *tb_ptr++;
706 t1 = *tb_ptr++;
707 tmp64 = tci_read_r64(&tb_ptr);
708 tmp64 += tci_read_r64(&tb_ptr);
709 tci_write_reg64(t1, t0, tmp64);
710 break;
711 case INDEX_op_sub2_i32:
712 t0 = *tb_ptr++;
713 t1 = *tb_ptr++;
714 tmp64 = tci_read_r64(&tb_ptr);
715 tmp64 -= tci_read_r64(&tb_ptr);
716 tci_write_reg64(t1, t0, tmp64);
717 break;
718 case INDEX_op_brcond2_i32:
719 tmp64 = tci_read_r64(&tb_ptr);
720 v64 = tci_read_ri64(&tb_ptr);
721 condition = *tb_ptr++;
722 label = tci_read_label(&tb_ptr);
723 if (tci_compare64(tmp64, v64, condition)) {
724 assert(tb_ptr == old_code_ptr + op_size);
725 tb_ptr = (uint8_t *)label;
726 continue;
727 }
728 break;
729 case INDEX_op_mulu2_i32:
730 t0 = *tb_ptr++;
731 t1 = *tb_ptr++;
732 t2 = tci_read_r32(&tb_ptr);
733 tmp64 = tci_read_r32(&tb_ptr);
734 tci_write_reg64(t1, t0, t2 * tmp64);
735 break;
736#endif /* TCG_TARGET_REG_BITS == 32 */
737#if TCG_TARGET_HAS_ext8s_i32
738 case INDEX_op_ext8s_i32:
739 t0 = *tb_ptr++;
740 t1 = tci_read_r8s(&tb_ptr);
741 tci_write_reg32(t0, t1);
742 break;
743#endif
744#if TCG_TARGET_HAS_ext16s_i32
745 case INDEX_op_ext16s_i32:
746 t0 = *tb_ptr++;
747 t1 = tci_read_r16s(&tb_ptr);
748 tci_write_reg32(t0, t1);
749 break;
750#endif
751#if TCG_TARGET_HAS_ext8u_i32
752 case INDEX_op_ext8u_i32:
753 t0 = *tb_ptr++;
754 t1 = tci_read_r8(&tb_ptr);
755 tci_write_reg32(t0, t1);
756 break;
757#endif
758#if TCG_TARGET_HAS_ext16u_i32
759 case INDEX_op_ext16u_i32:
760 t0 = *tb_ptr++;
761 t1 = tci_read_r16(&tb_ptr);
762 tci_write_reg32(t0, t1);
763 break;
764#endif
765#if TCG_TARGET_HAS_bswap16_i32
766 case INDEX_op_bswap16_i32:
767 t0 = *tb_ptr++;
768 t1 = tci_read_r16(&tb_ptr);
769 tci_write_reg32(t0, bswap16(t1));
770 break;
771#endif
772#if TCG_TARGET_HAS_bswap32_i32
773 case INDEX_op_bswap32_i32:
774 t0 = *tb_ptr++;
775 t1 = tci_read_r32(&tb_ptr);
776 tci_write_reg32(t0, bswap32(t1));
777 break;
778#endif
779#if TCG_TARGET_HAS_not_i32
780 case INDEX_op_not_i32:
781 t0 = *tb_ptr++;
782 t1 = tci_read_r32(&tb_ptr);
783 tci_write_reg32(t0, ~t1);
784 break;
785#endif
786#if TCG_TARGET_HAS_neg_i32
787 case INDEX_op_neg_i32:
788 t0 = *tb_ptr++;
789 t1 = tci_read_r32(&tb_ptr);
790 tci_write_reg32(t0, -t1);
791 break;
792#endif
793#if TCG_TARGET_REG_BITS == 64
794 case INDEX_op_mov_i64:
795 t0 = *tb_ptr++;
796 t1 = tci_read_r64(&tb_ptr);
797 tci_write_reg64(t0, t1);
798 break;
799 case INDEX_op_movi_i64:
800 t0 = *tb_ptr++;
801 t1 = tci_read_i64(&tb_ptr);
802 tci_write_reg64(t0, t1);
803 break;
804
805 /* Load/store operations (64 bit). */
806
807 case INDEX_op_ld8u_i64:
808 t0 = *tb_ptr++;
809 t1 = tci_read_r(&tb_ptr);
810 t2 = tci_read_i32(&tb_ptr);
811 tci_write_reg8(t0, *(uint8_t *)(t1 + t2));
812 break;
813 case INDEX_op_ld8s_i64:
814 case INDEX_op_ld16u_i64:
815 case INDEX_op_ld16s_i64:
816 TODO();
817 break;
818 case INDEX_op_ld32u_i64:
819 t0 = *tb_ptr++;
820 t1 = tci_read_r(&tb_ptr);
821 t2 = tci_read_i32(&tb_ptr);
822 tci_write_reg32(t0, *(uint32_t *)(t1 + t2));
823 break;
824 case INDEX_op_ld32s_i64:
825 t0 = *tb_ptr++;
826 t1 = tci_read_r(&tb_ptr);
827 t2 = tci_read_i32(&tb_ptr);
828 tci_write_reg32s(t0, *(int32_t *)(t1 + t2));
829 break;
830 case INDEX_op_ld_i64:
831 t0 = *tb_ptr++;
832 t1 = tci_read_r(&tb_ptr);
833 t2 = tci_read_i32(&tb_ptr);
834 tci_write_reg64(t0, *(uint64_t *)(t1 + t2));
835 break;
836 case INDEX_op_st8_i64:
837 t0 = tci_read_r8(&tb_ptr);
838 t1 = tci_read_r(&tb_ptr);
839 t2 = tci_read_i32(&tb_ptr);
840 *(uint8_t *)(t1 + t2) = t0;
841 break;
842 case INDEX_op_st16_i64:
843 t0 = tci_read_r16(&tb_ptr);
844 t1 = tci_read_r(&tb_ptr);
845 t2 = tci_read_i32(&tb_ptr);
846 *(uint16_t *)(t1 + t2) = t0;
847 break;
848 case INDEX_op_st32_i64:
849 t0 = tci_read_r32(&tb_ptr);
850 t1 = tci_read_r(&tb_ptr);
851 t2 = tci_read_i32(&tb_ptr);
852 *(uint32_t *)(t1 + t2) = t0;
853 break;
854 case INDEX_op_st_i64:
855 t0 = tci_read_r64(&tb_ptr);
856 t1 = tci_read_r(&tb_ptr);
857 t2 = tci_read_i32(&tb_ptr);
858 *(uint64_t *)(t1 + t2) = t0;
859 break;
860
861 /* Arithmetic operations (64 bit). */
862
863 case INDEX_op_add_i64:
864 t0 = *tb_ptr++;
865 t1 = tci_read_ri64(&tb_ptr);
866 t2 = tci_read_ri64(&tb_ptr);
867 tci_write_reg64(t0, t1 + t2);
868 break;
869 case INDEX_op_sub_i64:
870 t0 = *tb_ptr++;
871 t1 = tci_read_ri64(&tb_ptr);
872 t2 = tci_read_ri64(&tb_ptr);
873 tci_write_reg64(t0, t1 - t2);
874 break;
875 case INDEX_op_mul_i64:
876 t0 = *tb_ptr++;
877 t1 = tci_read_ri64(&tb_ptr);
878 t2 = tci_read_ri64(&tb_ptr);
879 tci_write_reg64(t0, t1 * t2);
880 break;
881#if TCG_TARGET_HAS_div_i64
882 case INDEX_op_div_i64:
883 case INDEX_op_divu_i64:
884 case INDEX_op_rem_i64:
885 case INDEX_op_remu_i64:
886 TODO();
887 break;
888#elif TCG_TARGET_HAS_div2_i64
889 case INDEX_op_div2_i64:
890 case INDEX_op_divu2_i64:
891 TODO();
892 break;
893#endif
894 case INDEX_op_and_i64:
895 t0 = *tb_ptr++;
896 t1 = tci_read_ri64(&tb_ptr);
897 t2 = tci_read_ri64(&tb_ptr);
898 tci_write_reg64(t0, t1 & t2);
899 break;
900 case INDEX_op_or_i64:
901 t0 = *tb_ptr++;
902 t1 = tci_read_ri64(&tb_ptr);
903 t2 = tci_read_ri64(&tb_ptr);
904 tci_write_reg64(t0, t1 | t2);
905 break;
906 case INDEX_op_xor_i64:
907 t0 = *tb_ptr++;
908 t1 = tci_read_ri64(&tb_ptr);
909 t2 = tci_read_ri64(&tb_ptr);
910 tci_write_reg64(t0, t1 ^ t2);
911 break;
912
913 /* Shift/rotate operations (64 bit). */
914
915 case INDEX_op_shl_i64:
916 t0 = *tb_ptr++;
917 t1 = tci_read_ri64(&tb_ptr);
918 t2 = tci_read_ri64(&tb_ptr);
919 tci_write_reg64(t0, t1 << t2);
920 break;
921 case INDEX_op_shr_i64:
922 t0 = *tb_ptr++;
923 t1 = tci_read_ri64(&tb_ptr);
924 t2 = tci_read_ri64(&tb_ptr);
925 tci_write_reg64(t0, t1 >> t2);
926 break;
927 case INDEX_op_sar_i64:
928 t0 = *tb_ptr++;
929 t1 = tci_read_ri64(&tb_ptr);
930 t2 = tci_read_ri64(&tb_ptr);
931 tci_write_reg64(t0, ((int64_t)t1 >> t2));
932 break;
933#if TCG_TARGET_HAS_rot_i64
934 case INDEX_op_rotl_i64:
935 case INDEX_op_rotr_i64:
936 TODO();
937 break;
938#endif
939 case INDEX_op_brcond_i64:
940 t0 = tci_read_r64(&tb_ptr);
941 t1 = tci_read_ri64(&tb_ptr);
942 condition = *tb_ptr++;
943 label = tci_read_label(&tb_ptr);
944 if (tci_compare64(t0, t1, condition)) {
945 assert(tb_ptr == old_code_ptr + op_size);
946 tb_ptr = (uint8_t *)label;
947 continue;
948 }
949 break;
950#if TCG_TARGET_HAS_ext8u_i64
951 case INDEX_op_ext8u_i64:
952 t0 = *tb_ptr++;
953 t1 = tci_read_r8(&tb_ptr);
954 tci_write_reg64(t0, t1);
955 break;
956#endif
957#if TCG_TARGET_HAS_ext8s_i64
958 case INDEX_op_ext8s_i64:
959 t0 = *tb_ptr++;
960 t1 = tci_read_r8s(&tb_ptr);
961 tci_write_reg64(t0, t1);
962 break;
963#endif
964#if TCG_TARGET_HAS_ext16s_i64
965 case INDEX_op_ext16s_i64:
966 t0 = *tb_ptr++;
967 t1 = tci_read_r16s(&tb_ptr);
968 tci_write_reg64(t0, t1);
969 break;
970#endif
971#if TCG_TARGET_HAS_ext16u_i64
972 case INDEX_op_ext16u_i64:
973 t0 = *tb_ptr++;
974 t1 = tci_read_r16(&tb_ptr);
975 tci_write_reg64(t0, t1);
976 break;
977#endif
978#if TCG_TARGET_HAS_ext32s_i64
979 case INDEX_op_ext32s_i64:
980 t0 = *tb_ptr++;
981 t1 = tci_read_r32s(&tb_ptr);
982 tci_write_reg64(t0, t1);
983 break;
984#endif
985#if TCG_TARGET_HAS_ext32u_i64
986 case INDEX_op_ext32u_i64:
987 t0 = *tb_ptr++;
988 t1 = tci_read_r32(&tb_ptr);
989 tci_write_reg64(t0, t1);
990 break;
991#endif
992#if TCG_TARGET_HAS_bswap16_i64
993 case INDEX_op_bswap16_i64:
994 TODO();
995 t0 = *tb_ptr++;
996 t1 = tci_read_r16(&tb_ptr);
997 tci_write_reg64(t0, bswap16(t1));
998 break;
999#endif
1000#if TCG_TARGET_HAS_bswap32_i64
1001 case INDEX_op_bswap32_i64:
1002 t0 = *tb_ptr++;
1003 t1 = tci_read_r32(&tb_ptr);
1004 tci_write_reg64(t0, bswap32(t1));
1005 break;
1006#endif
1007#if TCG_TARGET_HAS_bswap64_i64
1008 case INDEX_op_bswap64_i64:
1009 t0 = *tb_ptr++;
1010 t1 = tci_read_r64(&tb_ptr);
1011 tci_write_reg64(t0, bswap64(t1));
1012 break;
1013#endif
1014#if TCG_TARGET_HAS_not_i64
1015 case INDEX_op_not_i64:
1016 t0 = *tb_ptr++;
1017 t1 = tci_read_r64(&tb_ptr);
1018 tci_write_reg64(t0, ~t1);
1019 break;
1020#endif
1021#if TCG_TARGET_HAS_neg_i64
1022 case INDEX_op_neg_i64:
1023 t0 = *tb_ptr++;
1024 t1 = tci_read_r64(&tb_ptr);
1025 tci_write_reg64(t0, -t1);
1026 break;
1027#endif
1028#endif /* TCG_TARGET_REG_BITS == 64 */
1029
1030 /* QEMU specific operations. */
1031
1032#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
1033 case INDEX_op_debug_insn_start:
1034 TODO();
1035 break;
1036#else
1037 case INDEX_op_debug_insn_start:
1038 TODO();
1039 break;
1040#endif
1041 case INDEX_op_exit_tb:
1042 next_tb = *(uint64_t *)tb_ptr;
1043 goto exit;
1044 break;
1045 case INDEX_op_goto_tb:
1046 t0 = tci_read_i32(&tb_ptr);
1047 assert(tb_ptr == old_code_ptr + op_size);
1048 tb_ptr += (int32_t)t0;
1049 continue;
1050 case INDEX_op_qemu_ld8u:
1051 t0 = *tb_ptr++;
1052 taddr = tci_read_ulong(&tb_ptr);
1053#ifdef CONFIG_SOFTMMU
1054 tmp8 = helper_ldb_mmu(env, taddr, tci_read_i(&tb_ptr));
1055#else
1056 host_addr = (tcg_target_ulong)taddr;
1057 assert(taddr == host_addr);
1058 tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);
1059#endif
1060 tci_write_reg8(t0, tmp8);
1061 break;
1062 case INDEX_op_qemu_ld8s:
1063 t0 = *tb_ptr++;
1064 taddr = tci_read_ulong(&tb_ptr);
1065#ifdef CONFIG_SOFTMMU
1066 tmp8 = helper_ldb_mmu(env, taddr, tci_read_i(&tb_ptr));
1067#else
1068 host_addr = (tcg_target_ulong)taddr;
1069 assert(taddr == host_addr);
1070 tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);
1071#endif
1072 tci_write_reg8s(t0, tmp8);
1073 break;
1074 case INDEX_op_qemu_ld16u:
1075 t0 = *tb_ptr++;
1076 taddr = tci_read_ulong(&tb_ptr);
1077#ifdef CONFIG_SOFTMMU
1078 tmp16 = helper_ldw_mmu(env, taddr, tci_read_i(&tb_ptr));
1079#else
1080 host_addr = (tcg_target_ulong)taddr;
1081 assert(taddr == host_addr);
1082 tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));
1083#endif
1084 tci_write_reg16(t0, tmp16);
1085 break;
1086 case INDEX_op_qemu_ld16s:
1087 t0 = *tb_ptr++;
1088 taddr = tci_read_ulong(&tb_ptr);
1089#ifdef CONFIG_SOFTMMU
1090 tmp16 = helper_ldw_mmu(env, taddr, tci_read_i(&tb_ptr));
1091#else
1092 host_addr = (tcg_target_ulong)taddr;
1093 assert(taddr == host_addr);
1094 tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));
1095#endif
1096 tci_write_reg16s(t0, tmp16);
1097 break;
1098#if TCG_TARGET_REG_BITS == 64
1099 case INDEX_op_qemu_ld32u:
1100 t0 = *tb_ptr++;
1101 taddr = tci_read_ulong(&tb_ptr);
1102#ifdef CONFIG_SOFTMMU
1103 tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
1104#else
1105 host_addr = (tcg_target_ulong)taddr;
1106 assert(taddr == host_addr);
1107 tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
1108#endif
1109 tci_write_reg32(t0, tmp32);
1110 break;
1111 case INDEX_op_qemu_ld32s:
1112 t0 = *tb_ptr++;
1113 taddr = tci_read_ulong(&tb_ptr);
1114#ifdef CONFIG_SOFTMMU
1115 tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
1116#else
1117 host_addr = (tcg_target_ulong)taddr;
1118 assert(taddr == host_addr);
1119 tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
1120#endif
1121 tci_write_reg32s(t0, tmp32);
1122 break;
1123#endif /* TCG_TARGET_REG_BITS == 64 */
1124 case INDEX_op_qemu_ld32:
1125 t0 = *tb_ptr++;
1126 taddr = tci_read_ulong(&tb_ptr);
1127#ifdef CONFIG_SOFTMMU
1128 tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
1129#else
1130 host_addr = (tcg_target_ulong)taddr;
1131 assert(taddr == host_addr);
1132 tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
1133#endif
1134 tci_write_reg32(t0, tmp32);
1135 break;
1136 case INDEX_op_qemu_ld64:
1137 t0 = *tb_ptr++;
1138#if TCG_TARGET_REG_BITS == 32
1139 t1 = *tb_ptr++;
1140#endif
1141 taddr = tci_read_ulong(&tb_ptr);
1142#ifdef CONFIG_SOFTMMU
1143 tmp64 = helper_ldq_mmu(env, taddr, tci_read_i(&tb_ptr));
1144#else
1145 host_addr = (tcg_target_ulong)taddr;
1146 assert(taddr == host_addr);
1147 tmp64 = tswap64(*(uint64_t *)(host_addr + GUEST_BASE));
1148#endif
1149 tci_write_reg(t0, tmp64);
1150#if TCG_TARGET_REG_BITS == 32
1151 tci_write_reg(t1, tmp64 >> 32);
1152#endif
1153 break;
1154 case INDEX_op_qemu_st8:
1155 t0 = tci_read_r8(&tb_ptr);
1156 taddr = tci_read_ulong(&tb_ptr);
1157#ifdef CONFIG_SOFTMMU
1158 t2 = tci_read_i(&tb_ptr);
1159 helper_stb_mmu(env, taddr, t0, t2);
1160#else
1161 host_addr = (tcg_target_ulong)taddr;
1162 assert(taddr == host_addr);
1163 *(uint8_t *)(host_addr + GUEST_BASE) = t0;
1164#endif
1165 break;
1166 case INDEX_op_qemu_st16:
1167 t0 = tci_read_r16(&tb_ptr);
1168 taddr = tci_read_ulong(&tb_ptr);
1169#ifdef CONFIG_SOFTMMU
1170 t2 = tci_read_i(&tb_ptr);
1171 helper_stw_mmu(env, taddr, t0, t2);
1172#else
1173 host_addr = (tcg_target_ulong)taddr;
1174 assert(taddr == host_addr);
1175 *(uint16_t *)(host_addr + GUEST_BASE) = tswap16(t0);
1176#endif
1177 break;
1178 case INDEX_op_qemu_st32:
1179 t0 = tci_read_r32(&tb_ptr);
1180 taddr = tci_read_ulong(&tb_ptr);
1181#ifdef CONFIG_SOFTMMU
1182 t2 = tci_read_i(&tb_ptr);
1183 helper_stl_mmu(env, taddr, t0, t2);
1184#else
1185 host_addr = (tcg_target_ulong)taddr;
1186 assert(taddr == host_addr);
1187 *(uint32_t *)(host_addr + GUEST_BASE) = tswap32(t0);
1188#endif
1189 break;
1190 case INDEX_op_qemu_st64:
1191 tmp64 = tci_read_r64(&tb_ptr);
1192 taddr = tci_read_ulong(&tb_ptr);
1193#ifdef CONFIG_SOFTMMU
1194 t2 = tci_read_i(&tb_ptr);
1195 helper_stq_mmu(env, taddr, tmp64, t2);
1196#else
1197 host_addr = (tcg_target_ulong)taddr;
1198 assert(taddr == host_addr);
1199 *(uint64_t *)(host_addr + GUEST_BASE) = tswap64(tmp64);
1200#endif
1201 break;
1202 default:
1203 TODO();
1204 break;
1205 }
1206 assert(tb_ptr == old_code_ptr + op_size);
1207 }
1208exit:
1209 return next_tb;
1210}
Qemu copy for testing