drc: some debug improvements
[picodrive.git] / cpu / sh2 / compiler.c
index bdf2cea..f76ba43 100644 (file)
@@ -119,13 +119,16 @@ enum op_types {
   OP_BRANCH_RF, // indirect far (PC + Rm)
   OP_SETCLRT,   // T flag set/clear
   OP_MOVE,      // register move
-  OP_LOAD_POOL, // literal pool load
+  OP_LOAD_POOL, // literal pool load, imm is address
+  OP_MOVA,
   OP_SLEEP,
   OP_RTE,
 };
 
 #ifdef DRC_SH2
 
+static int literal_disabled_frames;
+
 #if (DRC_DEBUG & 4)
 static u8 *tcache_dsm_ptrs[3];
 static char sh2dasm_buff[64];
@@ -187,7 +190,8 @@ struct block_entry {
 
 struct block_desc {
   u32 addr;                  // block start SH2 PC address
-  u32 end_addr;              // address after last op or literal
+  u16 size;                  // ..of recompiled insns+lit. pool
+  u16 size_nolit;            // same without literals
 #if (DRC_DEBUG & 2)
   int refcount;
 #endif
@@ -219,7 +223,7 @@ static const int ram_sizes[TCACHE_BUFFERS] = {
   0x1000,
   0x1000,
 };
-#define ADDR_TO_BLOCK_PAGE 0x100
+#define INVAL_PAGE_SIZE 0x100
 
 struct block_list {
   struct block_desc *block;
@@ -227,7 +231,7 @@ struct block_list {
 };
 
 // array of pointers to block_lists for RAM and 2 data arrays
-// each array has len: sizeof(mem) / ADDR_TO_BLOCK_PAG
+// each array has len: sizeof(mem) / INVAL_PAGE_SIZ
 static struct block_list **inval_lookup[TCACHE_BUFFERS];
 
 static const int hash_table_sizes[TCACHE_BUFFERS] = {
@@ -409,7 +413,7 @@ static void rm_from_block_list(struct block_list **blist, struct block_desc *blo
     }
   }
   dbg(1, "can't rm block %p (%08x-%08x)",
-    block, block->addr, block->end_addr);
+    block, block->addr, block->addr + block->size);
 }
 
 static void rm_block_list(struct block_list **blist)
@@ -448,7 +452,7 @@ static void REGPARM(1) flush_tcache(int tcid)
   tcache_dsm_ptrs[tcid] = tcache_bases[tcid];
 #endif
 
-  for (i = 0; i < ram_sizes[tcid] / ADDR_TO_BLOCK_PAGE; i++)
+  for (i = 0; i < ram_sizes[tcid] / INVAL_PAGE_SIZE; i++)
     rm_block_list(&inval_lookup[tcid][i]);
 }
 
@@ -493,7 +497,8 @@ missing:
   dbg(1, "rm_from_hashlist: be %p %08x missing?", be, be->pc);
 }
 
