gwj / at91sam9263 · Commits

Commit c55497ecb8c084adb80e6367845b51dd30475272

Authored by aurel32
1 parent 7efbe241

SH4: Remove most uses of cpu_T[0] and cpu_T[1] 

Signed-off-by: Aurelien Jarno <aurelien@aurel32.net>

git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@5122 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 1 changed file with 427 additions and 181 deletions
target-sh4/translate.c
  View file @c55497e
... ... @@ -261,10 +261,12 @@ static void gen_jump(DisasContext * ctx)
261 261  
262 262 static inline void gen_branch_slot(uint32_t delayed_pc, int t)
263 263 {
  264 + TCGv sr;
264 265 int label = gen_new_label();
265 266 tcg_gen_movi_i32(cpu_delayed_pc, delayed_pc);
266   - tcg_gen_andi_i32(cpu_T[0], cpu_sr, SR_T);
267   - tcg_gen_brcondi_i32(TCG_COND_NE, cpu_T[0], t ? SR_T : 0, label);
  267 + sr = tcg_temp_new(TCG_TYPE_I32);
  268 + tcg_gen_andi_i32(sr, cpu_sr, SR_T);
  269 + tcg_gen_brcondi_i32(TCG_COND_NE, sr, t ? SR_T : 0, label);
268 270 tcg_gen_ori_i32(cpu_flags, cpu_flags, DELAY_SLOT_TRUE);
269 271 gen_set_label(label);
270 272 }
... ... @@ -274,10 +276,12 @@ static void gen_conditional_jump(DisasContext * ctx,
274 276 target_ulong ift, target_ulong ifnott)
275 277 {
276 278 int l1;
  279 + TCGv sr;
277 280  
278 281 l1 = gen_new_label();
279   - tcg_gen_andi_i32(cpu_T[0], cpu_sr, SR_T);
280   - tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_T[0], SR_T, l1);
  282 + sr = tcg_temp_new(TCG_TYPE_I32);
  283 + tcg_gen_andi_i32(sr, cpu_sr, SR_T);
  284 + tcg_gen_brcondi_i32(TCG_COND_EQ, sr, SR_T, l1);
281 285 gen_goto_tb(ctx, 0, ifnott);
282 286 gen_set_label(l1);
283 287 gen_goto_tb(ctx, 1, ift);
... ... @@ -287,10 +291,12 @@ static void gen_conditional_jump(DisasContext * ctx,
287 291 static void gen_delayed_conditional_jump(DisasContext * ctx)
288 292 {
289 293 int l1;
  294 + TCGv ds;
290 295  
291 296 l1 = gen_new_label();
292   - tcg_gen_andi_i32(cpu_T[0], cpu_flags, DELAY_SLOT_TRUE);
293   - tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_T[0], DELAY_SLOT_TRUE, l1);
  297 + ds = tcg_temp_new(TCG_TYPE_I32);
  298 + tcg_gen_andi_i32(ds, cpu_flags, DELAY_SLOT_TRUE);
  299 + tcg_gen_brcondi_i32(TCG_COND_EQ, ds, DELAY_SLOT_TRUE, l1);
294 300 gen_goto_tb(ctx, 1, ctx->pc + 2);
295 301 gen_set_label(l1);
296 302 tcg_gen_andi_i32(cpu_flags, cpu_flags, ~DELAY_SLOT_TRUE);
... ... @@ -448,23 +454,37 @@ void _decode_opc(DisasContext * ctx)
448 454  
449 455 switch (ctx->opcode & 0xf000) {
450 456 case 0x1000: /* mov.l Rm,@(disp,Rn) */
451   - tcg_gen_addi_i32(cpu_T[0], REG(B11_8), B3_0 * 4);
452   - tcg_gen_qemu_st32(REG(B7_4), cpu_T[0], ctx->memidx);
  457 + {
  458 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  459 + tcg_gen_addi_i32(addr, REG(B11_8), B3_0 * 4);
  460 + tcg_gen_qemu_st32(REG(B7_4), addr, ctx->memidx);
  461 + tcg_temp_free(addr);
  462 + }
453 463 return;
454 464 case 0x5000: /* mov.l @(disp,Rm),Rn */
455   - tcg_gen_addi_i32(cpu_T[0], REG(B7_4), B3_0 * 4);
456   - tcg_gen_qemu_ld32s(REG(B11_8), cpu_T[0], ctx->memidx);
  465 + {
  466 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  467 + tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 4);
  468 + tcg_gen_qemu_ld32s(REG(B11_8), addr, ctx->memidx);
  469 + tcg_temp_free(addr);
  470 + }
457 471 return;
458 472 case 0xe000: /* mov #imm,Rn */
459 473 tcg_gen_movi_i32(REG(B11_8), B7_0s);
460 474 return;
461 475 case 0x9000: /* mov.w @(disp,PC),Rn */
462   - tcg_gen_movi_i32(cpu_T[0], ctx->pc + 4 + B7_0 * 2);
463   - tcg_gen_qemu_ld16s(REG(B11_8), cpu_T[0], ctx->memidx);
  476 + {
  477 + TCGv addr = tcg_const_i32(ctx->pc + 4 + B7_0 * 2);
  478 + tcg_gen_qemu_ld16s(REG(B11_8), addr, ctx->memidx);
  479 + tcg_temp_free(addr);
  480 + }
464 481 return;
465 482 case 0xd000: /* mov.l @(disp,PC),Rn */
466   - tcg_gen_movi_i32(cpu_T[0], (ctx->pc + 4 + B7_0 * 4) & ~3);
467   - tcg_gen_qemu_ld32s(REG(B11_8), cpu_T[0], ctx->memidx);
  483 + {
  484 + TCGv addr = tcg_const_i32((ctx->pc + 4 + B7_0 * 4) & ~3);
  485 + tcg_gen_qemu_ld32s(REG(B11_8), addr, ctx->memidx);
  486 + tcg_temp_free(addr);
  487 + }
468 488 return;
469 489 case 0x7000: /* add #imm,Rn */
470 490 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), B7_0s);
... ... @@ -507,19 +527,30 @@ void _decode_opc(DisasContext * ctx)
507 527 tcg_gen_qemu_ld32s(REG(B11_8), REG(B7_4), ctx->memidx);
508 528 return;
509 529 case 0x2004: /* mov.b Rm,@-Rn */
510   - tcg_gen_subi_i32(cpu_T[0], REG(B11_8), 1);
511   - tcg_gen_qemu_st8(REG(B7_4), cpu_T[0], ctx->memidx); /* might cause re-execution */
512   - tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 1); /* modify register status */
  530 + {
  531 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  532 + tcg_gen_subi_i32(addr, REG(B11_8), 1);
  533 + tcg_gen_qemu_st8(REG(B7_4), addr, ctx->memidx); /* might cause re-execution */
  534 + tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 1); /* modify register status */
  535 + tcg_temp_free(addr);
  536 + }
