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,10 +261,12 @@ static void gen_jump(DisasContext * ctx)
261 261
262 static inline void gen_branch_slot(uint32_t delayed_pc, int t) 262 static inline void gen_branch_slot(uint32_t delayed_pc, int t)
263 { 263 {
  264 + TCGv sr;
264 int label = gen_new_label(); 265 int label = gen_new_label();
265 tcg_gen_movi_i32(cpu_delayed_pc, delayed_pc); 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 tcg_gen_ori_i32(cpu_flags, cpu_flags, DELAY_SLOT_TRUE); 270 tcg_gen_ori_i32(cpu_flags, cpu_flags, DELAY_SLOT_TRUE);
269 gen_set_label(label); 271 gen_set_label(label);
270 } 272 }
@@ -274,10 +276,12 @@ static void gen_conditional_jump(DisasContext * ctx, @@ -274,10 +276,12 @@ static void gen_conditional_jump(DisasContext * ctx,
274 target_ulong ift, target_ulong ifnott) 276 target_ulong ift, target_ulong ifnott)
275 { 277 {
276 int l1; 278 int l1;
  279 + TCGv sr;
277 280
278 l1 = gen_new_label(); 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 gen_goto_tb(ctx, 0, ifnott); 285 gen_goto_tb(ctx, 0, ifnott);
282 gen_set_label(l1); 286 gen_set_label(l1);
283 gen_goto_tb(ctx, 1, ift); 287 gen_goto_tb(ctx, 1, ift);
@@ -287,10 +291,12 @@ static void gen_conditional_jump(DisasContext * ctx, @@ -287,10 +291,12 @@ static void gen_conditional_jump(DisasContext * ctx,
287 static void gen_delayed_conditional_jump(DisasContext * ctx) 291 static void gen_delayed_conditional_jump(DisasContext * ctx)
288 { 292 {
289 int l1; 293 int l1;
  294 + TCGv ds;
290 295
291 l1 = gen_new_label(); 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 gen_goto_tb(ctx, 1, ctx->pc + 2); 300 gen_goto_tb(ctx, 1, ctx->pc + 2);
295 gen_set_label(l1); 301 gen_set_label(l1);
296 tcg_gen_andi_i32(cpu_flags, cpu_flags, ~DELAY_SLOT_TRUE); 302 tcg_gen_andi_i32(cpu_flags, cpu_flags, ~DELAY_SLOT_TRUE);
@@ -448,23 +454,37 @@ void _decode_opc(DisasContext * ctx) @@ -448,23 +454,37 @@ void _decode_opc(DisasContext * ctx)
448 454
449 switch (ctx->opcode & 0xf000) { 455 switch (ctx->opcode & 0xf000) {
450 case 0x1000: /* mov.l Rm,@(disp,Rn) */ 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 return; 463 return;
454 case 0x5000: /* mov.l @(disp,Rm),Rn */ 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 return; 471 return;
458 case 0xe000: /* mov #imm,Rn */ 472 case 0xe000: /* mov #imm,Rn */
459 tcg_gen_movi_i32(REG(B11_8), B7_0s); 473 tcg_gen_movi_i32(REG(B11_8), B7_0s);
460 return; 474 return;
461 case 0x9000: /* mov.w @(disp,PC),Rn */ 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 return; 481 return;
465 case 0xd000: /* mov.l @(disp,PC),Rn */ 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 return; 488 return;
469 case 0x7000: /* add #imm,Rn */ 489 case 0x7000: /* add #imm,Rn */
470 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), B7_0s); 490 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), B7_0s);
@@ -507,19 +527,30 @@ void _decode_opc(DisasContext * ctx) @@ -507,19 +527,30 @@ void _decode_opc(DisasContext * ctx)
507 tcg_gen_qemu_ld32s(REG(B11_8), REG(B7_4), ctx->memidx); 527 tcg_gen_qemu_ld32s(REG(B11_8), REG(B7_4), ctx->memidx);
508 return; 528 return;
509 case 0x2004: /* mov.b Rm,@-Rn */ 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 return; 537 return;
514 case 0x2005: /* mov.w Rm,@-Rn */ 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 return; 546 return;
519 case 0x2006: /* mov.l Rm,@-Rn */ 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 return; 554 return;
524 case 0x6004: /* mov.b @Rm+,Rn */ 555 case 0x6004: /* mov.b @Rm+,Rn */
525 tcg_gen_qemu_ld8s(REG(B11_8), REG(B7_4), ctx->memidx); 556 tcg_gen_qemu_ld8s(REG(B11_8), REG(B7_4), ctx->memidx);
@@ -537,49 +568,94 @@ void _decode_opc(DisasContext * ctx) @@ -537,49 +568,94 @@ void _decode_opc(DisasContext * ctx)
537 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4); 568 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
538 return; 569 return;
539 case 0x0004: /* mov.b Rm,@(R0,Rn) */ 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 return; 577 return;
543 case 0x0005: /* mov.w Rm,@(R0,Rn) */ 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 return; 585 return;
547 case 0x0006: /* mov.l Rm,@(R0,Rn) */ 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 return; 593 return;
551 case 0x000c: /* mov.b @(R0,Rm),Rn */ 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 return; 601 return;
555 case 0x000d: /* mov.w @(R0,Rm),Rn */ 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 return; 609 return;
559 case 0x000e: /* mov.l @(R0,Rm),Rn */ 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 return; 617 return;
563 case 0x6008: /* swap.b Rm,Rn */ 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 return; 631 return;
570 case 0x6009: /* swap.w Rm,Rn */ 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 return; 645 return;
577 case 0x200d: /* xtrct Rm,Rn */ 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 return; 659 return;
584 case 0x300c: /* add Rm,Rn */ 660 case 0x300c: /* add Rm,Rn */
585 tcg_gen_add_i32(REG(B11_8), REG(B11_8), REG(B7_4)); 661 tcg_gen_add_i32(REG(B11_8), REG(B11_8), REG(B7_4));
@@ -612,27 +688,35 @@ void _decode_opc(DisasContext * ctx) @@ -612,27 +688,35 @@ void _decode_opc(DisasContext * ctx)
612 { 688 {
613 int label1 = gen_new_label(); 689 int label1 = gen_new_label();
614 int label2 = gen_new_label(); 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 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T); 702 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
625 tcg_gen_br(label2); 703 tcg_gen_br(label2);
626 gen_set_label(label1); 704 gen_set_label(label1);
627 tcg_gen_ori_i32(cpu_sr, cpu_sr, SR_T); 705 tcg_gen_ori_i32(cpu_sr, cpu_sr, SR_T);
628 gen_set_label(label2); 706 gen_set_label(label2);
  707 + tcg_temp_free(cmp2);
  708 + tcg_temp_free(cmp1);
629 } 709 }
630 return; 710 return;
631 case 0x2007: /* div0s Rm,Rn */ 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 return; 720 return;
637 case 0x3004: /* div1 Rm,Rn */ 721 case 0x3004: /* div1 Rm,Rn */
638 tcg_gen_helper_1_2(helper_div1, REG(B11_8), REG(B7_4), REG(B11_8)); 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,8 +733,8 @@ void _decode_opc(DisasContext * ctx)
649 tcg_gen_shri_i64(tmp1, tmp1, 32); 733 tcg_gen_shri_i64(tmp1, tmp1, 32);
650 tcg_gen_trunc_i64_i32(cpu_mach, tmp1); 734 tcg_gen_trunc_i64_i32(cpu_mach, tmp1);
651 735
652 - tcg_temp_free(tmp1);  
653 tcg_temp_free(tmp2); 736 tcg_temp_free(tmp2);
  737 + tcg_temp_free(tmp1);
654 } 738 }
655 return; 739 return;
656 case 0x3005: /* dmulu.l Rm,Rn */ 740 case 0x3005: /* dmulu.l Rm,Rn */
@@ -665,8 +749,8 @@ void _decode_opc(DisasContext * ctx) @@ -665,8 +749,8 @@ void _decode_opc(DisasContext * ctx)
665 tcg_gen_shri_i64(tmp1, tmp1, 32); 749 tcg_gen_shri_i64(tmp1, tmp1, 32);
666 tcg_gen_trunc_i64_i32(cpu_mach, tmp1); 750 tcg_gen_trunc_i64_i32(cpu_mach, tmp1);
667 751
668 - tcg_temp_free(tmp1);  
669 tcg_temp_free(tmp2); 752 tcg_temp_free(tmp2);
  753 + tcg_temp_free(tmp1);