-static struct block_desc *dr_add_block(u32 addr, u32 end_addr, int is_slave, int *blk_id)
+static struct block_desc *dr_add_block(u32 addr, u16 size_lit,
+  u16 size_nolit, int is_slave, int *blk_id)
 {
   struct block_entry *be;
   struct block_desc *bd;
@@ -513,7 +518,8 @@ static struct block_desc *dr_add_block(u32 addr, u32 end_addr, int is_slave, int
 
   bd = &block_tables[tcache_id][*bcount];
   bd->addr = addr;
-  bd->end_addr = end_addr;
+  bd->size = size_lit;
+  bd->size_nolit = size_nolit;
 
   bd->entry_count = 1;
   bd->entryp[0].pc = addr;
@@ -572,7 +578,7 @@ static void *dr_prepare_ext_branch(u32 pc, int is_slave, int tcache_id)
       break;
   cnt = i + 1;
   if (cnt >= block_link_pool_max_counts[tcache_id]) {
-    dbg(1, "bl overflow for tcache %d\n", tcache_id);
+    dbg(1, "bl overflow for tcache %d", tcache_id);
     return NULL;
   }
   bl += cnt;
@@ -630,11 +636,11 @@ static void dr_link_blocks(struct block_entry *be, int tcache_id)
 }
 
 #define ADD_TO_ARRAY(array, count, item, failcode) \
-  array[count++] = item; \
   if (count >= ARRAY_SIZE(array)) { \
     dbg(1, "warning: " #array " overflow"); \
     failcode; \
-  }
+  } \
+  array[count++] = item;
 
 static int find_in_array(u32 *array, size_t size, u32 what)
 {
@@ -994,6 +1000,18 @@ static void rcache_unlock_all(void)
     reg_temp[i].flags &= ~HRF_LOCKED;
 }
 
+static inline u32 rcache_used_hreg_mask(void)
+{
+  u32 mask = 0;
+  int i;
+
+  for (i = 0; i < ARRAY_SIZE(reg_temp); i++)
+    if (reg_temp[i].type != HR_FREE)
+      mask |= 1 << reg_temp[i].hreg;
+
+  return mask;
+}
+
 static void rcache_clean(void)
 {
   int i;
@@ -1088,7 +1106,8 @@ static int emit_memhandler_read_(int size, int ram_check)
   arg1 = rcache_get_tmp_arg(1);
   emith_move_r_r(arg1, CONTEXT_REG);
 
-#ifndef PDB_NET
+#if 0 // can't do this because of unmapped reads
+ // ndef PDB_NET
   if (ram_check && Pico.rom == (void *)0x02000000 && Pico32xMem->sdram == (void *)0x06000000) {
     int tmp = rcache_get_tmp();
     emith_and_r_r_imm(tmp, arg0, 0xfb000000);
@@ -1199,14 +1218,14 @@ static void emit_memhandler_write(int size, u32 pc)
   if (reg_map_g2h[SHR_SR] != -1)
     emith_ctx_write(reg_map_g2h[SHR_SR], SHR_SR * 4);
 
+  rcache_clean();
+
   switch (size) {
   case 0: // 8
     // XXX: consider inlining sh2_drc_write8
-    rcache_clean();
     emith_call(sh2_drc_write8);
     break;
   case 1: // 16
-    rcache_clean();
     emith_call(sh2_drc_write16);
     break;
   case 2: // 32
@@ -1336,6 +1355,7 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
     u32 test_irq:1;
     u32 pending_branch_direct:1;
     u32 pending_branch_indirect:1;
+    u32 literals_disabled:1;
   } drcf = { 0, };
 
   // PC of current, first, last SH2 insn
@@ -1353,6 +1373,7 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
   int op;
 
   base_pc = sh2->pc;
+  drcf.literals_disabled = literal_disabled_frames != 0;
 
   // get base/validate PC
   dr_pc_base = dr_get_pc_base(base_pc, sh2->is_slave);
@@ -1374,7 +1395,11 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
   // initial passes to disassemble and analyze the block
   scan_block(base_pc, sh2->is_slave, op_flags, &end_pc, &end_literals);
 
-  block = dr_add_block(base_pc, end_literals, sh2->is_slave, &blkid_main);
+  if (drcf.literals_disabled)
+    end_literals = end_pc;
+
+  block = dr_add_block(base_pc, end_literals - base_pc,
+    end_pc - base_pc, sh2->is_slave, &blkid_main);
   if (block == NULL)
     return NULL;
 
@@ -1399,6 +1424,9 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
     memset(branch_target_ptr, 0, sizeof(branch_target_ptr[0]) * branch_target_count);
   }
 
+  // clear stale state after compile errors
+  rcache_invalidate();
+
   // -------------------------------------------------
   // 3rd pass: actual compilation
   pc = base_pc;
@@ -1477,16 +1505,18 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
       emit_move_r_imm32(SHR_PC, pc);
       sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
       FLUSH_CYCLES(sr);
-      // rcache_clean(); // FIXME
-      rcache_flush();
+      rcache_clean();
+
+      tmp = rcache_used_hreg_mask();
+      emith_save_caller_regs(tmp);
       emit_do_static_regs(1, 0);
       emith_pass_arg_r(0, CONTEXT_REG);
       emith_call(do_sh2_cmp);
+      emith_restore_caller_regs(tmp);
     }
 #endif
 
     pc += 2;
-    cycles += opd->cycles;
 
     if (skip_op > 0) {
       skip_op--;
@@ -1502,9 +1532,35 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
         sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
         DELAY_SAVE_T(sr);
       }
-      if (delay_dep_fw & ~BITMASK1(SHR_T))
-        dbg(1, "unhandled delay_dep_fw: %x", delay_dep_fw & ~BITMASK1(SHR_T));
-      if (delay_dep_bk)
+      if (delay_dep_bk & BITMASK1(SHR_PC)) {
+        if (opd->op != OP_LOAD_POOL && opd->op != OP_MOVA) {
+          // can only be those 2 really..
+          elprintf(EL_ANOMALY, "%csh2 drc: illegal slot insn %04x @ %08x?",
+            sh2->is_slave ? 's' : 'm', op, pc - 2);
+        }
+        if (opd->imm != 0)
+          ; // addr already resolved somehow
+        else {
+          switch (ops[i-1].op) {
+          case OP_BRANCH:
+            emit_move_r_imm32(SHR_PC, ops[i-1].imm);
+            break;
+          case OP_BRANCH_CT:
+          case OP_BRANCH_CF:
+            tmp = rcache_get_reg(SHR_PC, RC_GR_WRITE);
+            sr = rcache_get_reg(SHR_SR, RC_GR_READ);
+            emith_move_r_imm(tmp, pc);
+            emith_tst_r_imm(sr, T);
+            tmp2 = ops[i-1].op == OP_BRANCH_CT ? DCOND_NE : DCOND_EQ;
+            emith_move_r_imm_c(tmp2, tmp, ops[i-1].imm);
+            break;
+          // case OP_BRANCH_R OP_BRANCH_RF - PC already loaded
+          }
+        }
+      }
+      //if (delay_dep_fw & ~BITMASK1(SHR_T))
+      //  dbg(1, "unhandled delay_dep_fw: %x", delay_dep_fw & ~BITMASK1(SHR_T));
+      if (delay_dep_bk & ~BITMASK2(SHR_PC, SHR_PR))
         dbg(1, "unhandled delay_dep_bk: %x", delay_dep_bk);
     }
 