513 537 return;
514 538 case 0x2005: /* mov.w Rm,@-Rn */
515   - tcg_gen_subi_i32(cpu_T[0], REG(B11_8), 2);
516   - tcg_gen_qemu_st16(REG(B7_4), cpu_T[0], ctx->memidx);
517   - tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 2);
  539 + {
  540 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  541 + tcg_gen_subi_i32(addr, REG(B11_8), 2);
  542 + tcg_gen_qemu_st16(REG(B7_4), addr, ctx->memidx);
  543 + tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 2);
  544 + tcg_temp_free(addr);
  545 + }
518 546 return;
519 547 case 0x2006: /* mov.l Rm,@-Rn */
520   - tcg_gen_subi_i32(cpu_T[0], REG(B11_8), 4);
521   - tcg_gen_qemu_st32(REG(B7_4), cpu_T[0], ctx->memidx);
522   - tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
  548 + {
  549 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  550 + tcg_gen_subi_i32(addr, REG(B11_8), 4);
  551 + tcg_gen_qemu_st32(REG(B7_4), addr, ctx->memidx);
  552 + tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
  553 + }
523 554 return;
524 555 case 0x6004: /* mov.b @Rm+,Rn */
525 556 tcg_gen_qemu_ld8s(REG(B11_8), REG(B7_4), ctx->memidx);
... ... @@ -537,49 +568,94 @@ void _decode_opc(DisasContext * ctx)
537 568 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
538 569 return;
539 570 case 0x0004: /* mov.b Rm,@(R0,Rn) */
540   - tcg_gen_add_i32(cpu_T[0], REG(B11_8), REG(0));
541   - tcg_gen_qemu_st8(REG(B7_4), cpu_T[0], ctx->memidx);
  571 + {
  572 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  573 + tcg_gen_add_i32(addr, REG(B11_8), REG(0));
  574 + tcg_gen_qemu_st8(REG(B7_4), addr, ctx->memidx);
  575 + tcg_temp_free(addr);
  576 + }
542 577 return;
543 578 case 0x0005: /* mov.w Rm,@(R0,Rn) */
544   - tcg_gen_add_i32(cpu_T[0], REG(B11_8), REG(0));
545   - tcg_gen_qemu_st16(REG(B7_4), cpu_T[0], ctx->memidx);
  579 + {
  580 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  581 + tcg_gen_add_i32(addr, REG(B11_8), REG(0));
  582 + tcg_gen_qemu_st16(REG(B7_4), addr, ctx->memidx);
  583 + tcg_temp_free(addr);
  584 + }
546 585 return;
547 586 case 0x0006: /* mov.l Rm,@(R0,Rn) */
548   - tcg_gen_add_i32(cpu_T[0], REG(B11_8), REG(0));
549   - tcg_gen_qemu_st32(REG(B7_4), cpu_T[0], ctx->memidx);
  587 + {
  588 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  589 + tcg_gen_add_i32(addr, REG(B11_8), REG(0));
  590 + tcg_gen_qemu_st32(REG(B7_4), addr, ctx->memidx);
  591 + tcg_temp_free(addr);
  592 + }
550 593 return;
551 594 case 0x000c: /* mov.b @(R0,Rm),Rn */
552   - tcg_gen_add_i32(cpu_T[0], REG(B7_4), REG(0));
553   - tcg_gen_qemu_ld8s(REG(B11_8), cpu_T[0], ctx->memidx);
  595 + {
  596 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  597 + tcg_gen_add_i32(addr, REG(B7_4), REG(0));
  598 + tcg_gen_qemu_ld8s(REG(B11_8), addr, ctx->memidx);
  599 + tcg_temp_free(addr);
  600 + }
554 601 return;
555 602 case 0x000d: /* mov.w @(R0,Rm),Rn */
556   - tcg_gen_add_i32(cpu_T[0], REG(B7_4), REG(0));
557   - tcg_gen_qemu_ld16s(REG(B11_8), cpu_T[0], ctx->memidx);
  603 + {
  604 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  605 + tcg_gen_add_i32(addr, REG(B7_4), REG(0));
  606 + tcg_gen_qemu_ld16s(REG(B11_8), addr, ctx->memidx);
  607 + tcg_temp_free(addr);
  608 + }
558 609 return;
559 610 case 0x000e: /* mov.l @(R0,Rm),Rn */
560   - tcg_gen_add_i32(cpu_T[0], REG(B7_4), REG(0));
561   - tcg_gen_qemu_ld32s(REG(B11_8), cpu_T[0], ctx->memidx);
  611 + {
  612 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  613 + tcg_gen_add_i32(addr, REG(B7_4), REG(0));
  614 + tcg_gen_qemu_ld32s(REG(B11_8), addr, ctx->memidx);
  615 + tcg_temp_free(addr);
  616 + }
562 617 return;
563 618 case 0x6008: /* swap.b Rm,Rn */
564   - tcg_gen_ext8u_i32(cpu_T[0], REG(B7_4));
565   - tcg_gen_shli_i32(cpu_T[0], cpu_T[0], 8);
566   - tcg_gen_shri_i32(cpu_T[1], REG(B7_4), 8);
567   - tcg_gen_ext8u_i32(cpu_T[1], cpu_T[1]);
568   - tcg_gen_or_i32(REG(B11_8), cpu_T[0], cpu_T[1]);
  619 + {
  620 + TCGv high, low;
  621 + high = tcg_temp_new(TCG_TYPE_I32);
  622 + tcg_gen_ext8u_i32(high, REG(B7_4));
  623 + tcg_gen_shli_i32(high, high, 8);
  624 + low = tcg_temp_new(TCG_TYPE_I32);
  625 + tcg_gen_shri_i32(low, REG(B7_4), 8);
  626 + tcg_gen_ext8u_i32(low, low);
  627 + tcg_gen_or_i32(REG(B11_8), high, low);
  628 + tcg_temp_free(low);
  629 + tcg_temp_free(high);
  630 + }