670 } 754 }
671 return; 755 return;
672 case 0x600e: /* exts.b Rm,Rn */ 756 case 0x600e: /* exts.b Rm,Rn */
@@ -682,31 +766,59 @@ void _decode_opc(DisasContext * ctx) @@ -682,31 +766,59 @@ void _decode_opc(DisasContext * ctx)
682 tcg_gen_ext16u_i32(REG(B11_8), REG(B7_4)); 766 tcg_gen_ext16u_i32(REG(B11_8), REG(B7_4));
683 return; 767 return;
684 case 0x000f: /* mac.l @Rm+,@Rn+ */ 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 return; 781 return;
691 case 0x400f: /* mac.w @Rm+,@Rn+ */ 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 return; 795 return;
698 case 0x0007: /* mul.l Rm,Rn */ 796 case 0x0007: /* mul.l Rm,Rn */
699 tcg_gen_mul_i32(cpu_macl, REG(B7_4), REG(B11_8)); 797 tcg_gen_mul_i32(cpu_macl, REG(B7_4), REG(B11_8));
700 return; 798 return;
701 case 0x200f: /* muls.w Rm,Rn */ 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 return; 810 return;
706 case 0x200e: /* mulu.w Rm,Rn */ 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 return; 822 return;
711 case 0x600b: /* neg Rm,Rn */ 823 case 0x600b: /* neg Rm,Rn */
712 tcg_gen_neg_i32(REG(B11_8), REG(B7_4)); 824 tcg_gen_neg_i32(REG(B11_8), REG(B7_4));
@@ -726,19 +838,20 @@ void _decode_opc(DisasContext * ctx) @@ -726,19 +838,20 @@ void _decode_opc(DisasContext * ctx)
726 int label2 = gen_new_label(); 838 int label2 = gen_new_label();
727 int label3 = gen_new_label(); 839 int label3 = gen_new_label();
728 int label4 = gen_new_label(); 840 int label4 = gen_new_label();
  841 + TCGv shift = tcg_temp_local_new(TCG_TYPE_I32);