@@ -1558,7 +1614,56 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
       emith_add_r_imm(tmp, 4*2);
       drcf.test_irq = 1;
       drcf.pending_branch_indirect = 1;
-      break;
+      goto end_op;
+
+    case OP_LOAD_POOL:
+#if PROPAGATE_CONSTANTS
+      if (opd->imm != 0 && opd->imm < end_literals
+          && literal_addr_count < MAX_LITERALS)
+      {
+        ADD_TO_ARRAY(literal_addr, literal_addr_count, opd->imm,);
+        if (opd->size == 2)
+          tmp = FETCH32(opd->imm);
+        else
+          tmp = (u32)(int)(signed short)FETCH_OP(opd->imm);
+        gconst_new(GET_Rn(), tmp);
+      }
+      else
+#endif
+      {
+        tmp = rcache_get_tmp_arg(0);
+        if (opd->imm != 0)
+          emith_move_r_imm(tmp, opd->imm);
+        else {
+          // have to calculate read addr from PC
+          tmp2 = rcache_get_reg(SHR_PC, RC_GR_READ);
+          if (opd->size == 2) {
+            emith_add_r_r_imm(tmp, tmp2, 2 + (op & 0xff) * 4);
+            emith_bic_r_imm(tmp, 3);
+          }
+          else
+            emith_add_r_r_imm(tmp, tmp2, 2 + (op & 0xff) * 2);
+        }
+        tmp2 = emit_memhandler_read(opd->size);
+        tmp3 = rcache_get_reg(GET_Rn(), RC_GR_WRITE);
+        if (opd->size == 2)
+          emith_move_r_r(tmp3, tmp2);
+        else
+          emith_sext(tmp3, tmp2, 16);
+        rcache_free_tmp(tmp2);
+      }
+      goto end_op;
+
+    case OP_MOVA:
+      if (opd->imm != 0)
+        emit_move_r_imm32(SHR_R0, opd->imm);
+      else {
+        tmp = rcache_get_reg(SHR_R0, RC_GR_WRITE);
+        tmp2 = rcache_get_reg(SHR_PC, RC_GR_READ);
+        emith_add_r_r_imm(tmp, tmp2, 2 + (op & 0xff) * 4);
+        emith_bic_r_imm(tmp, 3);
+      }
+      goto end_op;
     }
 
     switch ((op >> 12) & 0x0f)
@@ -1729,14 +1834,14 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
         rcache_get_reg_arg(1, GET_Rm());
         emit_memhandler_write(op & 3, pc);
         goto end_op;
-      case 0x04: // MOV.B Rm,@–Rn       0010nnnnmmmm0100
-      case 0x05: // MOV.W Rm,@–Rn       0010nnnnmmmm0101
-      case 0x06: // MOV.L Rm,@–Rn       0010nnnnmmmm0110
+      case 0x04: // MOV.B Rm,@-Rn       0010nnnnmmmm0100
+      case 0x05: // MOV.W Rm,@-Rn       0010nnnnmmmm0101
+      case 0x06: // MOV.L Rm,@-Rn       0010nnnnmmmm0110
+        rcache_get_reg_arg(1, GET_Rm()); // for Rm == Rn
         tmp = rcache_get_reg(GET_Rn(), RC_GR_RMW);
         emith_sub_r_imm(tmp, (1 << (op & 3)));
         rcache_clean();
         rcache_get_reg_arg(0, GET_Rn());