569 631 return;
570 632 case 0x6009: /* swap.w Rm,Rn */
571   - tcg_gen_ext16u_i32(cpu_T[0], REG(B7_4));
572   - tcg_gen_shli_i32(cpu_T[0], cpu_T[0], 16);
573   - tcg_gen_shri_i32(cpu_T[1], REG(B7_4), 16);
574   - tcg_gen_ext16u_i32(cpu_T[1], cpu_T[1]);
575   - tcg_gen_or_i32(REG(B11_8), cpu_T[0], cpu_T[1]);
  633 + {
  634 + TCGv high, low;
  635 + high = tcg_temp_new(TCG_TYPE_I32);
  636 + tcg_gen_ext16u_i32(high, REG(B7_4));
  637 + tcg_gen_shli_i32(high, high, 16);
  638 + low = tcg_temp_new(TCG_TYPE_I32);
  639 + tcg_gen_shri_i32(low, REG(B7_4), 16);
  640 + tcg_gen_ext16u_i32(low, low);
  641 + tcg_gen_or_i32(REG(B11_8), high, low);
  642 + tcg_temp_free(low);
  643 + tcg_temp_free(high);
  644 + }
576 645 return;
577 646 case 0x200d: /* xtrct Rm,Rn */
578   - tcg_gen_ext16u_i32(cpu_T[0], REG(B7_4));
579   - tcg_gen_shli_i32(cpu_T[0], cpu_T[0], 16);
580   - tcg_gen_shri_i32(cpu_T[1], REG(B11_8), 16);
581   - tcg_gen_ext16u_i32(cpu_T[1], cpu_T[1]);
582   - tcg_gen_or_i32(REG(B11_8), cpu_T[0], cpu_T[1]);
  647 + {
  648 + TCGv high, low;
  649 + high = tcg_temp_new(TCG_TYPE_I32);
  650 + tcg_gen_ext16u_i32(high, REG(B7_4));
  651 + tcg_gen_shli_i32(high, high, 16);
  652 + low = tcg_temp_new(TCG_TYPE_I32);
  653 + tcg_gen_shri_i32(low, REG(B11_8), 16);
  654 + tcg_gen_ext16u_i32(low, low);
  655 + tcg_gen_or_i32(REG(B11_8), high, low);
  656 + tcg_temp_free(low);
  657 + tcg_temp_free(high);
  658 + }
583 659 return;
584 660 case 0x300c: /* add Rm,Rn */
585 661 tcg_gen_add_i32(REG(B11_8), REG(B11_8), REG(B7_4));
... ... @@ -612,27 +688,35 @@ void _decode_opc(DisasContext * ctx)
612 688 {
613 689 int label1 = gen_new_label();
614 690 int label2 = gen_new_label();
615   - tcg_gen_xor_i32(cpu_T[0], REG(B7_4), REG(B11_8));
616   - tcg_gen_andi_i32(cpu_T[0], cpu_T[0], 0xff000000);
617   - tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_T[0], 0, label1);
618   - tcg_gen_andi_i32(cpu_T[0], cpu_T[0], 0x00ff0000);
619   - tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_T[0], 0, label1);
620   - tcg_gen_andi_i32(cpu_T[0], cpu_T[0], 0x0000ff00);
621   - tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_T[0], 0, label1);
622   - tcg_gen_andi_i32(cpu_T[0], cpu_T[0], 0x000000ff);
623   - tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_T[0], 0, label1);
  691 + TCGv cmp1 = tcg_temp_local_new(TCG_TYPE_I32);
  692 + TCGv cmp2 = tcg_temp_local_new(TCG_TYPE_I32);
  693 + tcg_gen_xor_i32(cmp1, REG(B7_4), REG(B11_8));
  694 + tcg_gen_andi_i32(cmp2, cmp1, 0xff000000);
  695 + tcg_gen_brcondi_i32(TCG_COND_EQ, cmp2, 0, label1);
  696 + tcg_gen_andi_i32(cmp2, cmp1, 0x00ff0000);
  697 + tcg_gen_brcondi_i32(TCG_COND_EQ, cmp2, 0, label1);
  698 + tcg_gen_andi_i32(cmp2, cmp1, 0x0000ff00);
  699 + tcg_gen_brcondi_i32(TCG_COND_EQ, cmp2, 0, label1);
  700 + tcg_gen_andi_i32(cmp2, cmp1, 0x000000ff);
  701 + tcg_gen_brcondi_i32(TCG_COND_EQ, cmp2, 0, label1);
624 702 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
625 703 tcg_gen_br(label2);
626 704 gen_set_label(label1);
627 705 tcg_gen_ori_i32(cpu_sr, cpu_sr, SR_T);
628 706 gen_set_label(label2);
  707 + tcg_temp_free(cmp2);
  708 + tcg_temp_free(cmp1);
629 709 }
630 710 return;
631 711 case 0x2007: /* div0s Rm,Rn */
632   - gen_copy_bit_i32(cpu_sr, 8, REG(B11_8), 31); /* SR_Q */
633   - gen_copy_bit_i32(cpu_sr, 9, REG(B7_4), 31); /* SR_M */
634   - tcg_gen_xor_i32(cpu_T[0], REG(B7_4), REG(B11_8));
635   - gen_copy_bit_i32(cpu_sr, 0, cpu_T[0], 31); /* SR_T */
  712 + {
  713 + gen_copy_bit_i32(cpu_sr, 8, REG(B11_8), 31); /* SR_Q */
  714 + gen_copy_bit_i32(cpu_sr, 9, REG(B7_4), 31); /* SR_M */
  715 + TCGv val = tcg_temp_new(TCG_TYPE_I32);
  716 + tcg_gen_xor_i32(val, REG(B7_4), REG(B11_8));
  717 + gen_copy_bit_i32(cpu_sr, 0, val, 31); /* SR_T */
  718 + tcg_temp_free(val);
  719 + }
636 720 return;
637 721 case 0x3004: /* div1 Rm,Rn */
638 722 tcg_gen_helper_1_2(helper_div1, REG(B11_8), REG(B7_4), REG(B11_8));
... ... @@ -649,8 +733,8 @@ void _decode_opc(DisasContext * ctx)
649 733 tcg_gen_shri_i64(tmp1, tmp1, 32);
650 734 tcg_gen_trunc_i64_i32(cpu_mach, tmp1);
651 735  
652   - tcg_temp_free(tmp1);
653 736 tcg_temp_free(tmp2);
  737 + tcg_temp_free(tmp1);
654 738 }
655 739 return;
656 740 case 0x3005: /* dmulu.l Rm,Rn */
... ... @@ -665,8 +749,8 @@ void _decode_opc(DisasContext * ctx)
665 749 tcg_gen_shri_i64(tmp1, tmp1, 32);
666 750 tcg_gen_trunc_i64_i32(cpu_mach, tmp1);
667 751  
668   - tcg_temp_free(tmp1);
669 752 tcg_temp_free(tmp2);
  753 + tcg_temp_free(tmp1);