729 tcg_gen_brcondi_i32(TCG_COND_LT, REG(B7_4), 0, label1); 842 tcg_gen_brcondi_i32(TCG_COND_LT, REG(B7_4), 0, label1);
730 /* Rm positive, shift to the left */ 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 tcg_gen_br(label4); 846 tcg_gen_br(label4);
734 /* Rm negative, shift to the right */ 847 /* Rm negative, shift to the right */
735 gen_set_label(label1); 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 tcg_gen_br(label4); 855 tcg_gen_br(label4);
743 /* Rm = -32 */ 856 /* Rm = -32 */
744 gen_set_label(label2); 857 gen_set_label(label2);
@@ -748,6 +861,7 @@ void _decode_opc(DisasContext * ctx) @@ -748,6 +861,7 @@ void _decode_opc(DisasContext * ctx)
748 gen_set_label(label3); 861 gen_set_label(label3);
749 tcg_gen_movi_i32(REG(B11_8), 0xffffffff); 862 tcg_gen_movi_i32(REG(B11_8), 0xffffffff);
750 gen_set_label(label4); 863 gen_set_label(label4);
  864 + tcg_temp_free(shift);
751 } 865 }
752 return; 866 return;
753 case 0x400d: /* shld Rm,Rn */ 867 case 0x400d: /* shld Rm,Rn */
@@ -755,24 +869,26 @@ void _decode_opc(DisasContext * ctx) @@ -755,24 +869,26 @@ void _decode_opc(DisasContext * ctx)
755 int label1 = gen_new_label(); 869 int label1 = gen_new_label();
756 int label2 = gen_new_label(); 870 int label2 = gen_new_label();
757 int label3 = gen_new_label(); 871 int label3 = gen_new_label();
  872 + TCGv shift = tcg_temp_local_new(TCG_TYPE_I32);
758 tcg_gen_brcondi_i32(TCG_COND_LT, REG(B7_4), 0, label1); 873 tcg_gen_brcondi_i32(TCG_COND_LT, REG(B7_4), 0, label1);
759 /* Rm positive, shift to the left */ 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 tcg_gen_br(label3); 877 tcg_gen_br(label3);
763 /* Rm negative, shift to the right */ 878 /* Rm negative, shift to the right */
764 gen_set_label(label1); 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 tcg_gen_br(label3); 886 tcg_gen_br(label3);
772 /* Rm = -32 */ 887 /* Rm = -32 */
773 gen_set_label(label2); 888 gen_set_label(label2);
774 tcg_gen_movi_i32(REG(B11_8), 0); 889 tcg_gen_movi_i32(REG(B11_8), 0);
775 gen_set_label(label3); 890 gen_set_label(label3);
  891 + tcg_temp_free(shift);