-        rcache_get_reg_arg(1, GET_Rm());
         emit_memhandler_write(op & 3, pc);
         goto end_op;
       case 0x07: // DIV0S Rm,Rn         0010nnnnmmmm0111
@@ -1788,13 +1893,13 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
         sr   = rcache_get_reg(SHR_SR, RC_GR_RMW);
         emith_bic_r_imm(sr, T);
         emith_tst_r_imm(tmp, 0x000000ff);
-        emit_or_t_if_eq(tmp);
+        emit_or_t_if_eq(sr);
         emith_tst_r_imm(tmp, 0x0000ff00);
-        emit_or_t_if_eq(tmp);
+        emit_or_t_if_eq(sr);
         emith_tst_r_imm(tmp, 0x00ff0000);
-        emit_or_t_if_eq(tmp);
+        emit_or_t_if_eq(sr);
         emith_tst_r_imm(tmp, 0xff000000);
-        emit_or_t_if_eq(tmp);
+        emit_or_t_if_eq(sr);
         rcache_free_tmp(tmp);
         goto end_op;
       case 0x0d: // XTRCT  Rm,Rn        0010nnnnmmmm1101
@@ -1968,7 +2073,7 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
           goto end_op;
         case 1: // DT Rn      0100nnnn00010000
           sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