670 754 }
671 755 return;
672 756 case 0x600e: /* exts.b Rm,Rn */
... ... @@ -682,31 +766,59 @@ void _decode_opc(DisasContext * ctx)
682 766 tcg_gen_ext16u_i32(REG(B11_8), REG(B7_4));
683 767 return;
684 768 case 0x000f: /* mac.l @Rm+,@Rn+ */
685   - tcg_gen_qemu_ld32s(cpu_T[0], REG(B7_4), ctx->memidx);
686   - tcg_gen_qemu_ld32s(cpu_T[1], REG(B11_8), ctx->memidx);
687   - tcg_gen_helper_0_2(helper_macl, cpu_T[0], cpu_T[1]);
688   - tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
689   - tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
  769 + {
  770 + TCGv arg0, arg1;
  771 + arg0 = tcg_temp_new(TCG_TYPE_I32);
  772 + tcg_gen_qemu_ld32s(arg0, REG(B7_4), ctx->memidx);
  773 + arg1 = tcg_temp_new(TCG_TYPE_I32);
  774 + tcg_gen_qemu_ld32s(arg1, REG(B11_8), ctx->memidx);
  775 + tcg_gen_helper_0_2(helper_macl, arg0, arg1);
  776 + tcg_temp_free(arg1);
  777 + tcg_temp_free(arg0);
  778 + tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
  779 + tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
  780 + }
690 781 return;
691 782 case 0x400f: /* mac.w @Rm+,@Rn+ */
692   - tcg_gen_qemu_ld32s(cpu_T[0], REG(B7_4), ctx->memidx);
693   - tcg_gen_qemu_ld32s(cpu_T[1], REG(B11_8), ctx->memidx);
694   - tcg_gen_helper_0_2(helper_macw, cpu_T[0], cpu_T[1]);
695   - tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 2);
696   - tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 2);
  783 + {
  784 + TCGv arg0, arg1;
  785 + arg0 = tcg_temp_new(TCG_TYPE_I32);
  786 + tcg_gen_qemu_ld32s(arg0, REG(B7_4), ctx->memidx);
  787 + arg1 = tcg_temp_new(TCG_TYPE_I32);
  788 + tcg_gen_qemu_ld32s(arg1, REG(B11_8), ctx->memidx);
  789 + tcg_gen_helper_0_2(helper_macw, arg0, arg1);
  790 + tcg_temp_free(arg1);
  791 + tcg_temp_free(arg0);
  792 + tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 2);
  793 + tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 2);
  794 + }
697 795 return;
698 796 case 0x0007: /* mul.l Rm,Rn */
699 797 tcg_gen_mul_i32(cpu_macl, REG(B7_4), REG(B11_8));
700 798 return;
701 799 case 0x200f: /* muls.w Rm,Rn */
702   - tcg_gen_ext16s_i32(cpu_T[0], REG(B7_4));
703   - tcg_gen_ext16s_i32(cpu_T[1], REG(B11_8));
704   - tcg_gen_mul_i32(cpu_macl, cpu_T[0], cpu_T[1]);
  800 + {
  801 + TCGv arg0, arg1;
  802 + arg0 = tcg_temp_new(TCG_TYPE_I32);
  803 + tcg_gen_ext16s_i32(arg0, REG(B7_4));
  804 + arg1 = tcg_temp_new(TCG_TYPE_I32);
  805 + tcg_gen_ext16s_i32(arg1, REG(B11_8));
  806 + tcg_gen_mul_i32(cpu_macl, arg0, arg1);
  807 + tcg_temp_free(arg1);
  808 + tcg_temp_free(arg0);
  809 + }
705 810 return;
706 811 case 0x200e: /* mulu.w Rm,Rn */
707   - tcg_gen_ext16u_i32(cpu_T[0], REG(B7_4));
708   - tcg_gen_ext16u_i32(cpu_T[1], REG(B11_8));
709   - tcg_gen_mul_i32(cpu_macl, cpu_T[0], cpu_T[1]);
  812 + {
  813 + TCGv arg0, arg1;
  814 + arg0 = tcg_temp_new(TCG_TYPE_I32);
  815 + tcg_gen_ext16u_i32(arg0, REG(B7_4));
  816 + arg1 = tcg_temp_new(TCG_TYPE_I32);
  817 + tcg_gen_ext16u_i32(arg1, REG(B11_8));
  818 + tcg_gen_mul_i32(cpu_macl, arg0, arg1);
  819 + tcg_temp_free(arg1);
  820 + tcg_temp_free(arg0);
  821 + }
710 822 return;
711 823 case 0x600b: /* neg Rm,Rn */
712 824 tcg_gen_neg_i32(REG(B11_8), REG(B7_4));
... ... @@ -726,19 +838,20 @@ void _decode_opc(DisasContext * ctx)
726 838 int label2 = gen_new_label();
727 839 int label3 = gen_new_label();
728 840 int label4 = gen_new_label();
  841 + TCGv shift = tcg_temp_local_new(TCG_TYPE_I32);
729 842 tcg_gen_brcondi_i32(TCG_COND_LT, REG(B7_4), 0, label1);
730 843 /* Rm positive, shift to the left */
731   - tcg_gen_andi_i32(cpu_T[0], REG(B7_4), 0x1f);
732   - tcg_gen_shl_i32(REG(B11_8), REG(B11_8), cpu_T[0]);
  844 + tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
  845 + tcg_gen_shl_i32(REG(B11_8), REG(B11_8), shift);
733 846 tcg_gen_br(label4);
734 847 /* Rm negative, shift to the right */
735 848 gen_set_label(label1);
736   - tcg_gen_andi_i32(cpu_T[0], REG(B7_4), 0x1f);
737   - tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_T[0], 0, label2);
738   - tcg_gen_not_i32(cpu_T[0], REG(B7_4));
739   - tcg_gen_andi_i32(cpu_T[0], cpu_T[0], 0x1f);
740   - tcg_gen_addi_i32(cpu_T[0], cpu_T[0], 1);
741   - tcg_gen_sar_i32(REG(B11_8), REG(B11_8), cpu_T[0]);
  849 + tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
  850 + tcg_gen_brcondi_i32(TCG_COND_EQ, shift, 0, label2);
  851 + tcg_gen_not_i32(shift, REG(B7_4));
  852 + tcg_gen_andi_i32(shift, shift, 0x1f);
  853 + tcg_gen_addi_i32(shift, shift, 1);
  854 + tcg_gen_sar_i32(REG(B11_8), REG(B11_8), shift);
742 855 tcg_gen_br(label4);
743 856 /* Rm = -32 */
744 857 gen_set_label(label2);
... ... @@ -748,6 +861,7 @@ void _decode_opc(DisasContext * ctx)
748 861 gen_set_label(label3);
749 862 tcg_gen_movi_i32(REG(B11_8), 0xffffffff);
750 863 gen_set_label(label4);
  864 + tcg_temp_free(shift);