776 } 892 }
777 return; 893 return;
778 case 0x3008: /* sub Rm,Rn */ 894 case 0x3008: /* sub Rm,Rn */
@@ -785,8 +901,12 @@ void _decode_opc(DisasContext * ctx) @@ -785,8 +901,12 @@ void _decode_opc(DisasContext * ctx)
785 tcg_gen_helper_1_2(helper_subv, REG(B11_8), REG(B7_4), REG(B11_8)); 901 tcg_gen_helper_1_2(helper_subv, REG(B11_8), REG(B7_4), REG(B11_8));
786 return; 902 return;
787 case 0x2008: /* tst Rm,Rn */ 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 return; 910 return;
791 case 0x200a: /* xor Rm,Rn */ 911 case 0x200a: /* xor Rm,Rn */
792 tcg_gen_xor_i32(REG(B11_8), REG(B11_8), REG(B7_4)); 912 tcg_gen_xor_i32(REG(B11_8), REG(B11_8), REG(B7_4));
@@ -929,10 +1049,17 @@ void _decode_opc(DisasContext * ctx) @@ -929,10 +1049,17 @@ void _decode_opc(DisasContext * ctx)
929 tcg_gen_andi_i32(REG(0), REG(0), B7_0); 1049 tcg_gen_andi_i32(REG(0), REG(0), B7_0);
930 return; 1050 return;
931 case 0xcd00: /* and.b #imm,@(R0,GBR) */ 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 return; 1063 return;
937 case 0x8b00: /* bf label */ 1064 case 0x8b00: /* bf label */
938 CHECK_NOT_DELAY_SLOT 1065 CHECK_NOT_DELAY_SLOT
@@ -960,44 +1087,84 @@ void _decode_opc(DisasContext * ctx) @@ -960,44 +1087,84 @@ void _decode_opc(DisasContext * ctx)
960 gen_cmp_imm(TCG_COND_EQ, REG(0), B7_0s); 1087 gen_cmp_imm(TCG_COND_EQ, REG(0), B7_0s);
961 return; 1088 return;
962 case 0xc400: /* mov.b @(disp,GBR),R0 */ 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 return; 1096 return;
966 case 0xc500: /* mov.w @(disp,GBR),R0 */ 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 return; 1104 return;
970 case 0xc600: /* mov.l @(disp,GBR),R0 */ 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 return; 1112 return;
974 case 0xc000: /* mov.b R0,@(disp,GBR) */ 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 return; 1120 return;
978 case 0xc100: /* mov.w R0,@(disp,GBR) */ 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 return; 1128 return;
982 case 0xc200: /* mov.l R0,@(disp,GBR) */ 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 return; 1136 return;
986 case 0x8000: /* mov.b R0,@(disp,Rn) */ 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 return; 1144 return;
990 case 0x8100: /* mov.w R0,@(disp,Rn) */ 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 return; 1152 return;
994 case 0x8400: /* mov.b @(disp,Rn),R0 */ 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 return; 1160 return;
998 case 0x8500: /* mov.w @(disp,Rn),R0 */ 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 return; 1168 return;
1002 case 0xc700: /* mova @(disp,PC),R0 */ 1169 case 0xc700: /* mova @(disp,PC),R0 */
1003 tcg_gen_movi_i32(REG(0), ((ctx->pc & 0xfffffffc) + 4 + B7_0 * 4) & ~3); 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,36 +1173,62 @@ void _decode_opc(DisasContext * ctx)
1006 tcg_gen_ori_i32(REG(0), REG(0), B7_0); 1173 tcg_gen_ori_i32(REG(0), REG(0), B7_0);
1007 return; 1174 return;
1008 case 0xcf00: /* or.b #imm,@(R0,GBR) */ 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 return; 1187 return;
1014 case 0xc300: /* trapa #imm */ 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 return; 1198 return;
1021 case 0xc800: /* tst #imm,R0 */ 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 return; 1206 return;
1025 case 0xcc00: /* tst.b #imm,@(R0,GBR) */ 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 return; 1216 return;
1031 case 0xca00: /* xor #imm,R0 */ 1217 case 0xca00: /* xor #imm,R0 */
1032 tcg_gen_xori_i32(REG(0), REG(0), B7_0); 1218 tcg_gen_xori_i32(REG(0), REG(0), B7_0);
1033 return; 1219 return;
1034 case 0xce00: /* xor.b #imm,@(R0,GBR) */ 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 return; 1232 return;
1040 } 1233 }
1041 1234
@@ -1051,9 +1244,13 @@ void _decode_opc(DisasContext * ctx) @@ -1051,9 +1244,13 @@ void _decode_opc(DisasContext * ctx)
1051 tcg_gen_mov_i32(REG(B11_8), ALTREG(B6_4)); 1244 tcg_gen_mov_i32(REG(B11_8), ALTREG(B6_4));
1052 return; 1245 return;
1053 case 0x4083: /* stc.l Rm_BANK,@-Rn */ 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 return; 1254 return;
1058 } 1255 }
1059 1256
@@ -1099,18 +1296,26 @@ void _decode_opc(DisasContext * ctx) @@ -1099,18 +1296,26 @@ void _decode_opc(DisasContext * ctx)
1099 ctx->bstate = BS_STOP; 1296 ctx->bstate = BS_STOP;
1100 return; 1297 return;
1101 case 0x4007: /* lds.l @Rm+,SR */ 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 return; 1307 return;
1107 case 0x0002: /* sts SR,Rn */ 1308 case 0x0002: /* sts SR,Rn */
1108 tcg_gen_mov_i32(REG(B11_8), cpu_sr); 1309 tcg_gen_mov_i32(REG(B11_8), cpu_sr);
1109 return; 1310 return;
1110 case 0x4003: /* sts SR,@-Rn */ 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 return; 1319 return;
1115 #define LDST(reg,ldnum,ldpnum,stnum,stpnum) \ 1320 #define LDST(reg,ldnum,ldpnum,stnum,stpnum) \
1116 case ldnum: \ 1321 case ldnum: \
@@ -1124,9 +1329,13 @@ void _decode_opc(DisasContext * ctx) @@ -1124,9 +1329,13 @@ void _decode_opc(DisasContext * ctx)
1124 tcg_gen_mov_i32 (REG(B11_8), cpu_##reg); \ 1329 tcg_gen_mov_i32 (REG(B11_8), cpu_##reg); \
1125 return; \ 1330 return; \
1126 case stpnum: \ 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 return; 1339 return;
1131 LDST(gbr, 0x401e, 0x4017, 0x0012, 0x4013) 1340 LDST(gbr, 0x401e, 0x4017, 0x0012, 0x4013)
1132 LDST(vbr, 0x402e, 0x4027, 0x0022, 0x4023) 1341 LDST(vbr, 0x402e, 0x4027, 0x0022, 0x4023)
@@ -1142,20 +1351,30 @@ void _decode_opc(DisasContext * ctx) @@ -1142,20 +1351,30 @@ void _decode_opc(DisasContext * ctx)
1142 ctx->bstate = BS_STOP; 1351 ctx->bstate = BS_STOP;
1143 return; 1352 return;
1144 case 0x4066: /* lds.l @Rm+,FPSCR */ 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 return; 1362 return;
1150 case 0x006a: /* sts FPSCR,Rn */ 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 return; 1365 return;
1154 case 0x4062: /* sts FPSCR,@-Rn */ 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 return; 1378 return;
1160 case 0x00c3: /* movca.l R0,@Rm */ 1379 case 0x00c3: /* movca.l R0,@Rm */
1161 tcg_gen_qemu_st32(REG(0), REG(B11_8), ctx->memidx); 1380 tcg_gen_qemu_st32(REG(0), REG(B11_8), ctx->memidx);
@@ -1164,27 +1383,47 @@ void _decode_opc(DisasContext * ctx) @@ -1164,27 +1383,47 @@ void _decode_opc(DisasContext * ctx)
1164 tcg_gen_andi_i32(REG(B11_8), cpu_sr, SR_T); 1383 tcg_gen_andi_i32(REG(B11_8), cpu_sr, SR_T);
1165 return; 1384 return;
1166 case 0x0093: /* ocbi @Rn */ 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 return; 1391 return;
1169 case 0x00a3: /* ocbp @Rn */ 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 return; 1398 return;
1172 case 0x00b3: /* ocbwb @Rn */ 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 return; 1405 return;
1175 case 0x0083: /* pref @Rn */ 1406 case 0x0083: /* pref @Rn */
1176 return; 1407 return;
1177 case 0x4024: /* rotcl Rn */ 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 return; 1417 return;
1183 case 0x4025: /* rotcr Rn */ 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 return; 1427 return;
1189 case 0x4004: /* rotl Rn */ 1428 case 0x4004: /* rotl Rn */
1190 gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 31); 1429 gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 31);
@@ -1228,11 +1467,18 @@ void _decode_opc(DisasContext * ctx) @@ -1228,11 +1467,18 @@ void _decode_opc(DisasContext * ctx)
1228 tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 16); 1467 tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 16);
1229 return; 1468 return;
1230 case 0x401b: /* tas.b @Rn */ 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 return; 1482 return;
1237 case 0xf00d: /* fsts FPUL,FRn - FPSCR: Nothing */ 1483 case 0xf00d: /* fsts FPUL,FRn - FPSCR: Nothing */
1238 gen_op_movl_fpul_FT0(); 1484 gen_op_movl_fpul_FT0();