]> git.proxmox.com Git - qemu.git/blob - tci.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'target-arm.for-upstream' of git://git.linaro.org/people/pmaydell/qemu-arm
[qemu.git] / tci.c
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
43 typedef 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
49 typedef 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)
56 CPUArchState *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)
62 uintptr_t tci_tb_ptr;
63 #endif
64
65 static tcg_target_ulong tci_reg[TCG_TARGET_NB_REGS];
66
67 static 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
74 static 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
81 static 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
88 static int32_t tci_read_reg32s(TCGReg index)
89 {
90 return (int32_t)tci_read_reg(index);
91 }
92 #endif
93
94 static uint8_t tci_read_reg8(TCGReg index)
95 {
96 return (uint8_t)tci_read_reg(index);
97 }
98
99 static uint16_t tci_read_reg16(TCGReg index)
100 {
101 return (uint16_t)tci_read_reg(index);
102 }
103
104 static 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
110 static uint64_t tci_read_reg64(TCGReg index)
111 {
112 return tci_read_reg(index);
113 }
114 #endif
115
116 static 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
123 static void tci_write_reg8s(TCGReg index, int8_t value)
124 {
125 tci_write_reg(index, value);
126 }
127
128 static 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
134 static void tci_write_reg32s(TCGReg index, int32_t value)
135 {
136 tci_write_reg(index, value);
137 }
138 #endif
139
140 static void tci_write_reg8(TCGReg index, uint8_t value)
141 {
142 tci_write_reg(index, value);
143 }
144
145 static void tci_write_reg16(TCGReg index, uint16_t value)
146 {
147 tci_write_reg(index, value);
148 }
149
150 static 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
156 static 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
163 static 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. */
171 static 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. */
178 static 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. */
186 static 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. */
195 static 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. */
204 static 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. */
212 static 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. */
221 static 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. */
230 static 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. */
239 static 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. */
248 static 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. */
257 static 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. */
264 static 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. */
272 static 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. */
281 static 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. */
291 static 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. */
305 static 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. */
320 static 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. */
327 static 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
341 static 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
348 static 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
390 static 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. */
433 tcg_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 }
1208 exit:
1209 return next_tb;
1210 }
Qemu copy for testing