751 865 }
752 866 return;
753 867 case 0x400d: /* shld Rm,Rn */
... ... @@ -755,24 +869,26 @@ void _decode_opc(DisasContext * ctx)
755 869 int label1 = gen_new_label();
756 870 int label2 = gen_new_label();
757 871 int label3 = gen_new_label();
  872 + TCGv shift = tcg_temp_local_new(TCG_TYPE_I32);
758 873 tcg_gen_brcondi_i32(TCG_COND_LT, REG(B7_4), 0, label1);
759 874 /* Rm positive, shift to the left */
760   - tcg_gen_andi_i32(cpu_T[0], REG(B7_4), 0x1f);
761   - tcg_gen_shl_i32(REG(B11_8), REG(B11_8), cpu_T[0]);
  875 + tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
  876 + tcg_gen_shl_i32(REG(B11_8), REG(B11_8), shift);
762 877 tcg_gen_br(label3);
763 878 /* Rm negative, shift to the right */
764 879 gen_set_label(label1);
765   - tcg_gen_andi_i32(cpu_T[0], REG(B7_4), 0x1f);
766   - tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_T[0], 0, label2);
767   - tcg_gen_not_i32(cpu_T[0], REG(B7_4));
768   - tcg_gen_andi_i32(cpu_T[0], cpu_T[0], 0x1f);
769   - tcg_gen_addi_i32(cpu_T[0], cpu_T[0], 1);
770   - tcg_gen_shr_i32(REG(B11_8), REG(B11_8), cpu_T[0]);
  880 + tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
  881 + tcg_gen_brcondi_i32(TCG_COND_EQ, shift, 0, label2);
  882 + tcg_gen_not_i32(shift, REG(B7_4));
  883 + tcg_gen_andi_i32(shift, shift, 0x1f);
  884 + tcg_gen_addi_i32(shift, shift, 1);
  885 + tcg_gen_shr_i32(REG(B11_8), REG(B11_8), shift);
771 886 tcg_gen_br(label3);
772 887 /* Rm = -32 */
773 888 gen_set_label(label2);
774 889 tcg_gen_movi_i32(REG(B11_8), 0);
775 890 gen_set_label(label3);
  891 + tcg_temp_free(shift);
776 892 }
777 893 return;
778 894 case 0x3008: /* sub Rm,Rn */
... ... @@ -785,8 +901,12 @@ void _decode_opc(DisasContext * ctx)
785 901 tcg_gen_helper_1_2(helper_subv, REG(B11_8), REG(B7_4), REG(B11_8));
786 902 return;
787 903 case 0x2008: /* tst Rm,Rn */
788   - tcg_gen_and_i32(cpu_T[0], REG(B7_4), REG(B11_8));
789   - gen_cmp_imm(TCG_COND_EQ, cpu_T[0], 0);
  904 + {
  905 + TCGv val = tcg_temp_new(TCG_TYPE_I32);
  906 + tcg_gen_and_i32(val, REG(B7_4), REG(B11_8));
  907 + gen_cmp_imm(TCG_COND_EQ, val, 0);
  908 + tcg_temp_free(val);
  909 + }
790 910 return;
791 911 case 0x200a: /* xor Rm,Rn */
792 912 tcg_gen_xor_i32(REG(B11_8), REG(B11_8), REG(B7_4));
... ... @@ -929,10 +1049,17 @@ void _decode_opc(DisasContext * ctx)
929 1049 tcg_gen_andi_i32(REG(0), REG(0), B7_0);
930 1050 return;
931 1051 case 0xcd00: /* and.b #imm,@(R0,GBR) */
932   - tcg_gen_add_i32(cpu_T[1], REG(0), cpu_gbr);
933   - tcg_gen_qemu_ld8u(cpu_T[0], cpu_T[1], ctx->memidx);
934   - tcg_gen_andi_i32(cpu_T[0], cpu_T[0], B7_0);
935   - tcg_gen_qemu_st8(cpu_T[0], cpu_T[1], ctx->memidx);
  1052 + {
  1053 + TCGv addr, val;
  1054 + addr = tcg_temp_new(TCG_TYPE_I32);
  1055 + tcg_gen_add_i32(addr, REG(0), cpu_gbr);
  1056 + val = tcg_temp_new(TCG_TYPE_I32);
  1057 + tcg_gen_qemu_ld8u(val, addr, ctx->memidx);
  1058 + tcg_gen_andi_i32(val, val, B7_0);
  1059 + tcg_gen_qemu_st8(val, addr, ctx->memidx);
  1060 + tcg_temp_free(val);
  1061 + tcg_temp_free(addr);
  1062 + }
936 1063 return;
937 1064 case 0x8b00: /* bf label */
938 1065 CHECK_NOT_DELAY_SLOT
... ... @@ -960,44 +1087,84 @@ void _decode_opc(DisasContext * ctx)
960 1087 gen_cmp_imm(TCG_COND_EQ, REG(0), B7_0s);
961 1088 return;
962 1089 case 0xc400: /* mov.b @(disp,GBR),R0 */
963   - tcg_gen_addi_i32(cpu_T[0], cpu_gbr, B7_0);
964   - tcg_gen_qemu_ld8s(REG(0), cpu_T[0], ctx->memidx);
  1090 + {
  1091 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1092 + tcg_gen_addi_i32(addr, cpu_gbr, B7_0);
  1093 + tcg_gen_qemu_ld8s(REG(0), addr, ctx->memidx);
  1094 + tcg_temp_free(addr);
  1095 + }
965 1096 return;
966 1097 case 0xc500: /* mov.w @(disp,GBR),R0 */
967   - tcg_gen_addi_i32(cpu_T[0], cpu_gbr, B7_0 * 2);
968   - tcg_gen_qemu_ld16s(REG(0), cpu_T[0], ctx->memidx);
  1098 + {
  1099 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1100 + tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 2);
  1101 + tcg_gen_qemu_ld16s(REG(0), addr, ctx->memidx);
  1102 + tcg_temp_free(addr);
  1103 + }
969 1104 return;
970 1105 case 0xc600: /* mov.l @(disp,GBR),R0 */
971   - tcg_gen_addi_i32(cpu_T[0], cpu_gbr, B7_0 * 4);
972   - tcg_gen_qemu_ld32s(REG(0), cpu_T[0], ctx->memidx);
  1106 + {
  1107 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1108 + tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 4);
  1109 + tcg_gen_qemu_ld32s(REG(0), addr, ctx->memidx);
  1110 + tcg_temp_free(addr);
  1111 + }