-#ifndef DRC_CMP
+#if 0 // scheduling needs tuning
           if (FETCH_OP(pc) == 0x8bfd) { // BF #-2
             if (gconst_get(GET_Rn(), &tmp)) {
               // XXX: limit burned cycles
@@ -2018,22 +2123,22 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
       case 0x03:
         switch (op & 0x3f)
         {
-        case 0x02: // STS.L    MACH,@Rn 0100nnnn00000010
+        case 0x02: // STS.L    MACH,@-Rn 0100nnnn00000010
           tmp = SHR_MACH;
           break;
-        case 0x12: // STS.L    MACL,@Rn 0100nnnn00010010
+        case 0x12: // STS.L    MACL,@-Rn 0100nnnn00010010
           tmp = SHR_MACL;
           break;
-        case 0x22: // STS.L    PR,@Rn   0100nnnn00100010
+        case 0x22: // STS.L    PR,@-Rn   0100nnnn00100010
           tmp = SHR_PR;
           break;
-        case 0x03: // STC.L    SR,@Rn   0100nnnn00000011
+        case 0x03: // STC.L    SR,@-Rn   0100nnnn00000011
           tmp = SHR_SR;
           break;
-        case 0x13: // STC.L    GBR,@Rn  0100nnnn00010011
+        case 0x13: // STC.L    GBR,@-Rn  0100nnnn00010011
           tmp = SHR_GBR;
           break;
-        case 0x23: // STC.L    VBR,@Rn  0100nnnn00100011
+        case 0x23: // STC.L    VBR,@-Rn  0100nnnn00100011
           tmp = SHR_VBR;
           break;
         default:
@@ -2367,27 +2472,6 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
       }
       goto default_;
 
-    /////////////////////////////////////////////
-    case 0x09:
-      // MOV.W @(disp,PC),Rn  1001nnnndddddddd
-      tmp = pc + (op & 0xff) * 2 + 2;
-#if PROPAGATE_CONSTANTS
-      if (tmp < end_pc + MAX_LITERAL_OFFSET && literal_addr_count < MAX_LITERALS) {
-        ADD_TO_ARRAY(literal_addr, literal_addr_count, tmp,);
-        gconst_new(GET_Rn(), (u32)(int)(signed short)FETCH_OP(tmp));
-      }
-      else
-#endif
-      {
-        tmp2 = rcache_get_tmp_arg(0);
-        emith_move_r_imm(tmp2, tmp);
-        tmp2 = emit_memhandler_read(1);
-        tmp3 = rcache_get_reg(GET_Rn(), RC_GR_WRITE);
-        emith_sext(tmp3, tmp2, 16);
-        rcache_free_tmp(tmp2);
-      }
-      goto end_op;
-
     /////////////////////////////////////////////
     case 0x0c:
       switch (op & 0x0f00)
@@ -2425,11 +2509,9 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
         // obtain new PC
         emit_memhandler_read_rr(SHR_PC, SHR_VBR, (op & 0xff) * 4, 2);
         // indirect jump -> back to dispatcher
+        rcache_flush();
         emith_jump(sh2_drc_dispatcher);
         goto end_op;
-      case 0x0700: // MOVA @(disp,PC),R0    11000111dddddddd
-        emit_move_r_imm32(SHR_R0, (pc + (op & 0xff) * 4 + 2) & ~3);
-        goto end_op;
       case 0x0800: // TST #imm,R0           11001000iiiiiiii
         tmp = rcache_get_reg(SHR_R0, RC_GR_READ);
         sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
@@ -2480,27 +2562,6 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
       }
       goto default_;
 
-    /////////////////////////////////////////////
-    case 0x0d:
-      // MOV.L @(disp,PC),Rn  1101nnnndddddddd
-      tmp = (pc + (op & 0xff) * 4 + 2) & ~3;
-#if PROPAGATE_CONSTANTS
-      if (tmp < end_pc + MAX_LITERAL_OFFSET && literal_addr_count < MAX_LITERALS) {
-        ADD_TO_ARRAY(literal_addr, literal_addr_count, tmp,);
-        gconst_new(GET_Rn(), FETCH32(tmp));
-      }
-      else
-#endif
-      {
-        tmp2 = rcache_get_tmp_arg(0);
-        emith_move_r_imm(tmp2, tmp);
-        tmp2 = emit_memhandler_read(2);
-        tmp3 = rcache_get_reg(GET_Rn(), RC_GR_WRITE);
-        emith_move_r_r(tmp3, tmp2);
-        rcache_free_tmp(tmp2);
-      }
-      goto end_op;
-
     /////////////////////////////////////////////
     case 0x0e:
       // MOV #imm,Rn   1110nnnniiiiiiii
@@ -2517,6 +2578,8 @@ static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
 end_op:
     rcache_unlock_all();
 
+    cycles += opd->cycles;
+
     if (op_flags[i+1] & OF_DELAY_OP) {
       do_host_disasm(tcache_id);
       continue;
@@ -2526,6 +2589,8 @@ end_op:
     if (drcf.test_irq && !drcf.pending_branch_direct) {
       sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
       FLUSH_CYCLES(sr);
+      if (!drcf.pending_branch_indirect)
+        emit_move_r_imm32(SHR_PC, pc);
       rcache_flush();
       emith_call(sh2_drc_test_irq);
       drcf.test_irq = 0;
@@ -2586,8 +2651,10 @@ end_op:
 
       if (cond != -1)
         emith_jump_cond_patchable(cond, target);
-      else
+      else {
         emith_jump_patchable(target);
+        rcache_invalidate();
+      }
 
       drcf.pending_branch_direct = 0;
     }
@@ -2645,7 +2712,8 @@ end_op:
 
   // mark memory blocks as containing compiled code
   // override any overlay blocks as they become unreachable anyway
-  if (tcache_id != 0 || (block->addr & 0xc7fc0000) == 0x06000000)
+  if ((block->addr & 0xc7fc0000) == 0x06000000
+      || (block->addr & 0xfffff000) == 0xc0000000)
   {
     u16 *drc_ram_blk = NULL;
     u32 addr, mask = 0, shift = 0;
@@ -2656,7 +2724,7 @@ end_op:
       shift = SH2_DRCBLK_DA_SHIFT;
       mask = 0xfff;
     }
-    else if ((block->addr & 0xc7fc0000) == 0x06000000) {
+    else {
       // SDRAM
       drc_ram_blk = Pico32xMem->drcblk_ram;
       shift = SH2_DRCBLK_RAM_SHIFT;
@@ -2675,9 +2743,9 @@ end_op:
     }
 
     // add to invalidation lookup lists
-    addr = base_pc & ~(ADDR_TO_BLOCK_PAGE - 1);
-    for (; addr < end_literals; addr += ADDR_TO_BLOCK_PAGE) {
-      i = (addr & mask) / ADDR_TO_BLOCK_PAGE;
+    addr = base_pc & ~(INVAL_PAGE_SIZE - 1);
+    for (; addr < end_literals; addr += INVAL_PAGE_SIZE) {
+      i = (addr & mask) / INVAL_PAGE_SIZE;
       add_to_block_list(&inval_lookup[tcache_id][i], block);
     }
   }
@@ -2687,6 +2755,9 @@ end_op:
   host_instructions_updated(block_entry_ptr, tcache_ptr);
 
   do_host_disasm(tcache_id);
+
+  if (drcf.literals_disabled && literal_addr_count)
+    dbg(1, "literals_disabled && literal_addr_count?");
   dbg(2, " block #%d,%d tcache %d/%d, insns %d -> %d %.3f",
     tcache_id, blkid_main,
     tcache_ptr - tcache_bases[tcache_id], tcache_sizes[tcache_id],
@@ -2876,20 +2947,22 @@ static void sh2_generate_utils(void)
 static void sh2_smc_rm_block_entry(struct block_desc *bd, int tcache_id, u32 ram_mask)
 {
   struct block_link *bl, *bl_next, *bl_unresolved;
+  u32 i, addr, end_addr;
   void *tmp;
-  u32 i, addr;
 
-  dbg(2, "  killing entry %08x-%08x, blkid %d,%d",
-    bd->addr, bd->end_addr, tcache_id, bd - block_tables[tcache_id]);
+  dbg(2, "  killing entry %08x-%08x-%08x, blkid %d,%d",
+    bd->addr, bd->addr + bd->size_nolit, bd->addr + bd->size,
+    tcache_id, bd - block_tables[tcache_id]);
   if (bd->addr == 0 || bd->entry_count == 0) {
     dbg(1, "  killing dead block!? %08x", bd->addr);
     return;
   }
 
   // remove from inval_lookup
-  addr = bd->addr & ~(ADDR_TO_BLOCK_PAGE - 1);
-  for (; addr < bd->end_addr; addr += ADDR_TO_BLOCK_PAGE) {
-    i = (addr & ram_mask) / ADDR_TO_BLOCK_PAGE;
+  addr = bd->addr & ~(INVAL_PAGE_SIZE - 1);
+  end_addr = bd->addr + bd->size;
+  for (; addr < end_addr; addr += INVAL_PAGE_SIZE) {
+    i = (addr & ram_mask) / INVAL_PAGE_SIZE;
     rm_from_block_list(&inval_lookup[tcache_id][i], bd);
   }
 
@@ -2904,7 +2977,7 @@ static void sh2_smc_rm_block_entry(struct block_desc *bd, int tcache_id, u32 ram
     // since we never reuse tcache space of dead blocks,
     // insert jump to dispatcher for blocks that are linked to this
     tcache_ptr = bd->entryp[i].tcache_ptr;
-    emit_move_r_imm32(SHR_PC, bd->addr);
+    emit_move_r_imm32(SHR_PC, bd->entryp[i].pc);
     rcache_flush();
     emith_jump(sh2_drc_dispatcher);
 
@@ -2921,27 +2994,31 @@ static void sh2_smc_rm_block_entry(struct block_desc *bd, int tcache_id, u32 ram
   tcache_ptr = tmp;
   unresolved_links[tcache_id] = bl_unresolved;
 
-  bd->addr = bd->end_addr = 0;
+  bd->addr = bd->size = bd->size_nolit = 0;
   bd->entry_count = 0;
 }
 
 static void sh2_smc_rm_block(u32 a, u16 *drc_ram_blk, int tcache_id, u32 shift, u32 mask)
 {
   struct block_list **blist = NULL, *entry;
-  u32 from = ~0, to = 0;
+  u32 from = ~0, to = 0, end_addr, taddr, i;
   struct block_desc *block;
 
-  blist = &inval_lookup[tcache_id][(a & mask) / ADDR_TO_BLOCK_PAGE];
+  blist = &inval_lookup[tcache_id][(a & mask) / INVAL_PAGE_SIZE];
   entry = *blist;
   while (entry != NULL) {
     block = entry->block;
-    if (block->addr <= a && a < block->end_addr) {
-      if (block->addr < from)
+    end_addr = block->addr + block->size;
+    if (block->addr <= a && a < end_addr) {
+      // get addr range that includes all removed blocks
+      if (from > block->addr)
         from = block->addr;
-      if (block->end_addr > to)
-        to = block->end_addr;
+      if (to < end_addr)
+        to = end_addr;
 
       sh2_smc_rm_block_entry(block, tcache_id, mask);
+      if (a >= block->addr + block->size_nolit)
+        literal_disabled_frames = 3;
 
       // entry lost, restart search
       entry = *blist;
@@ -2950,7 +3027,32 @@ static void sh2_smc_rm_block(u32 a, u16 *drc_ram_blk, int tcache_id, u32 shift,
     entry = entry->next;
   }
 
-  // clear entry points
+  if (from >= to)
+    return;
+
+  // update range around a to match latest state
+  from &= ~(INVAL_PAGE_SIZE - 1);
+  to |= (INVAL_PAGE_SIZE - 1);
+  for (taddr = from; taddr < to; taddr += INVAL_PAGE_SIZE) {
+    i = (taddr & mask) / INVAL_PAGE_SIZE;
+    entry = inval_lookup[tcache_id][i];
+
+    for (; entry != NULL; entry = entry->next) {
+      block = entry->block;
+
+      if (block->addr > a) {
+        if (to > block->addr)
+          to = block->addr;
+      }
+      else {
+        end_addr = block->addr + block->size;
+        if (from < end_addr)
+          from = end_addr;
+      }
+    }
+  }
+
+  // clear code marks
   if (from < to) {
     u16 *p = drc_ram_blk + ((from & mask) >> shift);
     memset(p, 0, (to - from) >> (shift - 1));
@@ -3046,6 +3148,12 @@ void sh2_drc_mem_setup(SH2 *sh2)
   sh2->p_rom = Pico.rom;
 }
 
+void sh2_drc_frame(void)
+{
+  if (literal_disabled_frames > 0)
+    literal_disabled_frames--;
+}
+
 int sh2_drc_init(SH2 *sh2)
 {
   int i;
@@ -3062,7 +3170,7 @@ int sh2_drc_init(SH2 *sh2)
       if (block_link_pool[i] == NULL)
         goto fail;
 
-      inval_lookup[i] = calloc(ram_sizes[i] / ADDR_TO_BLOCK_PAGE,
+      inval_lookup[i] = calloc(ram_sizes[i] / INVAL_PAGE_SIZE,
                                sizeof(inval_lookup[0]));
       if (inval_lookup[i] == NULL)
         goto fail;
@@ -3083,9 +3191,6 @@ int sh2_drc_init(SH2 *sh2)
     for (i = 1; i < ARRAY_SIZE(tcache_bases); i++)
       tcache_bases[i] = tcache_ptrs[i] = tcache_bases[i - 1] + tcache_sizes[i - 1];
 
-    // tmp
-    PicoOpt |= POPT_DIS_VDP_FIFO;
-
 #if (DRC_DEBUG & 4)
     for (i = 0; i < ARRAY_SIZE(block_tables); i++)
       tcache_dsm_ptrs[i] = tcache_bases[i];
@@ -3381,9 +3486,9 @@ void scan_block(u32 base_pc, int is_slave, u8 *op_flags, u32 *end_pc_out,
         opd->source = BITMASK1(GET_Rm());
         opd->source = BITMASK1(GET_Rn());
         break;
-      case 0x04: // MOV.B Rm,@Rn       0010nnnnmmmm0100
-      case 0x05: // MOV.W Rm,@Rn       0010nnnnmmmm0101
-      case 0x06: // MOV.L Rm,@Rn       0010nnnnmmmm0110
+      case 0x04: // MOV.B Rm,@-Rn       0010nnnnmmmm0100
+      case 0x05: // MOV.W Rm,@-Rn       0010nnnnmmmm0101
+      case 0x06: // MOV.L Rm,@-Rn       0010nnnnmmmm0110
         opd->source = BITMASK2(GET_Rm(), GET_Rn());
         opd->dest = BITMASK1(GET_Rn());
         break;
@@ -3501,24 +3606,24 @@ void scan_block(u32 base_pc, int is_slave, u8 *op_flags, u32 *end_pc_out,
       case 0x03:
         switch (op & 0x3f)
         {
-        case 0x02: // STS.L    MACH,@Rn 0100nnnn00000010
+        case 0x02: // STS.L    MACH,@-Rn 0100nnnn00000010
           tmp = SHR_MACH;
           break;
-        case 0x12: // STS.L    MACL,@Rn 0100nnnn00010010
+        case 0x12: // STS.L    MACL,@-Rn 0100nnnn00010010
           tmp = SHR_MACL;
           break;
-        case 0x22: // STS.L    PR,@Rn   0100nnnn00100010
+        case 0x22: // STS.L    PR,@-Rn   0100nnnn00100010
           tmp = SHR_PR;
           break;
-        case 0x03: // STC.L    SR,@Rn   0100nnnn00000011
+        case 0x03: // STC.L    SR,@-Rn   0100nnnn00000011
           tmp = SHR_SR;
           opd->cycles = 2;
           break;
-        case 0x13: // STC.L    GBR,@Rn  0100nnnn00010011
+        case 0x13: // STC.L    GBR,@-Rn  0100nnnn00010011
           tmp = SHR_GBR;
           opd->cycles = 2;
           break;
-        case 0x23: // STC.L    VBR,@Rn  0100nnnn00100011
+        case 0x23: // STC.L    VBR,@-Rn  0100nnnn00100011
           tmp = SHR_VBR;
           opd->cycles = 2;
           break;
@@ -3697,13 +3802,16 @@ void scan_block(u32 base_pc, int is_slave, u8 *op_flags, u32 *end_pc_out,
         opd->source = BITMASK1(GET_Rm());
         opd->dest |= BITMASK1(GET_Rn());
         break;
+      case 0x0a: // NEGC   Rm,Rn        0110nnnnmmmm1010
+        opd->source = BITMASK2(GET_Rm(), SHR_T);
+        opd->dest = BITMASK2(GET_Rn(), SHR_T);
+        break;
       case 0x03: // MOV    Rm,Rn        0110nnnnmmmm0011
         opd->op = OP_MOVE;
         goto arith_rmrn;
       case 0x07: // NOT    Rm,Rn        0110nnnnmmmm0111
       case 0x08: // SWAP.B Rm,Rn        0110nnnnmmmm1000
       case 0x09: // SWAP.W Rm,Rn        0110nnnnmmmm1001
-      case 0x0a: // NEGC   Rm,Rn        0110nnnnmmmm1010
       case 0x0b: // NEG    Rm,Rn        0110nnnnmmmm1011
       case 0x0c: // EXTU.B Rm,Rn        0110nnnnmmmm1100
       case 0x0d: // EXTU.W Rm,Rn        0110nnnnmmmm1101
@@ -3773,9 +3881,17 @@ void scan_block(u32 base_pc, int is_slave, u8 *op_flags, u32 *end_pc_out,
     case 0x09:
       // MOV.W @(disp,PC),Rn  1001nnnndddddddd
       opd->op = OP_LOAD_POOL;
+      tmp = pc + 2;
+      if (op_flags[i] & OF_DELAY_OP) {
+        if (ops[i-1].op == OP_BRANCH)
+          tmp = ops[i-1].imm;
+        else
+          tmp = 0;
+      }
       opd->source = BITMASK1(SHR_PC);
       opd->dest = BITMASK1(GET_Rn());
-      opd->imm = pc + 4 + (op & 0xff) * 2;
+      if (tmp)
+        opd->imm = tmp + 2 + (op & 0xff) * 2;
       opd->size = 1;
       break;
 
@@ -3823,8 +3939,17 @@ void scan_block(u32 base_pc, int is_slave, u8 *op_flags, u32 *end_pc_out,
         end_block = 1; // FIXME
         break;
       case 0x0700: // MOVA @(disp,PC),R0    11000111dddddddd
+        opd->op = OP_MOVA;
+        tmp = pc + 2;
+        if (op_flags[i] & OF_DELAY_OP) {
+          if (ops[i-1].op == OP_BRANCH)
+            tmp = ops[i-1].imm;
+          else
+            tmp = 0;
+        }
         opd->dest = BITMASK1(SHR_R0);
-        opd->imm = (pc + 4 + (op & 0xff) * 4) & ~3;
+        if (tmp)
+          opd->imm = (tmp + 2 + (op & 0xff) * 4) & ~3;
         break;
       case 0x0800: // TST #imm,R0           11001000iiiiiiii
         opd->source = BITMASK1(SHR_R0);
@@ -3865,9 +3990,17 @@ void scan_block(u32 base_pc, int is_slave, u8 *op_flags, u32 *end_pc_out,
     case 0x0d:
       // MOV.L @(disp,PC),Rn  1101nnnndddddddd
       opd->op = OP_LOAD_POOL;
+      tmp = pc + 2;
+      if (op_flags[i] & OF_DELAY_OP) {
+        if (ops[i-1].op == OP_BRANCH)
+          tmp = ops[i-1].imm;
+        else
+          tmp = 0;
+      }
       opd->source = BITMASK1(SHR_PC);
       opd->dest = BITMASK1(GET_Rn());
-      opd->imm = (pc + 4 + (op & 0xff) * 2) & ~3;
+      if (tmp)
+        opd->imm = (tmp + 2 + (op & 0xff) * 4) & ~3;
       opd->size = 2;
       break;