973 1112 return;
974 1113 case 0xc000: /* mov.b R0,@(disp,GBR) */
975   - tcg_gen_addi_i32(cpu_T[0], cpu_gbr, B7_0);
976   - tcg_gen_qemu_st8(REG(0), cpu_T[0], ctx->memidx);
  1114 + {
  1115 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1116 + tcg_gen_addi_i32(addr, cpu_gbr, B7_0);
  1117 + tcg_gen_qemu_st8(REG(0), addr, ctx->memidx);
  1118 + tcg_temp_free(addr);
  1119 + }
977 1120 return;
978 1121 case 0xc100: /* mov.w R0,@(disp,GBR) */
979   - tcg_gen_addi_i32(cpu_T[0], cpu_gbr, B7_0 * 2);
980   - tcg_gen_qemu_st16(REG(0), cpu_T[0], ctx->memidx);
  1122 + {
  1123 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1124 + tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 2);
  1125 + tcg_gen_qemu_st16(REG(0), addr, ctx->memidx);
  1126 + tcg_temp_free(addr);
  1127 + }
981 1128 return;
982 1129 case 0xc200: /* mov.l R0,@(disp,GBR) */
983   - tcg_gen_addi_i32(cpu_T[0], cpu_gbr, B7_0 * 4);
984   - tcg_gen_qemu_st32(REG(0), cpu_T[0], ctx->memidx);
  1130 + {
  1131 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1132 + tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 4);
  1133 + tcg_gen_qemu_st32(REG(0), addr, ctx->memidx);
  1134 + tcg_temp_free(addr);
  1135 + }
985 1136 return;
986 1137 case 0x8000: /* mov.b R0,@(disp,Rn) */
987   - tcg_gen_addi_i32(cpu_T[0], REG(B7_4), B3_0);
988   - tcg_gen_qemu_st8(REG(0), cpu_T[0], ctx->memidx);
  1138 + {
  1139 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1140 + tcg_gen_addi_i32(addr, REG(B7_4), B3_0);
  1141 + tcg_gen_qemu_st8(REG(0), addr, ctx->memidx);
  1142 + tcg_temp_free(addr);
  1143 + }
989 1144 return;
990 1145 case 0x8100: /* mov.w R0,@(disp,Rn) */
991   - tcg_gen_addi_i32(cpu_T[0], REG(B7_4), B3_0 * 2);
992   - tcg_gen_qemu_st16(REG(0), cpu_T[0], ctx->memidx);
  1146 + {
  1147 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1148 + tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 2);
  1149 + tcg_gen_qemu_st16(REG(0), addr, ctx->memidx);
  1150 + tcg_temp_free(addr);
  1151 + }
993 1152 return;
994 1153 case 0x8400: /* mov.b @(disp,Rn),R0 */
995   - tcg_gen_addi_i32(cpu_T[0], REG(B7_4), B3_0);
996   - tcg_gen_qemu_ld8s(REG(0), cpu_T[0], ctx->memidx);
  1154 + {
  1155 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1156 + tcg_gen_addi_i32(addr, REG(B7_4), B3_0);
  1157 + tcg_gen_qemu_ld8s(REG(0), addr, ctx->memidx);
  1158 + tcg_temp_free(addr);
  1159 + }
997 1160 return;
998 1161 case 0x8500: /* mov.w @(disp,Rn),R0 */
999   - tcg_gen_addi_i32(cpu_T[0], REG(B7_4), B3_0 * 2);
1000   - tcg_gen_qemu_ld16s(REG(0), cpu_T[0], ctx->memidx);
  1162 + {
  1163 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1164 + tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 2);
  1165 + tcg_gen_qemu_ld16s(REG(0), addr, ctx->memidx);
  1166 + tcg_temp_free(addr);
  1167 + }
1001 1168 return;
1002 1169 case 0xc700: /* mova @(disp,PC),R0 */
1003 1170 tcg_gen_movi_i32(REG(0), ((ctx->pc & 0xfffffffc) + 4 + B7_0 * 4) & ~3);
... ... @@ -1006,36 +1173,62 @@ void _decode_opc(DisasContext * ctx)
1006 1173 tcg_gen_ori_i32(REG(0), REG(0), B7_0);
1007 1174 return;
1008 1175 case 0xcf00: /* or.b #imm,@(R0,GBR) */
1009   - tcg_gen_add_i32(cpu_T[1], REG(0), cpu_gbr);
1010   - tcg_gen_qemu_ld8u(cpu_T[0], cpu_T[1], ctx->memidx);
1011   - tcg_gen_ori_i32(cpu_T[0], cpu_T[0], B7_0);
1012   - tcg_gen_qemu_st8(cpu_T[0], cpu_T[1], ctx->memidx);
  1176 + {
  1177 + TCGv addr, val;
  1178 + addr = tcg_temp_new(TCG_TYPE_I32);
  1179 + tcg_gen_add_i32(addr, REG(0), cpu_gbr);
  1180 + val = tcg_temp_new(TCG_TYPE_I32);
  1181 + tcg_gen_qemu_ld8u(val, addr, ctx->memidx);
  1182 + tcg_gen_ori_i32(val, val, B7_0);
  1183 + tcg_gen_qemu_st8(val, addr, ctx->memidx);
  1184 + tcg_temp_free(val);
  1185 + tcg_temp_free(addr);
  1186 + }
1013 1187 return;
1014 1188 case 0xc300: /* trapa #imm */
1015   - CHECK_NOT_DELAY_SLOT
1016   - tcg_gen_movi_i32(cpu_pc, ctx->pc);
1017   - tcg_gen_movi_i32(cpu_T[0], B7_0);
1018   - tcg_gen_helper_0_1(helper_trapa, cpu_T[0]);
1019   - ctx->bstate = BS_BRANCH;
  1189 + {
  1190 + TCGv imm;
  1191 + CHECK_NOT_DELAY_SLOT
  1192 + tcg_gen_movi_i32(cpu_pc, ctx->pc);
  1193 + imm = tcg_const_i32(B7_0);
  1194 + tcg_gen_helper_0_1(helper_trapa, imm);
  1195 + tcg_temp_free(imm);
  1196 + ctx->bstate = BS_BRANCH;
  1197 + }
1020 1198 return;
1021 1199 case 0xc800: /* tst #imm,R0 */
1022   - tcg_gen_andi_i32(cpu_T[0], REG(0), B7_0);
1023   - gen_cmp_imm(TCG_COND_EQ, cpu_T[0], 0);
  1200 + {
  1201 + TCGv val = tcg_temp_new(TCG_TYPE_I32);
  1202 + tcg_gen_andi_i32(val, REG(0), B7_0);
  1203 + gen_cmp_imm(TCG_COND_EQ, val, 0);
  1204 + tcg_temp_free(val);
  1205 + }
1024 1206 return;
1025 1207 case 0xcc00: /* tst.b #imm,@(R0,GBR) */
1026   - tcg_gen_add_i32(cpu_T[0], REG(0), cpu_gbr);
1027   - tcg_gen_qemu_ld8u(cpu_T[0], cpu_T[0], ctx->memidx);
1028   - tcg_gen_andi_i32(cpu_T[0], cpu_T[0], B7_0);
1029   - gen_cmp_imm(TCG_COND_EQ, cpu_T[0], 0);
  1208 + {
  1209 + TCGv val = tcg_temp_new(TCG_TYPE_I32);
  1210 + tcg_gen_add_i32(val, REG(0), cpu_gbr);
  1211 + tcg_gen_qemu_ld8u(val, val, ctx->memidx);
  1212 + tcg_gen_andi_i32(val, val, B7_0);
  1213 + gen_cmp_imm(TCG_COND_EQ, val, 0);
  1214 + tcg_temp_free(val);
  1215 + }
1030 1216 return;
1031 1217 case 0xca00: /* xor #imm,R0 */
1032 1218 tcg_gen_xori_i32(REG(0), REG(0), B7_0);
1033 1219 return;
1034 1220 case 0xce00: /* xor.b #imm,@(R0,GBR) */
1035   - tcg_gen_add_i32(cpu_T[1], REG(0), cpu_gbr);
1036   - tcg_gen_qemu_ld8u(cpu_T[0], cpu_T[1], ctx->memidx);
1037   - tcg_gen_xori_i32(cpu_T[0], cpu_T[0], B7_0);
1038   - tcg_gen_qemu_st8(cpu_T[0], cpu_T[1], ctx->memidx);
  1221 + {
  1222 + TCGv addr, val;
  1223 + addr = tcg_temp_new(TCG_TYPE_I32);
  1224 + tcg_gen_add_i32(addr, REG(0), cpu_gbr);
  1225 + val = tcg_temp_new(TCG_TYPE_I32);
  1226 + tcg_gen_qemu_ld8u(val, addr, ctx->memidx);
  1227 + tcg_gen_xori_i32(val, val, B7_0);
  1228 + tcg_gen_qemu_st8(val, addr, ctx->memidx);
  1229 + tcg_temp_free(val);
  1230 + tcg_temp_free(addr);
  1231 + }
1039 1232 return;
1040 1233 }
1041 1234  
... ... @@ -1051,9 +1244,13 @@ void _decode_opc(DisasContext * ctx)
1051 1244 tcg_gen_mov_i32(REG(B11_8), ALTREG(B6_4));
1052 1245 return;
1053 1246 case 0x4083: /* stc.l Rm_BANK,@-Rn */
1054   - tcg_gen_subi_i32(cpu_T[0], REG(B11_8), 4);
1055   - tcg_gen_qemu_st32(ALTREG(B6_4), cpu_T[0], ctx->memidx);
1056   - tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
  1247 + {
  1248 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1249 + tcg_gen_subi_i32(addr, REG(B11_8), 4);
  1250 + tcg_gen_qemu_st32(ALTREG(B6_4), addr, ctx->memidx);
  1251 + tcg_temp_free(addr);
  1252 + tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
  1253 + }
1057 1254 return;
1058 1255 }
1059 1256  
... ... @@ -1099,18 +1296,26 @@ void _decode_opc(DisasContext * ctx)
1099 1296 ctx->bstate = BS_STOP;
1100 1297 return;
1101 1298 case 0x4007: /* lds.l @Rm+,SR */
1102   - tcg_gen_qemu_ld32s(cpu_T[0], REG(B11_8), ctx->memidx);
1103   - tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1104   - tcg_gen_andi_i32(cpu_sr, cpu_T[0], 0x700083f3);
1105   - ctx->bstate = BS_STOP;
  1299 + {
  1300 + TCGv val = tcg_temp_new(TCG_TYPE_I32);
  1301 + tcg_gen_qemu_ld32s(val, REG(B11_8), ctx->memidx);
  1302 + tcg_gen_andi_i32(cpu_sr, val, 0x700083f3);
  1303 + tcg_temp_free(val);
  1304 + tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
  1305 + ctx->bstate = BS_STOP;
  1306 + }
1106 1307 return;
1107 1308 case 0x0002: /* sts SR,Rn */
1108 1309 tcg_gen_mov_i32(REG(B11_8), cpu_sr);
1109 1310 return;
1110 1311 case 0x4003: /* sts SR,@-Rn */
1111   - tcg_gen_subi_i32(cpu_T[0], REG(B11_8), 4);
1112   - tcg_gen_qemu_st32(cpu_sr, cpu_T[0], ctx->memidx);
1113   - tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
  1312 + {
  1313 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1314 + tcg_gen_subi_i32(addr, REG(B11_8), 4);
  1315 + tcg_gen_qemu_st32(cpu_sr, addr, ctx->memidx);
  1316 + tcg_temp_free(addr);
  1317 + tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
  1318 + }
1114 1319 return;
1115 1320 #define LDST(reg,ldnum,ldpnum,stnum,stpnum) \
1116 1321 case ldnum: \
... ... @@ -1124,9 +1329,13 @@ void _decode_opc(DisasContext * ctx)
1124 1329 tcg_gen_mov_i32 (REG(B11_8), cpu_##reg); \
1125 1330 return; \
1126 1331 case stpnum: \
1127   - tcg_gen_subi_i32(cpu_T[0], REG(B11_8), 4); \
1128   - tcg_gen_qemu_st32 (cpu_##reg, cpu_T[0], ctx->memidx); \
1129   - tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4); \
  1332 + { \
  1333 + TCGv addr = tcg_temp_new(TCG_TYPE_I32); \
  1334 + tcg_gen_subi_i32(addr, REG(B11_8), 4); \
  1335 + tcg_gen_qemu_st32 (cpu_##reg, addr, ctx->memidx); \
  1336 + tcg_temp_free(addr); \
  1337 + tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4); \
  1338 + }
1130 1339 return;
1131 1340 LDST(gbr, 0x401e, 0x4017, 0x0012, 0x4013)
1132 1341 LDST(vbr, 0x402e, 0x4027, 0x0022, 0x4023)
... ... @@ -1142,20 +1351,30 @@ void _decode_opc(DisasContext * ctx)
1142 1351 ctx->bstate = BS_STOP;
1143 1352 return;
1144 1353 case 0x4066: /* lds.l @Rm+,FPSCR */
1145   - tcg_gen_qemu_ld32s(cpu_T[0], REG(B11_8), ctx->memidx);
1146   - tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1147   - tcg_gen_helper_0_1(helper_ld_fpscr, cpu_T[0]);
1148   - ctx->bstate = BS_STOP;
  1354 + {
  1355 + TCGv addr = tcg_temp_new(TCG_TYPE_I32);
  1356 + tcg_gen_qemu_ld32s(addr, REG(B11_8), ctx->memidx);
  1357 + tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
  1358 + tcg_gen_helper_0_1(helper_ld_fpscr, addr);
  1359 + tcg_temp_free(addr);
  1360 + ctx->bstate = BS_STOP;
  1361 + }
1149 1362 return;
1150 1363 case 0x006a: /* sts FPSCR,Rn */
1151   - tcg_gen_andi_i32(cpu_T[0], cpu_fpscr, 0x003fffff);
1152   - tcg_gen_mov_i32(REG(B11_8), cpu_T[0]);
  1364 + tcg_gen_andi_i32(REG(B11_8), cpu_fpscr, 0x003fffff);
1153 1365 return;
1154 1366 case 0x4062: /* sts FPSCR,@-Rn */
1155   - tcg_gen_andi_i32(cpu_T[0], cpu_fpscr, 0x003fffff);
1156   - tcg_gen_subi_i32(cpu_T[1], REG(B11_8), 4);
1157   - tcg_gen_qemu_st32(cpu_T[0], cpu_T[1], ctx->memidx);
1158   - tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
  1367 + {
  1368 + TCGv addr, val;
  1369 + val = tcg_temp_new(TCG_TYPE_I32);
  1370 + tcg_gen_andi_i32(val, cpu_fpscr, 0x003fffff);
  1371 + addr = tcg_temp_new(TCG_TYPE_I32);
  1372 + tcg_gen_subi_i32(addr, REG(B11_8), 4);
  1373 + tcg_gen_qemu_st32(val, addr, ctx->memidx);
  1374 + tcg_temp_free(addr);
  1375 + tcg_temp_free(val);
  1376 + tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
  1377 + }
1159 1378 return;
1160 1379 case 0x00c3: /* movca.l R0,@Rm */
1161 1380 tcg_gen_qemu_st32(REG(0), REG(B11_8), ctx->memidx);
... ... @@ -1164,27 +1383,47 @@ void _decode_opc(DisasContext * ctx)
1164 1383 tcg_gen_andi_i32(REG(B11_8), cpu_sr, SR_T);
1165 1384 return;
1166 1385 case 0x0093: /* ocbi @Rn */
1167   - tcg_gen_qemu_ld32s(cpu_T[0], REG(B11_8), ctx->memidx);
  1386 + {
  1387 + TCGv dummy = tcg_temp_new(TCG_TYPE_I32);
  1388 + tcg_gen_qemu_ld32s(dummy, REG(B11_8), ctx->memidx);
  1389 + tcg_temp_free(dummy);
  1390 + }
1168 1391 return;
1169 1392 case 0x00a3: /* ocbp @Rn */
1170   - tcg_gen_qemu_ld32s(cpu_T[0], REG(B11_8), ctx->memidx);
  1393 + {
  1394 + TCGv dummy = tcg_temp_new(TCG_TYPE_I32);
  1395 + tcg_gen_qemu_ld32s(dummy, REG(B11_8), ctx->memidx);
  1396 + tcg_temp_free(dummy);
  1397 + }
1171 1398 return;
1172 1399 case 0x00b3: /* ocbwb @Rn */
1173   - tcg_gen_qemu_ld32s(cpu_T[0], REG(B11_8), ctx->memidx);
  1400 + {
  1401 + TCGv dummy = tcg_temp_new(TCG_TYPE_I32);
  1402 + tcg_gen_qemu_ld32s(dummy, REG(B11_8), ctx->memidx);
  1403 + tcg_temp_free(dummy);
  1404 + }
1174 1405 return;
1175 1406 case 0x0083: /* pref @Rn */
1176 1407 return;
1177 1408 case 0x4024: /* rotcl Rn */
1178   - tcg_gen_mov_i32(cpu_T[0], cpu_sr);
1179   - gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 31);
1180   - tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 1);
1181   - gen_copy_bit_i32(REG(B11_8), 0, cpu_T[0], 0);
  1409 + {
  1410 + TCGv tmp = tcg_temp_new(TCG_TYPE_I32);
  1411 + tcg_gen_mov_i32(tmp, cpu_sr);
  1412 + gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 31);
  1413 + tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 1);
  1414 + gen_copy_bit_i32(REG(B11_8), 0, tmp, 0);
  1415 + tcg_temp_free(tmp);
  1416 + }
1182 1417 return;
1183 1418 case 0x4025: /* rotcr Rn */
1184   - tcg_gen_mov_i32(cpu_T[0], cpu_sr);
1185   - gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
1186   - tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 1);
1187   - gen_copy_bit_i32(REG(B11_8), 31, cpu_T[0], 0);
  1419 + {
  1420 + TCGv tmp = tcg_temp_new(TCG_TYPE_I32);
  1421 + tcg_gen_mov_i32(tmp, cpu_sr);
  1422 + gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
  1423 + tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 1);
  1424 + gen_copy_bit_i32(REG(B11_8), 31, tmp, 0);
  1425 + tcg_temp_free(tmp);
  1426 + }
1188 1427 return;
1189 1428 case 0x4004: /* rotl Rn */
1190 1429 gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 31);
... ... @@ -1228,11 +1467,18 @@ void _decode_opc(DisasContext * ctx)
1228 1467 tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 16);
1229 1468 return;
1230 1469 case 0x401b: /* tas.b @Rn */
1231   - tcg_gen_mov_i32(cpu_T[1], REG(B11_8));
1232   - tcg_gen_qemu_ld8u(cpu_T[0], cpu_T[1], ctx->memidx);
1233   - gen_cmp_imm(TCG_COND_EQ, cpu_T[0], 0);
1234   - tcg_gen_ori_i32(cpu_T[0], cpu_T[0], 0x80);
1235   - tcg_gen_qemu_st8(cpu_T[0], cpu_T[1], ctx->memidx);
  1470 + {
  1471 + TCGv addr, val;
  1472 + addr = tcg_temp_local_new(TCG_TYPE_I32);
  1473 + tcg_gen_mov_i32(addr, REG(B11_8));
  1474 + val = tcg_temp_local_new(TCG_TYPE_I32);
  1475 + tcg_gen_qemu_ld8u(val, addr, ctx->memidx);
  1476 + gen_cmp_imm(TCG_COND_EQ, val, 0);
  1477 + tcg_gen_ori_i32(val, val, 0x80);
  1478 + tcg_gen_qemu_st8(val, addr, ctx->memidx);
  1479 + tcg_temp_free(val);
  1480 + tcg_temp_free(addr);
  1481 + }
1236 1482 return;
1237 1483 case 0xf00d: /* fsts FPUL,FRn - FPSCR: Nothing */
1238 1484 gen_op_movl_fpul_FT0();
... ...