cpu/sh2/compiler.c

   1 /*
   2  * SH2 recompiler
   3  * (C) notaz, 2009,2010,2013
   4  *
   5  * This work is licensed under the terms of MAME license.
   6  * See COPYING file in the top-level directory.
   7  *
   8  * notes:
   9  * - tcache, block descriptor, link buffer overflows result in sh2_translate()
  10  *   failure, followed by full tcache invalidation for that region
  11  * - jumps between blocks are tracked for SMC handling (in block_entry->links),
  12  *   except jumps between different tcaches
  13  *
  14  * implemented:
  15  * - static register allocation
  16  * - remaining register caching and tracking in temporaries
  17  * - block-local branch linking
  18  * - block linking (except between tcaches)
  19  * - some constant propagation
  20  *
  21  * TODO:
  22  * - better constant propagation
  23  * - stack caching?
  24  * - bug fixing
  25  */
  26 #include <stddef.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <assert.h>
  30
  31 #include "../../pico/pico_int.h"
  32 #include "sh2.h"
  33 #include "compiler.h"
  34 #include "../drc/cmn.h"
  35 #include "../debug.h"
  36
  37 // features
  38 #define PROPAGATE_CONSTANTS     1
  39 #define LINK_BRANCHES           1
  40
  41 // limits (per block)
  42 #define MAX_BLOCK_SIZE          (BLOCK_INSN_LIMIT * 6 * 6)
  43
  44 // max literal offset from the block end
  45 #define MAX_LITERAL_OFFSET      32*2
  46 #define MAX_LITERALS            (BLOCK_INSN_LIMIT / 4)
  47 #define MAX_LOCAL_BRANCHES      32
  48
  49 // debug stuff
  50 // 1 - warnings/errors
  51 // 2 - block info/smc
  52 // 4 - asm
  53 // 8 - runtime block entry log
  54 // {
  55 #ifndef DRC_DEBUG
  56 #define DRC_DEBUG 0
  57 #endif
  58
  59 #if DRC_DEBUG
  60 #define dbg(l,...) { \
  61   if ((l) & DRC_DEBUG) \
  62     elprintf(EL_STATUS, ##__VA_ARGS__); \
  63 }
  64 #include "mame/sh2dasm.h"
  65 #include <platform/libpicofe/linux/host_dasm.h>
  66 static int insns_compiled, hash_collisions, host_insn_count;
  67 #define COUNT_OP \
  68         host_insn_count++
  69 #else // !DRC_DEBUG
  70 #define COUNT_OP
  71 #define dbg(...)
  72 #endif
  73
  74 ///
  75 #define FETCH_OP(pc) \
  76   dr_pc_base[(pc) / 2]
  77
  78 #define FETCH32(a) \
  79   ((dr_pc_base[(a) / 2] << 16) | dr_pc_base[(a) / 2 + 1])
  80
  81 #define CHECK_UNHANDLED_BITS(mask, label) { \
  82   if ((op & (mask)) != 0) \
  83     goto label; \
  84 }
  85
  86 #define GET_Fx() \
  87   ((op >> 4) & 0x0f)
  88
  89 #define GET_Rm GET_Fx
  90
  91 #define GET_Rn() \
  92   ((op >> 8) & 0x0f)
  93
  94 #define BITMASK1(v0) (1 << (v0))
  95 #define BITMASK2(v0,v1) ((1 << (v0)) | (1 << (v1)))
  96 #define BITMASK3(v0,v1,v2) (BITMASK2(v0,v1) | (1 << (v2)))
  97 #define BITMASK4(v0,v1,v2,v3) (BITMASK3(v0,v1,v2) | (1 << (v3)))
  98 #define BITMASK5(v0,v1,v2,v3,v4) (BITMASK4(v0,v1,v2,v3) | (1 << (v4)))
  99
 100 #define SHR_T SHR_SR // might make them separate someday
 101
 102 static struct op_data {
 103   u8 op;
 104   u8 cycles;
 105   u8 size;     // 0, 1, 2 - byte, word, long
 106   s8 rm;       // branch or load/store data reg
 107   u32 source;  // bitmask of src regs
 108   u32 dest;    // bitmask of dest regs
 109   u32 imm;     // immediate/io address/branch target
 110                // (for literal - address, not value)
 111 } ops[BLOCK_INSN_LIMIT];
 112
 113 enum op_types {
 114   OP_UNHANDLED = 0,
 115   OP_BRANCH,
 116   OP_BRANCH_CT, // conditional, branch if T set
 117   OP_BRANCH_CF, // conditional, branch if T clear
 118   OP_BRANCH_R,  // indirect
 119   OP_BRANCH_RF, // indirect far (PC + Rm)
 120   OP_SETCLRT,   // T flag set/clear
 121   OP_MOVE,      // register move
 122   OP_LOAD_POOL, // literal pool load, imm is address
 123   OP_MOVA,
 124   OP_SLEEP,
 125   OP_RTE,
 126 };
 127
 128 #ifdef DRC_SH2
 129
 130 static int literal_disabled_frames;
 131
 132 #if (DRC_DEBUG & 4)
 133 static u8 *tcache_dsm_ptrs[3];
 134 static char sh2dasm_buff[64];
 135 #define do_host_disasm(tcid) \
 136   host_dasm(tcache_dsm_ptrs[tcid], tcache_ptr - tcache_dsm_ptrs[tcid]); \
 137   tcache_dsm_ptrs[tcid] = tcache_ptr
 138 #else
 139 #define do_host_disasm(x)
 140 #endif
 141
 142 #if (DRC_DEBUG & 8) || defined(PDB)
 143 static void REGPARM(3) *sh2_drc_log_entry(void *block, SH2 *sh2, u32 sr)
 144 {
 145   if (block != NULL) {
 146     dbg(8, "= %csh2 enter %08x %p, c=%d", sh2->is_slave ? 's' : 'm',
 147       sh2->pc, block, (signed int)sr >> 12);
 148     pdb_step(sh2, sh2->pc);
 149   }
 150   return block;
 151 }
 152 #endif
 153 // } debug
 154
 155 #define TCACHE_BUFFERS 3
 156
 157 // we have 3 translation cache buffers, split from one drc/cmn buffer.
 158 // BIOS shares tcache with data array because it's only used for init
 159 // and can be discarded early
 160 // XXX: need to tune sizes
 161 static const int tcache_sizes[TCACHE_BUFFERS] = {
 162   DRC_TCACHE_SIZE * 6 / 8, // ROM (rarely used), DRAM
 163   DRC_TCACHE_SIZE / 8, // BIOS, data array in master sh2
 164   DRC_TCACHE_SIZE / 8, // ... slave
 165 };
 166
 167 static u8 *tcache_bases[TCACHE_BUFFERS];
 168 static u8 *tcache_ptrs[TCACHE_BUFFERS];
 169
 170 // ptr for code emiters
 171 static u8 *tcache_ptr;
 172
 173 #define MAX_BLOCK_ENTRIES (BLOCK_INSN_LIMIT / 8)
 174
 175 struct block_link {
 176   u32 target_pc;
 177   void *jump;                // insn address
 178   struct block_link *next;   // either in block_entry->links or
 179 };
 180
 181 struct block_entry {
 182   u32 pc;
 183   void *tcache_ptr;          // translated block for above PC
 184   struct block_entry *next;  // next block in hash_table with same pc hash
 185   struct block_link *links;  // links to this entry
 186 #if (DRC_DEBUG & 2)
 187   struct block_desc *block;
 188 #endif
 189 };
 190
 191 struct block_desc {
 192   u32 addr;                  // block start SH2 PC address
 193   u16 size;                  // ..of recompiled insns+lit. pool
 194   u16 size_nolit;            // same without literals
 195 #if (DRC_DEBUG & 2)
 196   int refcount;
 197 #endif
 198   int entry_count;
 199   struct block_entry entryp[MAX_BLOCK_ENTRIES];
 200 };
 201
 202 static const int block_max_counts[TCACHE_BUFFERS] = {
 203   4*1024,
 204   256,
 205   256,
 206 };
 207 static struct block_desc *block_tables[TCACHE_BUFFERS];
 208 static int block_counts[TCACHE_BUFFERS];
 209
 210 // we have block_link_pool to avoid using mallocs
 211 static const int block_link_pool_max_counts[TCACHE_BUFFERS] = {
 212   4*1024,
 213   256,
 214   256,
 215 };
 216 static struct block_link *block_link_pool[TCACHE_BUFFERS];
 217 static int block_link_pool_counts[TCACHE_BUFFERS];
 218 static struct block_link *unresolved_links[TCACHE_BUFFERS];
 219
 220 // used for invalidation
 221 static const int ram_sizes[TCACHE_BUFFERS] = {
 222   0x40000,
 223   0x1000,
 224   0x1000,
 225 };
 226 #define INVAL_PAGE_SIZE 0x100
 227
 228 struct block_list {
 229   struct block_desc *block;
 230   struct block_list *next;
 231 };
 232
 233 // array of pointers to block_lists for RAM and 2 data arrays
 234 // each array has len: sizeof(mem) / INVAL_PAGE_SIZE
 235 static struct block_list **inval_lookup[TCACHE_BUFFERS];
 236
 237 static const int hash_table_sizes[TCACHE_BUFFERS] = {
 238   0x1000,
 239   0x100,
 240   0x100,
 241 };
 242 static struct block_entry **hash_tables[TCACHE_BUFFERS];
 243
 244 #define HASH_FUNC(hash_tab, addr, mask) \
 245   (hash_tab)[(((addr) >> 20) ^ ((addr) >> 2)) & (mask)]
 246
 247 // host register tracking
 248 enum {
 249   HR_FREE,
 250   HR_CACHED, // 'val' has sh2_reg_e
 251 //  HR_CONST,  // 'val' has a constant
 252   HR_TEMP,   // reg used for temp storage
 253 };
 254
 255 enum {
 256   HRF_DIRTY  = 1 << 0, // reg has "dirty" value to be written to ctx
 257   HRF_LOCKED = 1 << 1, // HR_CACHED can't be evicted
 258 };
 259
 260 typedef struct {
 261   u32 hreg:5;   // "host" reg
 262   u32 greg:5;   // "guest" reg
 263   u32 type:3;
 264   u32 flags:3;
 265   u32 stamp:16; // kind of a timestamp
 266 } temp_reg_t;
 267
 268 // note: reg_temp[] must have at least the amount of
 269 // registers used by handlers in worst case (currently 4)
 270 #ifdef __arm__
 271 #include "../drc/emit_arm.c"
 272
 273 #ifndef __MACH__
 274
 275 static const int reg_map_g2h[] = {
 276    4,  5,  6,  7,
 277    8, -1, -1, -1,
 278   -1, -1, -1, -1,
 279   -1, -1, -1,  9, // r12 .. sp
 280   -1, -1, -1, 10, // SHR_PC,  SHR_PPC, SHR_PR,   SHR_SR,
 281   -1, -1, -1, -1, // SHR_GBR, SHR_VBR, SHR_MACH, SHR_MACL,
 282 };
 283
 284 #else
 285
 286 // no r9..
 287 static const int reg_map_g2h[] = {
 288    4,  5,  6,  7,
 289   -1, -1, -1, -1,
 290   -1, -1, -1, -1,
 291   -1, -1, -1,  8, // r12 .. sp
 292   -1, -1, -1, 10, // SHR_PC,  SHR_PPC, SHR_PR,   SHR_SR,
 293   -1, -1, -1, -1, // SHR_GBR, SHR_VBR, SHR_MACH, SHR_MACL,
 294 };
 295
 296 #endif
 297
 298 static temp_reg_t reg_temp[] = {
 299   {  0, },
 300   {  1, },
 301   { 12, },
 302   { 14, },
 303   {  2, },
 304   {  3, },
 305 };
 306
 307 #elif defined(__i386__)
 308 #include "../drc/emit_x86.c"
 309
 310 static const int reg_map_g2h[] = {
 311   xSI,-1, -1, -1,
 312   -1, -1, -1, -1,
 313   -1, -1, -1, -1,
 314   -1, -1, -1, -1,
 315   -1, -1, -1, xDI,
 316   -1, -1, -1, -1,
 317 };
 318
 319 // ax, cx, dx are usually temporaries by convention
 320 static temp_reg_t reg_temp[] = {
 321   { xAX, },
 322   { xBX, },
 323   { xCX, },
 324   { xDX, },
 325 };
 326
 327 #else
 328 #error unsupported arch
 329 #endif
 330
 331 #define T       0x00000001
 332 #define S       0x00000002
 333 #define I       0x000000f0
 334 #define Q       0x00000100
 335 #define M       0x00000200
 336 #define T_save  0x00000800
 337
 338 #define I_SHIFT 4
 339 #define Q_SHIFT 8
 340 #define M_SHIFT 9
 341
 342 static void REGPARM(1) (*sh2_drc_entry)(SH2 *sh2);
 343 static void            (*sh2_drc_dispatcher)(void);
 344 static void            (*sh2_drc_exit)(void);
 345 static void            (*sh2_drc_test_irq)(void);
 346
 347 static u32  REGPARM(2) (*sh2_drc_read8)(u32 a, SH2 *sh2);
 348 static u32  REGPARM(2) (*sh2_drc_read16)(u32 a, SH2 *sh2);
 349 static u32  REGPARM(2) (*sh2_drc_read32)(u32 a, SH2 *sh2);
 350 static void REGPARM(2) (*sh2_drc_write8)(u32 a, u32 d);
 351 static void REGPARM(2) (*sh2_drc_write16)(u32 a, u32 d);
 352 static void REGPARM(3) (*sh2_drc_write32)(u32 a, u32 d, SH2 *sh2);
 353
 354 // address space stuff
 355 static int dr_ctx_get_mem_ptr(u32 a, u32 *mask)
 356 {
 357   int poffs = -1;
 358
 359   if ((a & ~0x7ff) == 0) {
 360     // BIOS
 361     poffs = offsetof(SH2, p_bios);
 362     *mask = 0x7ff;
 363   }
 364   else if ((a & 0xfffff000) == 0xc0000000) {
 365     // data array
 366     // FIXME: access sh2->data_array instead
 367     poffs = offsetof(SH2, p_da);
 368     *mask = 0xfff;
 369   }
 370   else if ((a & 0xc6000000) == 0x06000000) {
 371     // SDRAM
 372     poffs = offsetof(SH2, p_sdram);
 373     *mask = 0x03ffff;
 374   }
 375   else if ((a & 0xc6000000) == 0x02000000) {
 376     // ROM
 377     poffs = offsetof(SH2, p_rom);
 378     *mask = 0x3fffff;
 379   }
 380
 381   return poffs;
 382 }
 383
 384 static struct block_entry *dr_get_entry(u32 pc, int is_slave, int *tcache_id)
 385 {
 386   struct block_entry *be;
 387   u32 tcid = 0, mask;
 388
 389   // data arrays have their own caches
 390   if ((pc & 0xe0000000) == 0xc0000000 || (pc & ~0xfff) == 0)
 391     tcid = 1 + is_slave;
 392
 393   *tcache_id = tcid;
 394
 395   mask = hash_table_sizes[tcid] - 1;
 396   be = HASH_FUNC(hash_tables[tcid], pc, mask);
 397   for (; be != NULL; be = be->next)
 398     if (be->pc == pc)
 399       return be;
 400
 401   return NULL;
 402 }
 403
 404 // ---------------------------------------------------------------
 405
 406 // block management
 407 static void add_to_block_list(struct block_list **blist, struct block_desc *block)
 408 {
 409   struct block_list *added = malloc(sizeof(*added));
 410   if (!added) {
 411     elprintf(EL_ANOMALY, "drc OOM (1)");
 412     return;
 413   }
 414   added->block = block;
 415   added->next = *blist;
 416   *blist = added;
 417 }
 418
 419 static void rm_from_block_list(struct block_list **blist, struct block_desc *block)
 420 {
 421   struct block_list *prev = NULL, *current = *blist;
 422   for (; current != NULL; prev = current, current = current->next) {
 423     if (current->block == block) {
 424       if (prev == NULL)
 425         *blist = current->next;
 426       else
 427         prev->next = current->next;
 428       free(current);
 429       return;
 430     }
 431   }
 432   dbg(1, "can't rm block %p (%08x-%08x)",
 433     block, block->addr, block->addr + block->size);
 434 }
 435
 436 static void rm_block_list(struct block_list **blist)
 437 {
 438   struct block_list *tmp, *current = *blist;
 439   while (current != NULL) {
 440     tmp = current;
 441     current = current->next;
 442     free(tmp);
 443   }
 444   *blist = NULL;
 445 }
 446
 447 static void REGPARM(1) flush_tcache(int tcid)
 448 {
 449   int i;
 450
 451   dbg(1, "tcache #%d flush! (%d/%d, bds %d/%d)", tcid,
 452     tcache_ptrs[tcid] - tcache_bases[tcid], tcache_sizes[tcid],
 453     block_counts[tcid], block_max_counts[tcid]);
 454
 455   block_counts[tcid] = 0;
 456   block_link_pool_counts[tcid] = 0;
 457   unresolved_links[tcid] = NULL;
 458   memset(hash_tables[tcid], 0, sizeof(*hash_tables[0]) * hash_table_sizes[tcid]);
 459   tcache_ptrs[tcid] = tcache_bases[tcid];
 460   if (Pico32xMem != NULL) {
 461     if (tcid == 0) // ROM, RAM
 462       memset(Pico32xMem->drcblk_ram, 0,
 463              sizeof(Pico32xMem->drcblk_ram));
 464     else
 465       memset(Pico32xMem->drcblk_da[tcid - 1], 0,
 466              sizeof(Pico32xMem->drcblk_da[0]));
 467   }
 468 #if (DRC_DEBUG & 4)
 469   tcache_dsm_ptrs[tcid] = tcache_bases[tcid];
 470 #endif
 471
 472   for (i = 0; i < ram_sizes[tcid] / INVAL_PAGE_SIZE; i++)
 473     rm_block_list(&inval_lookup[tcid][i]);
 474 }
 475
 476 static void add_to_hashlist(struct block_entry *be, int tcache_id)
 477 {
 478   u32 tcmask = hash_table_sizes[tcache_id] - 1;
 479
 480   be->next = HASH_FUNC(hash_tables[tcache_id], be->pc, tcmask);
 481   HASH_FUNC(hash_tables[tcache_id], be->pc, tcmask) = be;
 482
 483 #if (DRC_DEBUG & 2)
 484   if (be->next != NULL) {
 485     printf(" %08x: hash collision with %08x\n",
 486       be->pc, be->next->pc);
 487     hash_collisions++;
 488   }
 489 #endif
 490 }
 491
 492 static void rm_from_hashlist(struct block_entry *be, int tcache_id)
 493 {
 494   u32 tcmask = hash_table_sizes[tcache_id] - 1;
 495   struct block_entry *cur, *prev;
 496
 497   cur = HASH_FUNC(hash_tables[tcache_id], be->pc, tcmask);
 498   if (cur == NULL)
 499     goto missing;
 500
 501   if (be == cur) { // first
 502     HASH_FUNC(hash_tables[tcache_id], be->pc, tcmask) = be->next;
 503     return;
 504   }
 505
 506   for (prev = cur, cur = cur->next; cur != NULL; cur = cur->next) {
 507     if (cur == be) {
 508       prev->next = cur->next;
 509       return;
 510     }
 511   }
 512
 513 missing:
 514   dbg(1, "rm_from_hashlist: be %p %08x missing?", be, be->pc);
 515 }
 516
 517 static struct block_desc *dr_add_block(u32 addr, u16 size_lit,
 518   u16 size_nolit, int is_slave, int *blk_id)
 519 {
 520   struct block_entry *be;
 521   struct block_desc *bd;
 522   int tcache_id;
 523   int *bcount;
 524
 525   // do a lookup to get tcache_id and override check
 526   be = dr_get_entry(addr, is_slave, &tcache_id);
 527   if (be != NULL)
 528     dbg(1, "block override for %08x", addr);
 529
 530   bcount = &block_counts[tcache_id];
 531   if (*bcount >= block_max_counts[tcache_id]) {
 532     dbg(1, "bd overflow for tcache %d", tcache_id);
 533     return NULL;
 534   }
 535
 536   bd = &block_tables[tcache_id][*bcount];
 537   bd->addr = addr;
 538   bd->size = size_lit;
 539   bd->size_nolit = size_nolit;
 540
 541   bd->entry_count = 1;
 542   bd->entryp[0].pc = addr;
 543   bd->entryp[0].tcache_ptr = tcache_ptr;
 544   bd->entryp[0].links = NULL;
 545 #if (DRC_DEBUG & 2)
 546   bd->entryp[0].block = bd;
 547   bd->refcount = 0;
 548 #endif
 549   add_to_hashlist(&bd->entryp[0], tcache_id);
 550
 551   *blk_id = *bcount;
 552   (*bcount)++;
 553
 554   return bd;
 555 }
 556
 557 static void REGPARM(3) *dr_lookup_block(u32 pc, int is_slave, int *tcache_id)
 558 {
 559   struct block_entry *be = NULL;
 560   void *block = NULL;
 561
 562   be = dr_get_entry(pc, is_slave, tcache_id);
 563   if (be != NULL)
 564     block = be->tcache_ptr;
 565
 566 #if (DRC_DEBUG & 2)
 567   if (be != NULL)
 568     be->block->refcount++;
 569 #endif
 570   return block;
 571 }
 572
 573 static void *dr_failure(void)
 574 {
 575   lprintf("recompilation failed\n");
 576   exit(1);
 577 }
 578
 579 static void *dr_prepare_ext_branch(u32 pc, int is_slave, int tcache_id)
 580 {
 581 #if LINK_BRANCHES
 582   struct block_link *bl = block_link_pool[tcache_id];
 583   int cnt = block_link_pool_counts[tcache_id];
 584   struct block_entry *be = NULL;
 585   int target_tcache_id;
 586   int i;
 587
 588   be = dr_get_entry(pc, is_slave, &target_tcache_id);
 589   if (target_tcache_id != tcache_id)
 590     return sh2_drc_dispatcher;
 591
 592   // if pool has been freed, reuse
 593   for (i = cnt - 1; i >= 0; i--)
 594     if (bl[i].target_pc != 0)
 595       break;
 596   cnt = i + 1;
 597   if (cnt >= block_link_pool_max_counts[tcache_id]) {
 598     dbg(1, "bl overflow for tcache %d", tcache_id);
 599     return NULL;
 600   }
 601   bl += cnt;
 602   block_link_pool_counts[tcache_id]++;
 603
 604   bl->target_pc = pc;
 605   bl->jump = tcache_ptr;
 606
 607   if (be != NULL) {
 608     dbg(2, "- early link from %p to pc %08x", bl->jump, pc);
 609     bl->next = be->links;
 610     be->links = bl;
 611     return be->tcache_ptr;
 612   }
 613   else {
 614     bl->next = unresolved_links[tcache_id];
 615     unresolved_links[tcache_id] = bl;
 616     return sh2_drc_dispatcher;
 617   }
 618 #else
 619   return sh2_drc_dispatcher;
 620 #endif
 621 }
 622
 623 static void dr_link_blocks(struct block_entry *be, int tcache_id)
 624 {
 625 #if LINK_BRANCHES
 626   struct block_link *first = unresolved_links[tcache_id];
 627   struct block_link *bl, *prev, *tmp;
 628   u32 pc = be->pc;
 629
 630   for (bl = prev = first; bl != NULL; ) {
 631     if (bl->target_pc == pc) {
 632       dbg(2, "- link from %p to pc %08x", bl->jump, pc);
 633       emith_jump_patch(bl->jump, tcache_ptr);
 634
 635       // move bl from unresolved_links to block_entry
 636       tmp = bl->next;
 637       bl->next = be->links;
 638       be->links = bl;
 639
 640       if (bl == first)
 641         first = prev = bl = tmp;
 642       else
 643         prev->next = bl = tmp;
 644       continue;
 645     }
 646     prev = bl;
 647     bl = bl->next;
 648   }
 649   unresolved_links[tcache_id] = first;
 650
 651   // could sync arm caches here, but that's unnecessary
 652 #endif
 653 }
 654
 655 #define ADD_TO_ARRAY(array, count, item, failcode) \
 656   if (count >= ARRAY_SIZE(array)) { \
 657     dbg(1, "warning: " #array " overflow"); \
 658     failcode; \
 659   } \
 660   array[count++] = item;
 661
 662 static int find_in_array(u32 *array, size_t size, u32 what)
 663 {
 664   size_t i;
 665   for (i = 0; i < size; i++)
 666     if (what == array[i])
 667       return i;
 668
 669   return -1;
 670 }
 671
 672 // ---------------------------------------------------------------
 673
 674 // register cache / constant propagation stuff
 675 typedef enum {
 676   RC_GR_READ,
 677   RC_GR_WRITE,
 678   RC_GR_RMW,
 679 } rc_gr_mode;
 680
 681 static int rcache_get_reg_(sh2_reg_e r, rc_gr_mode mode, int do_locking);
 682
 683 // guest regs with constants
 684 static u32 dr_gcregs[24];
 685 // a mask of constant/dirty regs
 686 static u32 dr_gcregs_mask;
 687 static u32 dr_gcregs_dirty;
 688
 689 #if PROPAGATE_CONSTANTS
 690 static void gconst_new(sh2_reg_e r, u32 val)
 691 {
 692   int i;
 693
 694   dr_gcregs_mask  |= 1 << r;
 695   dr_gcregs_dirty |= 1 << r;
 696   dr_gcregs[r] = val;
 697
 698   // throw away old r that we might have cached
 699   for (i = ARRAY_SIZE(reg_temp) - 1; i >= 0; i--) {
 700     if ((reg_temp[i].type == HR_CACHED) &&
 701          reg_temp[i].greg == r) {
 702       reg_temp[i].type = HR_FREE;
 703       reg_temp[i].flags = 0;
 704     }
 705   }
 706 }
 707 #endif
 708
 709 static int gconst_get(sh2_reg_e r, u32 *val)
 710 {
 711   if (dr_gcregs_mask & (1 << r)) {
 712     *val = dr_gcregs[r];
 713     return 1;
 714   }
 715   return 0;
 716 }
 717
 718 static int gconst_check(sh2_reg_e r)
 719 {
 720   if ((dr_gcregs_mask | dr_gcregs_dirty) & (1 << r))
 721     return 1;
 722   return 0;
 723 }
 724
 725 // update hr if dirty, else do nothing
 726 static int gconst_try_read(int hr, sh2_reg_e r)
 727 {
 728   if (dr_gcregs_dirty & (1 << r)) {
 729     emith_move_r_imm(hr, dr_gcregs[r]);
 730     dr_gcregs_dirty &= ~(1 << r);
 731     return 1;
 732   }
 733   return 0;
 734 }
 735
 736 static void gconst_check_evict(sh2_reg_e r)
 737 {
 738   if (dr_gcregs_mask & (1 << r))
 739     // no longer cached in reg, make dirty again
 740     dr_gcregs_dirty |= 1 << r;
 741 }
 742
 743 static void gconst_kill(sh2_reg_e r)
 744 {
 745   dr_gcregs_mask &= ~(1 << r);
 746   dr_gcregs_dirty &= ~(1 << r);
 747 }
 748
 749 static void gconst_clean(void)
 750 {
 751   int i;
 752
 753   for (i = 0; i < ARRAY_SIZE(dr_gcregs); i++)
 754     if (dr_gcregs_dirty & (1 << i)) {
 755       // using RC_GR_READ here: it will call gconst_try_read,
 756       // cache the reg and mark it dirty.
 757       rcache_get_reg_(i, RC_GR_READ, 0);
 758     }
 759 }
 760
 761 static void gconst_invalidate(void)
 762 {
 763   dr_gcregs_mask = dr_gcregs_dirty = 0;
 764 }
 765
 766 static u16 rcache_counter;
 767
 768 static temp_reg_t *rcache_evict(void)
 769 {
 770   // evict reg with oldest stamp
 771   int i, oldest = -1;
 772   u16 min_stamp = (u16)-1;
 773
 774   for (i = 0; i < ARRAY_SIZE(reg_temp); i++) {
 775     if (reg_temp[i].type == HR_CACHED && !(reg_temp[i].flags & HRF_LOCKED) &&
 776         reg_temp[i].stamp <= min_stamp) {
 777       min_stamp = reg_temp[i].stamp;
 778       oldest = i;
 779     }
 780   }
 781
 782   if (oldest == -1) {
 783     printf("no registers to evict, aborting\n");
 784     exit(1);
 785   }
 786
 787   i = oldest;
 788   if (reg_temp[i].type == HR_CACHED) {
 789     if (reg_temp[i].flags & HRF_DIRTY)
 790       // writeback
 791       emith_ctx_write(reg_temp[i].hreg, reg_temp[i].greg * 4);
 792     gconst_check_evict(reg_temp[i].greg);
 793   }
 794
 795   reg_temp[i].type = HR_FREE;
 796   reg_temp[i].flags = 0;
 797   return &reg_temp[i];
 798 }
 799
 800 static int get_reg_static(sh2_reg_e r, rc_gr_mode mode)
 801 {
 802   int i = reg_map_g2h[r];
 803   if (i != -1) {
 804     if (mode != RC_GR_WRITE)
 805       gconst_try_read(i, r);
 806   }
 807   return i;
 808 }
 809
 810 // note: must not be called when doing conditional code
 811 static int rcache_get_reg_(sh2_reg_e r, rc_gr_mode mode, int do_locking)
 812 {
 813   temp_reg_t *tr;
 814   int i, ret;
 815
 816   // maybe statically mapped?
 817   ret = get_reg_static(r, mode);
 818   if (ret != -1)
 819     goto end;
 820
 821   rcache_counter++;
 822
 823   // maybe already cached?
 824   // if so, prefer against gconst (they must be in sync)
 825   for (i = ARRAY_SIZE(reg_temp) - 1; i >= 0; i--) {
 826     if (reg_temp[i].type == HR_CACHED && reg_temp[i].greg == r) {
 827       reg_temp[i].stamp = rcache_counter;
 828       if (mode != RC_GR_READ)
 829         reg_temp[i].flags |= HRF_DIRTY;
 830       ret = reg_temp[i].hreg;
 831       goto end;
 832     }
 833   }
 834
 835   // use any free reg
 836   for (i = ARRAY_SIZE(reg_temp) - 1; i >= 0; i--) {
 837     if (reg_temp[i].type == HR_FREE) {
 838       tr = &reg_temp[i];
 839       goto do_alloc;
 840     }
 841   }
 842
 843   tr = rcache_evict();
 844
 845 do_alloc:
 846   tr->type = HR_CACHED;
 847   if (do_locking)
 848     tr->flags |= HRF_LOCKED;
 849   if (mode != RC_GR_READ)
 850     tr->flags |= HRF_DIRTY;
 851   tr->greg = r;
 852   tr->stamp = rcache_counter;
 853   ret = tr->hreg;
 854
 855   if (mode != RC_GR_WRITE) {
 856     if (gconst_check(r)) {
 857       if (gconst_try_read(ret, r))
 858         tr->flags |= HRF_DIRTY;
 859     }
 860     else
 861       emith_ctx_read(tr->hreg, r * 4);
 862   }
 863
 864 end:
 865   if (mode != RC_GR_READ)
 866     gconst_kill(r);
 867
 868   return ret;
 869 }
 870
 871 static int rcache_get_reg(sh2_reg_e r, rc_gr_mode mode)
 872 {
 873   return rcache_get_reg_(r, mode, 1);
 874 }
 875
 876 static int rcache_get_tmp(void)
 877 {
 878   temp_reg_t *tr;
 879   int i;
 880
 881   for (i = 0; i < ARRAY_SIZE(reg_temp); i++)
 882     if (reg_temp[i].type == HR_FREE) {
 883       tr = &reg_temp[i];
 884       goto do_alloc;
 885     }
 886
 887   tr = rcache_evict();
 888
 889 do_alloc:
 890   tr->type = HR_TEMP;
 891   return tr->hreg;
 892 }
 893
 894 static int rcache_get_arg_id(int arg)
 895 {
 896   int i, r = 0;
 897   host_arg2reg(r, arg);
 898
 899   for (i = 0; i < ARRAY_SIZE(reg_temp); i++)
 900     if (reg_temp[i].hreg == r)
 901       break;
 902
 903   if (i == ARRAY_SIZE(reg_temp)) // can't happen
 904     exit(1);
 905
 906   if (reg_temp[i].type == HR_CACHED) {
 907     // writeback
 908     if (reg_temp[i].flags & HRF_DIRTY)
 909       emith_ctx_write(reg_temp[i].hreg, reg_temp[i].greg * 4);
 910     gconst_check_evict(reg_temp[i].greg);
 911   }
 912   else if (reg_temp[i].type == HR_TEMP) {
 913     printf("arg %d reg %d already used, aborting\n", arg, r);
 914     exit(1);
 915   }
 916
 917   reg_temp[i].type = HR_FREE;
 918   reg_temp[i].flags = 0;
 919
 920   return i;
 921 }
 922
 923 // get a reg to be used as function arg
 924 static int rcache_get_tmp_arg(int arg)
 925 {
 926   int id = rcache_get_arg_id(arg);
 927   reg_temp[id].type = HR_TEMP;
 928
 929   return reg_temp[id].hreg;
 930 }
 931
 932 // same but caches a reg. RC_GR_READ only.
 933 static int rcache_get_reg_arg(int arg, sh2_reg_e r)
 934 {
 935   int i, srcr, dstr, dstid;
 936   int dirty = 0, src_dirty = 0;
 937
 938   dstid = rcache_get_arg_id(arg);
 939   dstr = reg_temp[dstid].hreg;
 940
 941   // maybe already statically mapped?
 942   srcr = get_reg_static(r, RC_GR_READ);
 943   if (srcr != -1)
 944     goto do_cache;
 945
 946   // maybe already cached?
 947   for (i = ARRAY_SIZE(reg_temp) - 1; i >= 0; i--) {
 948     if ((reg_temp[i].type == HR_CACHED) &&
 949          reg_temp[i].greg == r)
 950     {
 951       srcr = reg_temp[i].hreg;
 952       if (reg_temp[i].flags & HRF_DIRTY)
 953         src_dirty = 1;
 954       goto do_cache;
 955     }
 956   }
 957
 958   // must read
 959   srcr = dstr;
 960   if (gconst_check(r)) {
 961     if (gconst_try_read(srcr, r))
 962       dirty = 1;
 963   }
 964   else
 965     emith_ctx_read(srcr, r * 4);
 966
 967 do_cache:
 968   if (dstr != srcr)
 969     emith_move_r_r(dstr, srcr);
 970 #if 1
 971   else
 972     dirty |= src_dirty;
 973
 974   if (dirty)
 975     // must clean, callers might want to modify the arg before call
 976     emith_ctx_write(dstr, r * 4);
 977 #else
 978   if (dirty)
 979     reg_temp[dstid].flags |= HRF_DIRTY;
 980 #endif
 981
 982   reg_temp[dstid].stamp = ++rcache_counter;
 983   reg_temp[dstid].type = HR_CACHED;
 984   reg_temp[dstid].greg = r;
 985   reg_temp[dstid].flags |= HRF_LOCKED;
 986   return dstr;
 987 }
 988
 989 static void rcache_free_tmp(int hr)
 990 {
 991   int i;
 992   for (i = 0; i < ARRAY_SIZE(reg_temp); i++)
 993     if (reg_temp[i].hreg == hr)
 994       break;
 995
 996   if (i == ARRAY_SIZE(reg_temp) || reg_temp[i].type != HR_TEMP) {
 997     printf("rcache_free_tmp fail: #%i hr %d, type %d\n", i, hr, reg_temp[i].type);
 998     return;
 999   }
1000
1001   reg_temp[i].type = HR_FREE;
1002   reg_temp[i].flags = 0;
1003 }
1004
1005 static void rcache_unlock(int hr)
1006 {
1007   int i;
1008   for (i = 0; i < ARRAY_SIZE(reg_temp); i++)
1009     if (reg_temp[i].type == HR_CACHED && reg_temp[i].hreg == hr)
1010       reg_temp[i].flags &= ~HRF_LOCKED;
1011 }
1012
1013 static void rcache_unlock_all(void)
1014 {
1015   int i;
1016   for (i = 0; i < ARRAY_SIZE(reg_temp); i++)
1017     reg_temp[i].flags &= ~HRF_LOCKED;
1018 }
1019
1020 static inline u32 rcache_used_hreg_mask(void)
1021 {
1022   u32 mask = 0;
1023   int i;
1024
1025   for (i = 0; i < ARRAY_SIZE(reg_temp); i++)
1026     if (reg_temp[i].type != HR_FREE)
1027       mask |= 1 << reg_temp[i].hreg;
1028
1029   return mask;
1030 }
1031
1032 static void rcache_clean(void)
1033 {
1034   int i;
1035   gconst_clean();
1036
1037   for (i = 0; i < ARRAY_SIZE(reg_temp); i++)
1038     if (reg_temp[i].type == HR_CACHED && (reg_temp[i].flags & HRF_DIRTY)) {
1039       // writeback
1040       emith_ctx_write(reg_temp[i].hreg, reg_temp[i].greg * 4);
1041       reg_temp[i].flags &= ~HRF_DIRTY;
1042     }
1043 }
1044
1045 static void rcache_invalidate(void)
1046 {
1047   int i;
1048   for (i = 0; i < ARRAY_SIZE(reg_temp); i++) {
1049     reg_temp[i].type = HR_FREE;
1050     reg_temp[i].flags = 0;
1051   }
1052   rcache_counter = 0;
1053
1054   gconst_invalidate();
1055 }
1056
1057 static void rcache_flush(void)
1058 {
1059   rcache_clean();
1060   rcache_invalidate();
1061 }
1062
1063 // ---------------------------------------------------------------
1064
1065 static int emit_get_rbase_and_offs(u32 a, u32 *offs)
1066 {
1067   u32 mask = 0;
1068   int poffs;
1069   int hr;
1070
1071   poffs = dr_ctx_get_mem_ptr(a, &mask);
1072   if (poffs == -1)
1073     return -1;
1074
1075   // XXX: could use some related reg
1076   hr = rcache_get_tmp();
1077   emith_ctx_read(hr, poffs);
1078   emith_add_r_imm(hr, a & mask & ~0xff);
1079   *offs = a & 0xff; // XXX: ARM oriented..
1080   return hr;
1081 }
1082
1083 static void emit_move_r_imm32(sh2_reg_e dst, u32 imm)
1084 {
1085 #if PROPAGATE_CONSTANTS
1086   gconst_new(dst, imm);
1087 #else
1088   int hr = rcache_get_reg(dst, RC_GR_WRITE);
1089   emith_move_r_imm(hr, imm);
1090 #endif
1091 }
1092
1093 static void emit_move_r_r(sh2_reg_e dst, sh2_reg_e src)
1094 {
1095   int hr_d = rcache_get_reg(dst, RC_GR_WRITE);
1096   int hr_s = rcache_get_reg(src, RC_GR_READ);
1097
1098   emith_move_r_r(hr_d, hr_s);
1099 }
1100
1101 // T must be clear, and comparison done just before this
1102 static void emit_or_t_if_eq(int srr)
1103 {
1104   EMITH_SJMP_START(DCOND_NE);
1105   emith_or_r_imm_c(DCOND_EQ, srr, T);
1106   EMITH_SJMP_END(DCOND_NE);
1107 }
1108
1109 // arguments must be ready
1110 // reg cache must be clean before call
1111 static int emit_memhandler_read_(int size, int ram_check)
1112 {
1113   int arg1;
1114 #if 0
1115   int arg0;
1116   host_arg2reg(arg0, 0);
1117 #endif
1118
1119   rcache_clean();
1120
1121   // must writeback cycles for poll detection stuff
1122   // FIXME: rm
1123   if (reg_map_g2h[SHR_SR] != -1)
1124     emith_ctx_write(reg_map_g2h[SHR_SR], SHR_SR * 4);
1125
1126   arg1 = rcache_get_tmp_arg(1);
1127   emith_move_r_r(arg1, CONTEXT_REG);
1128
1129 #if 0 // can't do this because of unmapped reads
1130  // ndef PDB_NET
1131   if (ram_check && Pico.rom == (void *)0x02000000 && Pico32xMem->sdram == (void *)0x06000000) {
1132     int tmp = rcache_get_tmp();
1133     emith_and_r_r_imm(tmp, arg0, 0xfb000000);
1134     emith_cmp_r_imm(tmp, 0x02000000);
1135     switch (size) {
1136     case 0: // 8
1137       EMITH_SJMP3_START(DCOND_NE);
1138       emith_eor_r_imm_c(DCOND_EQ, arg0, 1);
1139       emith_read8_r_r_offs_c(DCOND_EQ, arg0, arg0, 0);
1140       EMITH_SJMP3_MID(DCOND_NE);
1141       emith_call_cond(DCOND_NE, sh2_drc_read8);
1142       EMITH_SJMP3_END();
1143       break;
1144     case 1: // 16
1145       EMITH_SJMP3_START(DCOND_NE);
1146       emith_read16_r_r_offs_c(DCOND_EQ, arg0, arg0, 0);
1147       EMITH_SJMP3_MID(DCOND_NE);
1148       emith_call_cond(DCOND_NE, sh2_drc_read16);
1149       EMITH_SJMP3_END();
1150       break;
1151     case 2: // 32
1152       EMITH_SJMP3_START(DCOND_NE);
1153       emith_read_r_r_offs_c(DCOND_EQ, arg0, arg0, 0);
1154       emith_ror_c(DCOND_EQ, arg0, arg0, 16);
1155       EMITH_SJMP3_MID(DCOND_NE);
1156       emith_call_cond(DCOND_NE, sh2_drc_read32);
1157       EMITH_SJMP3_END();
1158       break;
1159     }
1160   }
1161   else
1162 #endif
1163   {
1164     switch (size) {
1165     case 0: // 8
1166       emith_call(sh2_drc_read8);
1167       break;
1168     case 1: // 16
1169       emith_call(sh2_drc_read16);
1170       break;
1171     case 2: // 32
1172       emith_call(sh2_drc_read32);
1173       break;
1174     }
1175   }
1176   rcache_invalidate();
1177
1178   if (reg_map_g2h[SHR_SR] != -1)
1179     emith_ctx_read(reg_map_g2h[SHR_SR], SHR_SR * 4);
1180
1181   // assuming arg0 and retval reg matches
1182   return rcache_get_tmp_arg(0);
1183 }
1184
1185 static int emit_memhandler_read(int size)
1186 {
1187   return emit_memhandler_read_(size, 1);
1188 }
1189
1190 static int emit_memhandler_read_rr(sh2_reg_e rd, sh2_reg_e rs, u32 offs, int size)
1191 {
1192   int hr, hr2, ram_check = 1;
1193   u32 val, offs2;
1194
1195   if (gconst_get(rs, &val)) {
1196     hr = emit_get_rbase_and_offs(val + offs, &offs2);
1197     if (hr != -1) {
1198       hr2 = rcache_get_reg(rd, RC_GR_WRITE);
1199       switch (size) {
1200       case 0: // 8
1201         emith_read8_r_r_offs(hr2, hr, offs2 ^ 1);
1202         emith_sext(hr2, hr2, 8);
1203         break;
1204       case 1: // 16
1205         emith_read16_r_r_offs(hr2, hr, offs2);
1206         emith_sext(hr2, hr2, 16);
1207         break;
1208       case 2: // 32
1209         emith_read_r_r_offs(hr2, hr, offs2);
1210         emith_ror(hr2, hr2, 16);
1211         break;
1212       }
1213       rcache_free_tmp(hr);
1214       return hr2;
1215     }
1216
1217     ram_check = 0;
1218   }
1219
1220   hr = rcache_get_reg_arg(0, rs);
1221   if (offs != 0)
1222     emith_add_r_imm(hr, offs);
1223   hr  = emit_memhandler_read_(size, ram_check);
1224   hr2 = rcache_get_reg(rd, RC_GR_WRITE);
1225   if (size != 2) {
1226     emith_sext(hr2, hr, (size == 1) ? 16 : 8);
1227   } else
1228     emith_move_r_r(hr2, hr);
1229   rcache_free_tmp(hr);
1230
1231   return hr2;
1232 }
1233
1234 static void emit_memhandler_write(int size)
1235 {
1236   int ctxr;
1237   host_arg2reg(ctxr, 2);
1238   if (reg_map_g2h[SHR_SR] != -1)
1239     emith_ctx_write(reg_map_g2h[SHR_SR], SHR_SR * 4);
1240
1241   rcache_clean();
1242
1243   switch (size) {
1244   case 0: // 8
1245     // XXX: consider inlining sh2_drc_write8
1246     emith_call(sh2_drc_write8);
1247     break;
1248   case 1: // 16
1249     emith_call(sh2_drc_write16);
1250     break;
1251   case 2: // 32
1252     emith_move_r_r(ctxr, CONTEXT_REG);
1253     emith_call(sh2_drc_write32);
1254     break;
1255   }
1256
1257   rcache_invalidate();
1258   if (reg_map_g2h[SHR_SR] != -1)
1259     emith_ctx_read(reg_map_g2h[SHR_SR], SHR_SR * 4);
1260 }
1261
1262 // @(Rx,Ry)
1263 static int emit_indirect_indexed_read(int rx, int ry, int size)
1264 {
1265   int a0, t;
1266   a0 = rcache_get_reg_arg(0, rx);
1267   t  = rcache_get_reg(ry, RC_GR_READ);
1268   emith_add_r_r(a0, t);
1269   return emit_memhandler_read(size);
1270 }
1271
1272 // read @Rn, @rm
1273 static void emit_indirect_read_double(u32 *rnr, u32 *rmr, int rn, int rm, int size)
1274 {
1275   int tmp;
1276
1277   rcache_get_reg_arg(0, rn);
1278   tmp = emit_memhandler_read(size);
1279   emith_ctx_write(tmp, offsetof(SH2, drc_tmp));
1280   rcache_free_tmp(tmp);
1281   tmp = rcache_get_reg(rn, RC_GR_RMW);
1282   emith_add_r_imm(tmp, 1 << size);
1283   rcache_unlock(tmp);
1284
1285   rcache_get_reg_arg(0, rm);
1286   *rmr = emit_memhandler_read(size);
1287   *rnr = rcache_get_tmp();
1288   emith_ctx_read(*rnr, offsetof(SH2, drc_tmp));
1289   tmp = rcache_get_reg(rm, RC_GR_RMW);
1290   emith_add_r_imm(tmp, 1 << size);
1291   rcache_unlock(tmp);
1292 }
1293
1294 static void emit_do_static_regs(int is_write, int tmpr)
1295 {
1296   int i, r, count;
1297
1298   for (i = 0; i < ARRAY_SIZE(reg_map_g2h); i++) {
1299     r = reg_map_g2h[i];
1300     if (r == -1)
1301       continue;
1302
1303     for (count = 1; i < ARRAY_SIZE(reg_map_g2h) - 1; i++, r++) {
1304       if (reg_map_g2h[i + 1] != r + 1)
1305         break;
1306       count++;
1307     }
1308
1309     if (count > 1) {
1310       // i, r point to last item
1311       if (is_write)
1312         emith_ctx_write_multiple(r - count + 1, (i - count + 1) * 4, count, tmpr);
1313       else
1314         emith_ctx_read_multiple(r - count + 1, (i - count + 1) * 4, count, tmpr);
1315     } else {
1316       if (is_write)
1317         emith_ctx_write(r, i * 4);
1318       else
1319         emith_ctx_read(r, i * 4);
1320     }
1321   }
1322 }
1323
1324 static void emit_block_entry(void)
1325 {
1326   int arg0;
1327
1328   host_arg2reg(arg0, 0);
1329
1330 #if (DRC_DEBUG & 8) || defined(PDB)
1331   int arg1, arg2;
1332   host_arg2reg(arg1, 1);
1333   host_arg2reg(arg2, 2);
1334
1335   emit_do_static_regs(1, arg2);
1336   emith_move_r_r(arg1, CONTEXT_REG);
1337   emith_move_r_r(arg2, rcache_get_reg(SHR_SR, RC_GR_READ));
1338   emith_call(sh2_drc_log_entry);
1339   rcache_invalidate();
1340 #endif
1341   emith_tst_r_r(arg0, arg0);
1342   EMITH_SJMP_START(DCOND_EQ);
1343   emith_jump_reg_c(DCOND_NE, arg0);
1344   EMITH_SJMP_END(DCOND_EQ);
1345 }
1346
1347 #define DELAY_SAVE_T(sr) { \
1348   emith_bic_r_imm(sr, T_save); \
1349   emith_tst_r_imm(sr, T);      \
1350   EMITH_SJMP_START(DCOND_EQ);  \
1351   emith_or_r_imm_c(DCOND_NE, sr, T_save); \
1352   EMITH_SJMP_END(DCOND_EQ);    \
1353 }
1354
1355 #define FLUSH_CYCLES(sr) \
1356   if (cycles > 0) { \
1357     emith_sub_r_imm(sr, cycles << 12); \
1358     cycles = 0; \
1359   }
1360
1361 static void *dr_get_pc_base(u32 pc, int is_slave);
1362
1363 static void REGPARM(2) *sh2_translate(SH2 *sh2, int tcache_id)
1364 {
1365   u32 branch_target_pc[MAX_LOCAL_BRANCHES];
1366   void *branch_target_ptr[MAX_LOCAL_BRANCHES];
1367   int branch_target_count = 0;
1368   void *branch_patch_ptr[MAX_LOCAL_BRANCHES];
1369   u32 branch_patch_pc[MAX_LOCAL_BRANCHES];
1370   int branch_patch_count = 0;
1371   u32 literal_addr[MAX_LITERALS];
1372   int literal_addr_count = 0;
1373   u8 op_flags[BLOCK_INSN_LIMIT];
1374   struct {
1375     u32 test_irq:1;
1376     u32 pending_branch_direct:1;
1377     u32 pending_branch_indirect:1;
1378     u32 literals_disabled:1;
1379   } drcf = { 0, };
1380
1381   // PC of current, first, last SH2 insn
1382   u32 pc, base_pc, end_pc;
1383   u32 end_literals;
1384   void *block_entry_ptr;
1385   struct block_desc *block;
1386   u16 *dr_pc_base;
1387   struct op_data *opd;
1388   int blkid_main = 0;
1389   int skip_op = 0;
1390   u32 tmp, tmp2;
1391   int cycles;
1392   int i, v;
1393   int op;
1394
1395   base_pc = sh2->pc;
1396   drcf.literals_disabled = literal_disabled_frames != 0;
1397
1398   // get base/validate PC
1399   dr_pc_base = dr_get_pc_base(base_pc, sh2->is_slave);
1400   if (dr_pc_base == (void *)-1) {
1401     printf("invalid PC, aborting: %08x\n", base_pc);
1402     // FIXME: be less destructive
1403     exit(1);
1404   }
1405
1406   tcache_ptr = tcache_ptrs[tcache_id];
1407
1408   // predict tcache overflow
1409   tmp = tcache_ptr - tcache_bases[tcache_id];
1410   if (tmp > tcache_sizes[tcache_id] - MAX_BLOCK_SIZE) {
1411     dbg(1, "tcache %d overflow", tcache_id);
1412     return NULL;
1413   }
1414
1415   // initial passes to disassemble and analyze the block
1416   scan_block(base_pc, sh2->is_slave, op_flags, &end_pc, &end_literals);
1417
1418   if (drcf.literals_disabled)
1419     end_literals = end_pc;
1420
1421   block = dr_add_block(base_pc, end_literals - base_pc,
1422     end_pc - base_pc, sh2->is_slave, &blkid_main);
1423   if (block == NULL)
1424     return NULL;
1425
1426   block_entry_ptr = tcache_ptr;
1427   dbg(2, "== %csh2 block #%d,%d %08x-%08x -> %p", sh2->is_slave ? 's' : 'm',
1428     tcache_id, blkid_main, base_pc, end_pc, block_entry_ptr);
1429
1430   dr_link_blocks(&block->entryp[0], tcache_id);
1431
1432   // collect branch_targets that don't land on delay slots
1433   for (pc = base_pc, i = 0; pc < end_pc; i++, pc += 2) {
1434     if (!(op_flags[i] & OF_BTARGET))
1435       continue;
1436     if (op_flags[i] & OF_DELAY_OP) {
1437       op_flags[i] &= ~OF_BTARGET;
1438       continue;
1439     }
1440     ADD_TO_ARRAY(branch_target_pc, branch_target_count, pc, break);
1441   }
1442
1443   if (branch_target_count > 0) {
1444     memset(branch_target_ptr, 0, sizeof(branch_target_ptr[0]) * branch_target_count);
1445   }
1446
1447   // clear stale state after compile errors
1448   rcache_invalidate();
1449
1450   // -------------------------------------------------
1451   // 3rd pass: actual compilation
1452   pc = base_pc;
1453   cycles = 0;
1454   for (i = 0; pc < end_pc; i++)
1455   {
1456     u32 delay_dep_fw = 0, delay_dep_bk = 0;
1457     u32 tmp3, tmp4, sr;
1458
1459     opd = &ops[i];
1460     op = FETCH_OP(pc);
1461
1462 #if (DRC_DEBUG & 2)
1463     insns_compiled++;
1464 #endif
1465 #if (DRC_DEBUG & 4)
1466     DasmSH2(sh2dasm_buff, pc, op);
1467     printf("%c%08x %04x %s\n", (op_flags[i] & OF_BTARGET) ? '*' : ' ',
1468       pc, op, sh2dasm_buff);
1469 #endif
1470
1471     if ((op_flags[i] & OF_BTARGET) || pc == base_pc)
1472     {
1473       if (pc != base_pc)
1474       {
1475         sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
1476         FLUSH_CYCLES(sr);
1477         rcache_flush();
1478
1479         // make block entry
1480         v = block->entry_count;
1481         if (v < ARRAY_SIZE(block->entryp)) {
1482           block->entryp[v].pc = pc;
1483           block->entryp[v].tcache_ptr = tcache_ptr;
1484           block->entryp[v].links = NULL;
1485 #if (DRC_DEBUG & 2)
1486           block->entryp[v].block = block;
1487 #endif
1488           add_to_hashlist(&block->entryp[v], tcache_id);
1489           block->entry_count++;
1490
1491           dbg(2, "-- %csh2 block #%d,%d entry %08x -> %p",
1492             sh2->is_slave ? 's' : 'm', tcache_id, blkid_main,
1493             pc, tcache_ptr);
1494
1495           // since we made a block entry, link any other blocks
1496           // that jump to current pc
1497           dr_link_blocks(&block->entryp[v], tcache_id);
1498         }
1499         else {
1500           dbg(1, "too many entryp for block #%d,%d pc=%08x",
1501             tcache_id, blkid_main, pc);
1502         }
1503
1504         do_host_disasm(tcache_id);
1505       }
1506
1507       v = find_in_array(branch_target_pc, branch_target_count, pc);
1508       if (v >= 0)
1509         branch_target_ptr[v] = tcache_ptr;
1510
1511       // must update PC
1512       emit_move_r_imm32(SHR_PC, pc);
1513       rcache_clean();
1514
1515       // check cycles
1516       sr = rcache_get_reg(SHR_SR, RC_GR_READ);
1517       emith_cmp_r_imm(sr, 0);
1518       emith_jump_cond(DCOND_LE, sh2_drc_exit);
1519       do_host_disasm(tcache_id);
1520       rcache_unlock_all();
1521     }
1522
1523 #ifdef DRC_CMP
1524     if (!(op_flags[i] & OF_DELAY_OP)) {
1525       emit_move_r_imm32(SHR_PC, pc);
1526       sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
1527       FLUSH_CYCLES(sr);
1528       rcache_clean();
1529
1530       tmp = rcache_used_hreg_mask();
1531       emith_save_caller_regs(tmp);
1532       emit_do_static_regs(1, 0);
1533       emith_pass_arg_r(0, CONTEXT_REG);
1534       emith_call(do_sh2_cmp);
1535       emith_restore_caller_regs(tmp);
1536     }
1537 #endif
1538
1539     pc += 2;
1540
1541     if (skip_op > 0) {
1542       skip_op--;
1543       continue;
1544     }
1545
1546     if (op_flags[i] & OF_DELAY_OP)
1547     {
1548       // handle delay slot dependencies
1549       delay_dep_fw = opd->dest & ops[i-1].source;
1550       delay_dep_bk = opd->source & ops[i-1].dest;
1551       if (delay_dep_fw & BITMASK1(SHR_T)) {
1552         sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
1553         DELAY_SAVE_T(sr);
1554       }
1555       if (delay_dep_bk & BITMASK1(SHR_PC)) {
1556         if (opd->op != OP_LOAD_POOL && opd->op != OP_MOVA) {
1557           // can only be those 2 really..
1558           elprintf_sh2(sh2, EL_ANOMALY,
1559             "drc: illegal slot insn %04x @ %08x?", op, pc - 2);
1560         }
1561         if (opd->imm != 0)
1562           ; // addr already resolved somehow
1563         else {
1564           switch (ops[i-1].op) {
1565           case OP_BRANCH:
1566             emit_move_r_imm32(SHR_PC, ops[i-1].imm);
1567             break;
1568           case OP_BRANCH_CT:
1569           case OP_BRANCH_CF:
1570             tmp = rcache_get_reg(SHR_PC, RC_GR_WRITE);
1571             sr = rcache_get_reg(SHR_SR, RC_GR_READ);
1572             emith_move_r_imm(tmp, pc);
1573             emith_tst_r_imm(sr, T);
1574             tmp2 = ops[i-1].op == OP_BRANCH_CT ? DCOND_NE : DCOND_EQ;
1575             emith_move_r_imm_c(tmp2, tmp, ops[i-1].imm);
1576             break;
1577           // case OP_BRANCH_R OP_BRANCH_RF - PC already loaded
1578           }
1579         }
1580       }
1581       //if (delay_dep_fw & ~BITMASK1(SHR_T))
1582       //  dbg(1, "unhandled delay_dep_fw: %x", delay_dep_fw & ~BITMASK1(SHR_T));
1583       if (delay_dep_bk & ~BITMASK2(SHR_PC, SHR_PR))
1584         dbg(1, "unhandled delay_dep_bk: %x", delay_dep_bk);
1585     }
1586
1587     switch (opd->op)
1588     {
1589     case OP_BRANCH:
1590     case OP_BRANCH_CT:
1591     case OP_BRANCH_CF:
1592       if (opd->dest & BITMASK1(SHR_PR))
1593         emit_move_r_imm32(SHR_PR, pc + 2);
1594       drcf.pending_branch_direct = 1;
1595       goto end_op;
1596
1597     case OP_BRANCH_R:
1598       if (opd->dest & BITMASK1(SHR_PR))
1599         emit_move_r_imm32(SHR_PR, pc + 2);
1600       emit_move_r_r(SHR_PC, opd->rm);
1601       drcf.pending_branch_indirect = 1;
1602       goto end_op;
1603
1604     case OP_BRANCH_RF:
1605       tmp  = rcache_get_reg(SHR_PC, RC_GR_WRITE);
1606       tmp2 = rcache_get_reg(GET_Rn(), RC_GR_READ);
1607       if (opd->dest & BITMASK1(SHR_PR)) {
1608         tmp3 = rcache_get_reg(SHR_PR, RC_GR_WRITE);
1609         emith_move_r_imm(tmp3, pc + 2);
1610         emith_add_r_r_r(tmp, tmp2, tmp3);
1611       }
1612       else {
1613         emith_move_r_r(tmp, tmp2);
1614         emith_add_r_imm(tmp, pc + 2);
1615       }
1616       drcf.pending_branch_indirect = 1;
1617       goto end_op;
1618
1619     case OP_SLEEP:
1620       printf("TODO sleep\n");
1621       goto end_op;
1622
1623     case OP_RTE:
1624       // pop PC
1625       emit_memhandler_read_rr(SHR_PC, SHR_SP, 0, 2);
1626       // pop SR
1627       tmp = rcache_get_reg_arg(0, SHR_SP);
1628       emith_add_r_imm(tmp, 4);
1629       tmp = emit_memhandler_read(2);
1630       sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
1631       emith_write_sr(sr, tmp);
1632       rcache_free_tmp(tmp);
1633       tmp = rcache_get_reg(SHR_SP, RC_GR_RMW);
1634       emith_add_r_imm(tmp, 4*2);
1635       drcf.test_irq = 1;
1636       drcf.pending_branch_indirect = 1;
1637       goto end_op;
1638
1639     case OP_LOAD_POOL:
1640 #if PROPAGATE_CONSTANTS
1641       if (opd->imm != 0 && opd->imm < end_literals
1642           && literal_addr_count < MAX_LITERALS)
1643       {
1644         ADD_TO_ARRAY(literal_addr, literal_addr_count, opd->imm,);
1645         if (opd->size == 2)
1646           tmp = FETCH32(opd->imm);
1647         else
1648           tmp = (u32)(int)(signed short)FETCH_OP(opd->imm);
1649         gconst_new(GET_Rn(), tmp);
1650       }
1651       else
1652 #endif
1653       {
1654         tmp = rcache_get_tmp_arg(0);
1655         if (opd->imm != 0)
1656           emith_move_r_imm(tmp, opd->imm);
1657         else {
1658           // have to calculate read addr from PC
1659           tmp2 = rcache_get_reg(SHR_PC, RC_GR_READ);
1660           if (opd->size == 2) {
1661             emith_add_r_r_imm(tmp, tmp2, 2 + (op & 0xff) * 4);
1662             emith_bic_r_imm(tmp, 3);
1663           }
1664           else
1665             emith_add_r_r_imm(tmp, tmp2, 2 + (op & 0xff) * 2);
1666         }
1667         tmp2 = emit_memhandler_read(opd->size);
1668         tmp3 = rcache_get_reg(GET_Rn(), RC_GR_WRITE);
1669         if (opd->size == 2)
1670           emith_move_r_r(tmp3, tmp2);
1671         else
1672           emith_sext(tmp3, tmp2, 16);
1673         rcache_free_tmp(tmp2);
1674       }
1675       goto end_op;
1676
1677     case OP_MOVA:
1678       if (opd->imm != 0)
1679         emit_move_r_imm32(SHR_R0, opd->imm);
1680       else {
1681         tmp = rcache_get_reg(SHR_R0, RC_GR_WRITE);
1682         tmp2 = rcache_get_reg(SHR_PC, RC_GR_READ);
1683         emith_add_r_r_imm(tmp, tmp2, 2 + (op & 0xff) * 4);
1684         emith_bic_r_imm(tmp, 3);
1685       }
1686       goto end_op;
1687     }
1688
1689     switch ((op >> 12) & 0x0f)
1690     {
1691     /////////////////////////////////////////////
1692     case 0x00:
1693       switch (op & 0x0f)
1694       {
1695       case 0x02:
1696         tmp = rcache_get_reg(GET_Rn(), RC_GR_WRITE);
1697         switch (GET_Fx())
1698         {
1699         case 0: // STC SR,Rn  0000nnnn00000010
1700           tmp2 = SHR_SR;
1701           break;
1702         case 1: // STC GBR,Rn 0000nnnn00010010
1703           tmp2 = SHR_GBR;
1704           break;
1705         case 2: // STC VBR,Rn 0000nnnn00100010
1706           tmp2 = SHR_VBR;
1707           break;
1708         default:
1709           goto default_;
1710         }
1711         tmp3 = rcache_get_reg(tmp2, RC_GR_READ);
1712         emith_move_r_r(tmp, tmp3);
1713         if (tmp2 == SHR_SR)
1714           emith_clear_msb(tmp, tmp, 22); // reserved bits defined by ISA as 0
1715         goto end_op;
1716       case 0x04: // MOV.B Rm,@(R0,Rn)   0000nnnnmmmm0100
1717       case 0x05: // MOV.W Rm,@(R0,Rn)   0000nnnnmmmm0101
1718       case 0x06: // MOV.L Rm,@(R0,Rn)   0000nnnnmmmm0110
1719         rcache_clean();
1720         tmp  = rcache_get_reg_arg(1, GET_Rm());
1721         tmp2 = rcache_get_reg_arg(0, SHR_R0);
1722         tmp3 = rcache_get_reg(GET_Rn(), RC_GR_READ);
1723         emith_add_r_r(tmp2, tmp3);
1724         emit_memhandler_write(op & 3);
1725         goto end_op;
1726       case 0x07:
1727         // MUL.L     Rm,Rn      0000nnnnmmmm0111
1728         tmp  = rcache_get_reg(GET_Rn(), RC_GR_READ);
1729         tmp2 = rcache_get_reg(GET_Rm(), RC_GR_READ);
1730         tmp3 = rcache_get_reg(SHR_MACL, RC_GR_WRITE);
1731         emith_mul(tmp3, tmp2, tmp);
1732         goto end_op;
1733       case 0x08:
1734         switch (GET_Fx())
1735         {
1736         case 0: // CLRT               0000000000001000
1737           sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
1738           emith_bic_r_imm(sr, T);
1739           break;
1740         case 1: // SETT               0000000000011000
1741           sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
1742           emith_or_r_imm(sr, T);
1743           break;
1744         case 2: // CLRMAC             0000000000101000
1745           emit_move_r_imm32(SHR_MACL, 0);
1746           emit_move_r_imm32(SHR_MACH, 0);
1747           break;
1748         default:
1749           goto default_;
1750         }
1751         goto end_op;
1752       case 0x09:
1753         switch (GET_Fx())
1754         {
1755         case 0: // NOP        0000000000001001
1756           break;
1757         case 1: // DIV0U      0000000000011001
1758           sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
1759           emith_bic_r_imm(sr, M|Q|T);
1760           break;
1761         case 2: // MOVT Rn    0000nnnn00101001
1762           sr   = rcache_get_reg(SHR_SR, RC_GR_READ);
1763           tmp2 = rcache_get_reg(GET_Rn(), RC_GR_WRITE);
1764           emith_clear_msb(tmp2, sr, 31);
1765           break;
1766         default:
1767           goto default_;
1768         }
1769         goto end_op;
1770       case 0x0a:
1771         tmp = rcache_get_reg(GET_Rn(), RC_GR_WRITE);
1772         switch (GET_Fx())
1773         {
1774         case 0: // STS      MACH,Rn   0000nnnn00001010
1775           tmp2 = SHR_MACH;
1776           break;
1777         case 1: // STS      MACL,Rn   0000nnnn00011010
1778           tmp2 = SHR_MACL;
1779           break;
1780         case 2: // STS      PR,Rn     0000nnnn00101010
1781           tmp2 = SHR_PR;
1782           break;
1783         default:
1784           goto default_;
1785         }
1786         tmp2 = rcache_get_reg(tmp2, RC_GR_READ);
1787         emith_move_r_r(tmp, tmp2);
1788         goto end_op;
1789       case 0x0c: // MOV.B    @(R0,Rm),Rn      0000nnnnmmmm1100
1790       case 0x0d: // MOV.W    @(R0,Rm),Rn      0000nnnnmmmm1101
1791       case 0x0e: // MOV.L    @(R0,Rm),Rn      0000nnnnmmmm1110
1792         tmp = emit_indirect_indexed_read(SHR_R0, GET_Rm(), op & 3);
1793         tmp2 = rcache_get_reg(GET_Rn(), RC_GR_WRITE);
1794         if ((op & 3) != 2) {
1795           emith_sext(tmp2, tmp, (op & 1) ? 16 : 8);
1796         } else
1797           emith_move_r_r(tmp2, tmp);
1798         rcache_free_tmp(tmp);
1799         goto end_op;
1800       case 0x0f: // MAC.L   @Rm+,@Rn+  0000nnnnmmmm1111
1801         emit_indirect_read_double(&tmp, &tmp2, GET_Rn(), GET_Rm(), 2);
1802         tmp4 = rcache_get_reg(SHR_MACH, RC_GR_RMW);
1803         /* MS 16 MAC bits unused if saturated */
1804         sr = rcache_get_reg(SHR_SR, RC_GR_READ);
1805         emith_tst_r_imm(sr, S);
1806         EMITH_SJMP_START(DCOND_EQ);
1807         emith_clear_msb_c(DCOND_NE, tmp4, tmp4, 16);
1808         EMITH_SJMP_END(DCOND_EQ);
1809         rcache_unlock(sr);
1810         tmp3 = rcache_get_reg(SHR_MACL, RC_GR_RMW); // might evict SR
1811         emith_mula_s64(tmp3, tmp4, tmp, tmp2);
1812         rcache_free_tmp(tmp2);
1813         sr = rcache_get_reg(SHR_SR, RC_GR_READ); // reget just in case
1814         emith_tst_r_imm(sr, S);
1815
1816         EMITH_JMP_START(DCOND_EQ);
1817         emith_asr(tmp, tmp4, 15);
1818         emith_cmp_r_imm(tmp, -1); // negative overflow (0x80000000..0xffff7fff)
1819         EMITH_SJMP_START(DCOND_GE);
1820         emith_move_r_imm_c(DCOND_LT, tmp4, 0x8000);
1821         emith_move_r_imm_c(DCOND_LT, tmp3, 0x0000);
1822         EMITH_SJMP_END(DCOND_GE);
1823         emith_cmp_r_imm(tmp, 0); // positive overflow (0x00008000..0x7fffffff)
1824         EMITH_SJMP_START(DCOND_LE);
1825         emith_move_r_imm_c(DCOND_GT, tmp4, 0x00007fff);
1826         emith_move_r_imm_c(DCOND_GT, tmp3, 0xffffffff);
1827         EMITH_SJMP_END(DCOND_LE);
1828         EMITH_JMP_END(DCOND_EQ);
1829
1830         rcache_free_tmp(tmp);
1831         goto end_op;
1832       }
1833       goto default_;
1834
1835     /////////////////////////////////////////////
1836     case 0x01:
1837       // MOV.L Rm,@(disp,Rn) 0001nnnnmmmmdddd
1838       rcache_clean();
1839       tmp  = rcache_get_reg_arg(0, GET_Rn());
1840       tmp2 = rcache_get_reg_arg(1, GET_Rm());
1841       if (op & 0x0f)
1842         emith_add_r_imm(tmp, (op & 0x0f) * 4);
1843       emit_memhandler_write(2);
1844       goto end_op;
1845
1846     case 0x02:
1847       switch (op & 0x0f)
1848       {
1849       case 0x00: // MOV.B Rm,@Rn        0010nnnnmmmm0000
1850       case 0x01: // MOV.W Rm,@Rn        0010nnnnmmmm0001
1851       case 0x02: // MOV.L Rm,@Rn        0010nnnnmmmm0010
1852         rcache_clean();
1853         rcache_get_reg_arg(0, GET_Rn());
1854         rcache_get_reg_arg(1, GET_Rm());
1855         emit_memhandler_write(op & 3);
1856         goto end_op;
1857       case 0x04: // MOV.B Rm,@-Rn       0010nnnnmmmm0100
1858       case 0x05: // MOV.W Rm,@-Rn       0010nnnnmmmm0101
1859       case 0x06: // MOV.L Rm,@-Rn       0010nnnnmmmm0110
1860         rcache_get_reg_arg(1, GET_Rm()); // for Rm == Rn
1861         tmp = rcache_get_reg(GET_Rn(), RC_GR_RMW);
1862         emith_sub_r_imm(tmp, (1 << (op & 3)));
1863         rcache_clean();
1864         rcache_get_reg_arg(0, GET_Rn());
1865         emit_memhandler_write(op & 3);
1866         goto end_op;
1867       case 0x07: // DIV0S Rm,Rn         0010nnnnmmmm0111
1868         sr   = rcache_get_reg(SHR_SR, RC_GR_RMW);
1869         tmp2 = rcache_get_reg(GET_Rn(), RC_GR_READ);
1870         tmp3 = rcache_get_reg(GET_Rm(), RC_GR_READ);
1871         emith_bic_r_imm(sr, M|Q|T);
1872         emith_tst_r_imm(tmp2, (1<<31));
1873         EMITH_SJMP_START(DCOND_EQ);
1874         emith_or_r_imm_c(DCOND_NE, sr, Q);
1875         EMITH_SJMP_END(DCOND_EQ);
1876         emith_tst_r_imm(tmp3, (1<<31));
1877         EMITH_SJMP_START(DCOND_EQ);
1878         emith_or_r_imm_c(DCOND_NE, sr, M);
1879         EMITH_SJMP_END(DCOND_EQ);
1880         emith_teq_r_r(tmp2, tmp3);
1881         EMITH_SJMP_START(DCOND_PL);
1882         emith_or_r_imm_c(DCOND_MI, sr, T);
1883         EMITH_SJMP_END(DCOND_PL);
1884         goto end_op;
1885       case 0x08: // TST Rm,Rn           0010nnnnmmmm1000
1886         sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
1887         tmp2 = rcache_get_reg(GET_Rn(), RC_GR_READ);
1888         tmp3 = rcache_get_reg(GET_Rm(), RC_GR_READ);
1889         emith_bic_r_imm(sr, T);
1890         emith_tst_r_r(tmp2, tmp3);
1891         emit_or_t_if_eq(sr);
1892         goto end_op;
1893       case 0x09: // AND Rm,Rn           0010nnnnmmmm1001
1894         tmp  = rcache_get_reg(GET_Rn(), RC_GR_RMW);
1895         tmp2 = rcache_get_reg(GET_Rm(), RC_GR_READ);
1896         emith_and_r_r(tmp, tmp2);
1897         goto end_op;
1898       case 0x0a: // XOR Rm,Rn           0010nnnnmmmm1010
1899         tmp  = rcache_get_reg(GET_Rn(), RC_GR_RMW);
1900         tmp2 = rcache_get_reg(GET_Rm(), RC_GR_READ);
1901         emith_eor_r_r(tmp, tmp2);
1902         goto end_op;
1903       case 0x0b: // OR  Rm,Rn           0010nnnnmmmm1011
1904         tmp  = rcache_get_reg(GET_Rn(), RC_GR_RMW);
1905         tmp2 = rcache_get_reg(GET_Rm(), RC_GR_READ);
1906         emith_or_r_r(tmp, tmp2);
1907         goto end_op;
1908       case 0x0c: // CMP/STR Rm,Rn       0010nnnnmmmm1100
1909         tmp  = rcache_get_tmp();
1910         tmp2 = rcache_get_reg(GET_Rn(), RC_GR_READ);
1911         tmp3 = rcache_get_reg(GET_Rm(), RC_GR_READ);
1912         emith_eor_r_r_r(tmp, tmp2, tmp3);
1913         sr   = rcache_get_reg(SHR_SR, RC_GR_RMW);
1914         emith_bic_r_imm(sr, T);
1915         emith_tst_r_imm(tmp, 0x000000ff);
1916         emit_or_t_if_eq(sr);
1917         emith_tst_r_imm(tmp, 0x0000ff00);
1918         emit_or_t_if_eq(sr);
1919         emith_tst_r_imm(tmp, 0x00ff0000);
1920         emit_or_t_if_eq(sr);
1921         emith_tst_r_imm(tmp, 0xff000000);
1922         emit_or_t_if_eq(sr);
1923         rcache_free_tmp(tmp);
1924         goto end_op;
1925       case 0x0d: // XTRCT  Rm,Rn        0010nnnnmmmm1101
1926         tmp  = rcache_get_reg(GET_Rn(), RC_GR_RMW);
1927         tmp2 = rcache_get_reg(GET_Rm(), RC_GR_READ);
1928         emith_lsr(tmp, tmp, 16);
1929         emith_or_r_r_lsl(tmp, tmp2, 16);
1930         goto end_op;
1931       case 0x0e: // MULU.W Rm,Rn        0010nnnnmmmm1110
1932       case 0x0f: // MULS.W Rm,Rn        0010nnnnmmmm1111
1933         tmp2 = rcache_get_reg(GET_Rn(), RC_GR_READ);
1934         tmp  = rcache_get_reg(SHR_MACL, RC_GR_WRITE);
1935         if (op & 1) {
1936           emith_sext(tmp, tmp2, 16);
1937         } else
1938           emith_clear_msb(tmp, tmp2, 16);
1939         tmp3 = rcache_get_reg(GET_Rm(), RC_GR_READ);
1940         tmp2 = rcache_get_tmp();
1941         if (op & 1) {
1942           emith_sext(tmp2, tmp3, 16);
1943         } else
1944           emith_clear_msb(tmp2, tmp3, 16);
1945         emith_mul(tmp, tmp, tmp2);
1946         rcache_free_tmp(tmp2);
1947         goto end_op;
1948       }
1949       goto default_;
1950
1951     /////////////////////////////////////////////
1952     case 0x03:
1953       switch (op & 0x0f)
1954       {
1955       case 0x00: // CMP/EQ Rm,Rn        0011nnnnmmmm0000
1956       case 0x02: // CMP/HS Rm,Rn        0011nnnnmmmm0010
1957       case 0x03: // CMP/GE Rm,Rn        0011nnnnmmmm0011
1958       case 0x06: // CMP/HI Rm,Rn        0011nnnnmmmm0110
1959       case 0x07: // CMP/GT Rm,Rn        0011nnnnmmmm0111
1960         sr   = rcache_get_reg(SHR_SR, RC_GR_RMW);
1961         tmp2 = rcache_get_reg(GET_Rn(), RC_GR_READ);
1962         tmp3 = rcache_get_reg(GET_Rm(), RC_GR_READ);
1963         emith_bic_r_imm(sr, T);
1964         emith_cmp_r_r(tmp2, tmp3);
1965         switch (op & 0x07)
1966         {
1967         case 0x00: // CMP/EQ
1968           emit_or_t_if_eq(sr);
1969           break;
1970         case 0x02: // CMP/HS
1971           EMITH_SJMP_START(DCOND_LO);
1972           emith_or_r_imm_c(DCOND_HS, sr, T);
1973           EMITH_SJMP_END(DCOND_LO);
1974           break;
1975         case 0x03: // CMP/GE
1976           EMITH_SJMP_START(DCOND_LT);
1977           emith_or_r_imm_c(DCOND_GE, sr, T);
1978           EMITH_SJMP_END(DCOND_LT);
1979           break;
1980         case 0x06: // CMP/HI
1981           EMITH_SJMP_START(DCOND_LS);
1982           emith_or_r_imm_c(DCOND_HI, sr, T);
1983           EMITH_SJMP_END(DCOND_LS);
1984           break;
1985         case 0x07: // CMP/GT
1986           EMITH_SJMP_START(DCOND_LE);
1987           emith_or_r_imm_c(DCOND_GT, sr, T);
1988           EMITH_SJMP_END(DCOND_LE);
1989           break;
1990         }
1991         goto end_op;
1992       case 0x04: // DIV1    Rm,Rn       0011nnnnmmmm0100
1993         // Q1 = carry(Rn = (Rn << 1) | T)
1994         // if Q ^ M
1995         //   Q2 = carry(Rn += Rm)
1996         // else
1997         //   Q2 = carry(Rn -= Rm)
1998         // Q = M ^ Q1 ^ Q2
1999         // T = (Q == M) = !(Q ^ M) = !(Q1 ^ Q2)
2000         tmp2 = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2001         tmp3 = rcache_get_reg(GET_Rm(), RC_GR_READ);
2002         sr   = rcache_get_reg(SHR_SR, RC_GR_RMW);
2003         emith_tpop_carry(sr, 0);
2004         emith_adcf_r_r(tmp2, tmp2);
2005         emith_tpush_carry(sr, 0);            // keep Q1 in T for now
2006         tmp4 = rcache_get_tmp();
2007         emith_and_r_r_imm(tmp4, sr, M);
2008         emith_eor_r_r_lsr(sr, tmp4, M_SHIFT - Q_SHIFT); // Q ^= M
2009         rcache_free_tmp(tmp4);
2010         // add or sub, invert T if carry to get Q1 ^ Q2
2011         // in: (Q ^ M) passed in Q, Q1 in T
2012         emith_sh2_div1_step(tmp2, tmp3, sr);
2013         emith_bic_r_imm(sr, Q);
2014         emith_tst_r_imm(sr, M);
2015         EMITH_SJMP_START(DCOND_EQ);
2016         emith_or_r_imm_c(DCOND_NE, sr, Q);  // Q = M
2017         EMITH_SJMP_END(DCOND_EQ);
2018         emith_tst_r_imm(sr, T);
2019         EMITH_SJMP_START(DCOND_EQ);
2020         emith_eor_r_imm_c(DCOND_NE, sr, Q); // Q = M ^ Q1 ^ Q2
2021         EMITH_SJMP_END(DCOND_EQ);
2022         emith_eor_r_imm(sr, T);             // T = !(Q1 ^ Q2)
2023         goto end_op;
2024       case 0x05: // DMULU.L Rm,Rn       0011nnnnmmmm0101
2025         tmp  = rcache_get_reg(GET_Rn(), RC_GR_READ);
2026         tmp2 = rcache_get_reg(GET_Rm(), RC_GR_READ);
2027         tmp3 = rcache_get_reg(SHR_MACL, RC_GR_WRITE);
2028         tmp4 = rcache_get_reg(SHR_MACH, RC_GR_WRITE);
2029         emith_mul_u64(tmp3, tmp4, tmp, tmp2);
2030         goto end_op;
2031       case 0x08: // SUB     Rm,Rn       0011nnnnmmmm1000
2032       case 0x0c: // ADD     Rm,Rn       0011nnnnmmmm1100
2033         tmp  = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2034         tmp2 = rcache_get_reg(GET_Rm(), RC_GR_READ);
2035         if (op & 4) {
2036           emith_add_r_r(tmp, tmp2);
2037         } else
2038           emith_sub_r_r(tmp, tmp2);
2039         goto end_op;
2040       case 0x0a: // SUBC    Rm,Rn       0011nnnnmmmm1010
2041       case 0x0e: // ADDC    Rm,Rn       0011nnnnmmmm1110
2042         tmp  = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2043         tmp2 = rcache_get_reg(GET_Rm(), RC_GR_READ);
2044         sr   = rcache_get_reg(SHR_SR, RC_GR_RMW);
2045         if (op & 4) { // adc
2046           emith_tpop_carry(sr, 0);
2047           emith_adcf_r_r(tmp, tmp2);
2048           emith_tpush_carry(sr, 0);
2049         } else {
2050           emith_tpop_carry(sr, 1);
2051           emith_sbcf_r_r(tmp, tmp2);
2052           emith_tpush_carry(sr, 1);
2053         }
2054         goto end_op;
2055       case 0x0b: // SUBV    Rm,Rn       0011nnnnmmmm1011
2056       case 0x0f: // ADDV    Rm,Rn       0011nnnnmmmm1111
2057         tmp  = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2058         tmp2 = rcache_get_reg(GET_Rm(), RC_GR_READ);
2059         sr   = rcache_get_reg(SHR_SR, RC_GR_RMW);
2060         emith_bic_r_imm(sr, T);
2061         if (op & 4) {
2062           emith_addf_r_r(tmp, tmp2);
2063         } else
2064           emith_subf_r_r(tmp, tmp2);
2065         EMITH_SJMP_START(DCOND_VC);
2066         emith_or_r_imm_c(DCOND_VS, sr, T);
2067         EMITH_SJMP_END(DCOND_VC);
2068         goto end_op;
2069       case 0x0d: // DMULS.L Rm,Rn       0011nnnnmmmm1101
2070         tmp  = rcache_get_reg(GET_Rn(), RC_GR_READ);
2071         tmp2 = rcache_get_reg(GET_Rm(), RC_GR_READ);
2072         tmp3 = rcache_get_reg(SHR_MACL, RC_GR_WRITE);
2073         tmp4 = rcache_get_reg(SHR_MACH, RC_GR_WRITE);
2074         emith_mul_s64(tmp3, tmp4, tmp, tmp2);
2075         goto end_op;
2076       }
2077       goto default_;
2078
2079     /////////////////////////////////////////////
2080     case 0x04:
2081       switch (op & 0x0f)
2082       {
2083       case 0x00:
2084         switch (GET_Fx())
2085         {
2086         case 0: // SHLL Rn    0100nnnn00000000
2087         case 2: // SHAL Rn    0100nnnn00100000
2088           tmp = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2089           sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
2090           emith_tpop_carry(sr, 0); // dummy
2091           emith_lslf(tmp, tmp, 1);
2092           emith_tpush_carry(sr, 0);
2093           goto end_op;
2094         case 1: // DT Rn      0100nnnn00010000
2095           sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
2096 #if 0 // scheduling needs tuning
2097           if (FETCH_OP(pc) == 0x8bfd) { // BF #-2
2098             if (gconst_get(GET_Rn(), &tmp)) {
2099               // XXX: limit burned cycles
2100               emit_move_r_imm32(GET_Rn(), 0);
2101               emith_or_r_imm(sr, T);
2102               cycles += tmp * 4 + 1; // +1 syncs with noconst version, not sure why
2103               skip_op = 1;
2104             }
2105             else
2106               emith_sh2_dtbf_loop();
2107             goto end_op;
2108           }
2109 #endif
2110           tmp = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2111           emith_bic_r_imm(sr, T);
2112           emith_subf_r_imm(tmp, 1);
2113           emit_or_t_if_eq(sr);
2114           goto end_op;
2115         }
2116         goto default_;
2117       case 0x01:
2118         switch (GET_Fx())
2119         {
2120         case 0: // SHLR Rn    0100nnnn00000001
2121         case 2: // SHAR Rn    0100nnnn00100001
2122           tmp = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2123           sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
2124           emith_tpop_carry(sr, 0); // dummy
2125           if (op & 0x20) {
2126             emith_asrf(tmp, tmp, 1);
2127           } else
2128             emith_lsrf(tmp, tmp, 1);
2129           emith_tpush_carry(sr, 0);
2130           goto end_op;
2131         case 1: // CMP/PZ Rn  0100nnnn00010001
2132           tmp = rcache_get_reg(GET_Rn(), RC_GR_READ);
2133           sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
2134           emith_bic_r_imm(sr, T);
2135           emith_cmp_r_imm(tmp, 0);
2136           EMITH_SJMP_START(DCOND_LT);
2137           emith_or_r_imm_c(DCOND_GE, sr, T);
2138           EMITH_SJMP_END(DCOND_LT);
2139           goto end_op;
2140         }
2141         goto default_;
2142       case 0x02:
2143       case 0x03:
2144         switch (op & 0x3f)
2145         {
2146         case 0x02: // STS.L    MACH,@-Rn 0100nnnn00000010
2147           tmp = SHR_MACH;
2148           break;
2149         case 0x12: // STS.L    MACL,@-Rn 0100nnnn00010010
2150           tmp = SHR_MACL;
2151           break;
2152         case 0x22: // STS.L    PR,@-Rn   0100nnnn00100010
2153           tmp = SHR_PR;
2154           break;
2155         case 0x03: // STC.L    SR,@-Rn   0100nnnn00000011
2156           tmp = SHR_SR;
2157           break;
2158         case 0x13: // STC.L    GBR,@-Rn  0100nnnn00010011
2159           tmp = SHR_GBR;
2160           break;
2161         case 0x23: // STC.L    VBR,@-Rn  0100nnnn00100011
2162           tmp = SHR_VBR;
2163           break;
2164         default:
2165           goto default_;
2166         }
2167         tmp2 = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2168         emith_sub_r_imm(tmp2, 4);
2169         rcache_clean();
2170         rcache_get_reg_arg(0, GET_Rn());
2171         tmp3 = rcache_get_reg_arg(1, tmp);
2172         if (tmp == SHR_SR)
2173           emith_clear_msb(tmp3, tmp3, 22); // reserved bits defined by ISA as 0
2174         emit_memhandler_write(2);
2175         goto end_op;
2176       case 0x04:
2177       case 0x05:
2178         switch (op & 0x3f)
2179         {
2180         case 0x04: // ROTL   Rn          0100nnnn00000100
2181         case 0x05: // ROTR   Rn          0100nnnn00000101
2182           tmp = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2183           sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
2184           emith_tpop_carry(sr, 0); // dummy
2185           if (op & 1) {
2186             emith_rorf(tmp, tmp, 1);
2187           } else
2188             emith_rolf(tmp, tmp, 1);
2189           emith_tpush_carry(sr, 0);
2190           goto end_op;
2191         case 0x24: // ROTCL  Rn          0100nnnn00100100
2192         case 0x25: // ROTCR  Rn          0100nnnn00100101
2193           tmp = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2194           sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
2195           emith_tpop_carry(sr, 0);
2196           if (op & 1) {
2197             emith_rorcf(tmp);
2198           } else
2199             emith_rolcf(tmp);
2200           emith_tpush_carry(sr, 0);
2201           goto end_op;
2202         case 0x15: // CMP/PL Rn          0100nnnn00010101
2203           tmp = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2204           sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
2205           emith_bic_r_imm(sr, T);
2206           emith_cmp_r_imm(tmp, 0);
2207           EMITH_SJMP_START(DCOND_LE);
2208           emith_or_r_imm_c(DCOND_GT, sr, T);
2209           EMITH_SJMP_END(DCOND_LE);
2210           goto end_op;
2211         }
2212         goto default_;
2213       case 0x06:
2214       case 0x07:
2215         switch (op & 0x3f)
2216         {
2217         case 0x06: // LDS.L @Rm+,MACH 0100mmmm00000110
2218           tmp = SHR_MACH;
2219           break;
2220         case 0x16: // LDS.L @Rm+,MACL 0100mmmm00010110
2221           tmp = SHR_MACL;
2222           break;
2223         case 0x26: // LDS.L @Rm+,PR   0100mmmm00100110
2224           tmp = SHR_PR;
2225           break;
2226         case 0x07: // LDC.L @Rm+,SR   0100mmmm00000111
2227           tmp = SHR_SR;
2228           break;
2229         case 0x17: // LDC.L @Rm+,GBR  0100mmmm00010111
2230           tmp = SHR_GBR;
2231           break;
2232         case 0x27: // LDC.L @Rm+,VBR  0100mmmm00100111
2233           tmp = SHR_VBR;
2234           break;
2235         default:
2236           goto default_;
2237         }
2238         rcache_get_reg_arg(0, GET_Rn());
2239         tmp2 = emit_memhandler_read(2);
2240         if (tmp == SHR_SR) {
2241           sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
2242           emith_write_sr(sr, tmp2);
2243           drcf.test_irq = 1;
2244         } else {
2245           tmp = rcache_get_reg(tmp, RC_GR_WRITE);
2246           emith_move_r_r(tmp, tmp2);
2247         }
2248         rcache_free_tmp(tmp2);
2249         tmp = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2250         emith_add_r_imm(tmp, 4);
2251         goto end_op;
2252       case 0x08:
2253       case 0x09:
2254         switch (GET_Fx())
2255         {
2256         case 0:
2257           // SHLL2 Rn        0100nnnn00001000
2258           // SHLR2 Rn        0100nnnn00001001
2259           tmp = 2;
2260           break;
2261         case 1:
2262           // SHLL8 Rn        0100nnnn00011000
2263           // SHLR8 Rn        0100nnnn00011001
2264           tmp = 8;
2265           break;
2266         case 2:
2267           // SHLL16 Rn       0100nnnn00101000
2268           // SHLR16 Rn       0100nnnn00101001
2269           tmp = 16;
2270           break;
2271         default:
2272           goto default_;
2273         }
2274         tmp2 = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2275         if (op & 1) {
2276           emith_lsr(tmp2, tmp2, tmp);
2277         } else
2278           emith_lsl(tmp2, tmp2, tmp);
2279         goto end_op;
2280       case 0x0a:
2281         switch (GET_Fx())
2282         {
2283         case 0: // LDS      Rm,MACH   0100mmmm00001010
2284           tmp2 = SHR_MACH;
2285           break;
2286         case 1: // LDS      Rm,MACL   0100mmmm00011010
2287           tmp2 = SHR_MACL;
2288           break;
2289         case 2: // LDS      Rm,PR     0100mmmm00101010
2290           tmp2 = SHR_PR;
2291           break;
2292         default:
2293           goto default_;
2294         }
2295         emit_move_r_r(tmp2, GET_Rn());
2296         goto end_op;
2297       case 0x0b:
2298         switch (GET_Fx())
2299         {
2300         case 1: // TAS.B @Rn  0100nnnn00011011
2301           // XXX: is TAS working on 32X?
2302           rcache_get_reg_arg(0, GET_Rn());
2303           tmp = emit_memhandler_read(0);
2304           sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
2305           emith_bic_r_imm(sr, T);
2306           emith_cmp_r_imm(tmp, 0);
2307           emit_or_t_if_eq(sr);
2308           rcache_clean();
2309           emith_or_r_imm(tmp, 0x80);
2310           tmp2 = rcache_get_tmp_arg(1); // assuming it differs to tmp
2311           emith_move_r_r(tmp2, tmp);
2312           rcache_free_tmp(tmp);
2313           rcache_get_reg_arg(0, GET_Rn());
2314           emit_memhandler_write(0);
2315           break;
2316         default:
2317           goto default_;
2318         }
2319         goto end_op;
2320       case 0x0e:
2321         tmp = rcache_get_reg(GET_Rn(), RC_GR_READ);
2322         switch (GET_Fx())
2323         {
2324         case 0: // LDC Rm,SR   0100mmmm00001110
2325           tmp2 = SHR_SR;
2326           break;
2327         case 1: // LDC Rm,GBR  0100mmmm00011110
2328           tmp2 = SHR_GBR;
2329           break;
2330         case 2: // LDC Rm,VBR  0100mmmm00101110
2331           tmp2 = SHR_VBR;
2332           break;
2333         default:
2334           goto default_;
2335         }
2336         if (tmp2 == SHR_SR) {
2337           sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
2338           emith_write_sr(sr, tmp);
2339           drcf.test_irq = 1;
2340         } else {
2341           tmp2 = rcache_get_reg(tmp2, RC_GR_WRITE);
2342           emith_move_r_r(tmp2, tmp);
2343         }
2344         goto end_op;
2345       case 0x0f:
2346         // MAC.W @Rm+,@Rn+  0100nnnnmmmm1111
2347         emit_indirect_read_double(&tmp, &tmp2, GET_Rn(), GET_Rm(), 1);
2348         emith_sext(tmp, tmp, 16);
2349         emith_sext(tmp2, tmp2, 16);
2350         tmp3 = rcache_get_reg(SHR_MACL, RC_GR_RMW);
2351         tmp4 = rcache_get_reg(SHR_MACH, RC_GR_RMW);
2352         emith_mula_s64(tmp3, tmp4, tmp, tmp2);
2353         rcache_free_tmp(tmp2);
2354         // XXX: MACH should be untouched when S is set?
2355         sr = rcache_get_reg(SHR_SR, RC_GR_READ);
2356         emith_tst_r_imm(sr, S);
2357         EMITH_JMP_START(DCOND_EQ);
2358
2359         emith_asr(tmp, tmp3, 31);
2360         emith_eorf_r_r(tmp, tmp4); // tmp = ((signed)macl >> 31) ^ mach
2361         EMITH_JMP_START(DCOND_EQ);
2362         emith_move_r_imm(tmp3, 0x80000000);
2363         emith_tst_r_r(tmp4, tmp4);
2364         EMITH_SJMP_START(DCOND_MI);
2365         emith_sub_r_imm_c(DCOND_PL, tmp3, 1); // positive
2366         EMITH_SJMP_END(DCOND_MI);
2367         EMITH_JMP_END(DCOND_EQ);
2368
2369         EMITH_JMP_END(DCOND_EQ);
2370         rcache_free_tmp(tmp);
2371         goto end_op;
2372       }
2373       goto default_;
2374
2375     /////////////////////////////////////////////
2376     case 0x05:
2377       // MOV.L @(disp,Rm),Rn 0101nnnnmmmmdddd
2378       emit_memhandler_read_rr(GET_Rn(), GET_Rm(), (op & 0x0f) * 4, 2);
2379       goto end_op;
2380
2381     /////////////////////////////////////////////
2382     case 0x06:
2383       switch (op & 0x0f)
2384       {
2385       case 0x00: // MOV.B @Rm,Rn        0110nnnnmmmm0000
2386       case 0x01: // MOV.W @Rm,Rn        0110nnnnmmmm0001
2387       case 0x02: // MOV.L @Rm,Rn        0110nnnnmmmm0010
2388       case 0x04: // MOV.B @Rm+,Rn       0110nnnnmmmm0100
2389       case 0x05: // MOV.W @Rm+,Rn       0110nnnnmmmm0101
2390       case 0x06: // MOV.L @Rm+,Rn       0110nnnnmmmm0110
2391         emit_memhandler_read_rr(GET_Rn(), GET_Rm(), 0, op & 3);
2392         if ((op & 7) >= 4 && GET_Rn() != GET_Rm()) {
2393           tmp = rcache_get_reg(GET_Rm(), RC_GR_RMW);
2394           emith_add_r_imm(tmp, (1 << (op & 3)));
2395         }
2396         goto end_op;
2397       case 0x03:
2398       case 0x07 ... 0x0f:
2399         tmp  = rcache_get_reg(GET_Rm(), RC_GR_READ);
2400         tmp2 = rcache_get_reg(GET_Rn(), RC_GR_WRITE);
2401         switch (op & 0x0f)
2402         {
2403         case 0x03: // MOV    Rm,Rn        0110nnnnmmmm0011
2404           emith_move_r_r(tmp2, tmp);
2405           break;
2406         case 0x07: // NOT    Rm,Rn        0110nnnnmmmm0111
2407           emith_mvn_r_r(tmp2, tmp);
2408           break;
2409         case 0x08: // SWAP.B Rm,Rn        0110nnnnmmmm1000
2410           tmp3 = tmp2;
2411           if (tmp == tmp2)
2412             tmp3 = rcache_get_tmp();
2413           tmp4 = rcache_get_tmp();
2414           emith_lsr(tmp3, tmp, 16);
2415           emith_or_r_r_lsl(tmp3, tmp, 24);
2416           emith_and_r_r_imm(tmp4, tmp, 0xff00);
2417           emith_or_r_r_lsl(tmp3, tmp4, 8);
2418           emith_rol(tmp2, tmp3, 16);
2419           rcache_free_tmp(tmp4);
2420           if (tmp == tmp2)
2421             rcache_free_tmp(tmp3);
2422           break;
2423         case 0x09: // SWAP.W Rm,Rn        0110nnnnmmmm1001
2424           emith_rol(tmp2, tmp, 16);
2425           break;
2426         case 0x0a: // NEGC   Rm,Rn        0110nnnnmmmm1010
2427           sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
2428           emith_tpop_carry(sr, 1);
2429           emith_negcf_r_r(tmp2, tmp);
2430           emith_tpush_carry(sr, 1);
2431           break;
2432         case 0x0b: // NEG    Rm,Rn        0110nnnnmmmm1011
2433           emith_neg_r_r(tmp2, tmp);
2434           break;
2435         case 0x0c: // EXTU.B Rm,Rn        0110nnnnmmmm1100
2436           emith_clear_msb(tmp2, tmp, 24);
2437           break;
2438         case 0x0d: // EXTU.W Rm,Rn        0110nnnnmmmm1101
2439           emith_clear_msb(tmp2, tmp, 16);
2440           break;
2441         case 0x0e: // EXTS.B Rm,Rn        0110nnnnmmmm1110
2442           emith_sext(tmp2, tmp, 8);
2443           break;
2444         case 0x0f: // EXTS.W Rm,Rn        0110nnnnmmmm1111
2445           emith_sext(tmp2, tmp, 16);
2446           break;
2447         }
2448         goto end_op;
2449       }
2450       goto default_;
2451
2452     /////////////////////////////////////////////
2453     case 0x07:
2454       // ADD #imm,Rn  0111nnnniiiiiiii
2455       tmp = rcache_get_reg(GET_Rn(), RC_GR_RMW);
2456       if (op & 0x80) { // adding negative
2457         emith_sub_r_imm(tmp, -op & 0xff);
2458       } else
2459         emith_add_r_imm(tmp, op & 0xff);
2460       goto end_op;
2461
2462     /////////////////////////////////////////////
2463     case 0x08:
2464       switch (op & 0x0f00)
2465       {
2466       case 0x0000: // MOV.B R0,@(disp,Rn)  10000000nnnndddd
2467       case 0x0100: // MOV.W R0,@(disp,Rn)  10000001nnnndddd
2468         rcache_clean();
2469         tmp  = rcache_get_reg_arg(0, GET_Rm());
2470         tmp2 = rcache_get_reg_arg(1, SHR_R0);
2471         tmp3 = (op & 0x100) >> 8;
2472         if (op & 0x0f)
2473           emith_add_r_imm(tmp, (op & 0x0f) << tmp3);
2474         emit_memhandler_write(tmp3);
2475         goto end_op;
2476       case 0x0400: // MOV.B @(disp,Rm),R0  10000100mmmmdddd
2477       case 0x0500: // MOV.W @(disp,Rm),R0  10000101mmmmdddd
2478         tmp = (op & 0x100) >> 8;
2479         emit_memhandler_read_rr(SHR_R0, GET_Rm(), (op & 0x0f) << tmp, tmp);
2480         goto end_op;
2481       case 0x0800: // CMP/EQ #imm,R0       10001000iiiiiiii
2482         // XXX: could use cmn
2483         tmp  = rcache_get_tmp();
2484         tmp2 = rcache_get_reg(0, RC_GR_READ);
2485         sr   = rcache_get_reg(SHR_SR, RC_GR_RMW);
2486         emith_move_r_imm_s8(tmp, op & 0xff);
2487         emith_bic_r_imm(sr, T);
2488         emith_cmp_r_r(tmp2, tmp);
2489         emit_or_t_if_eq(sr);
2490         rcache_free_tmp(tmp);
2491         goto end_op;
2492       }
2493       goto default_;
2494
2495     /////////////////////////////////////////////
2496     case 0x0c:
2497       switch (op & 0x0f00)
2498       {
2499       case 0x0000: // MOV.B R0,@(disp,GBR)   11000000dddddddd
2500       case 0x0100: // MOV.W R0,@(disp,GBR)   11000001dddddddd
2501       case 0x0200: // MOV.L R0,@(disp,GBR)   11000010dddddddd
2502         rcache_clean();
2503         tmp  = rcache_get_reg_arg(0, SHR_GBR);
2504         tmp2 = rcache_get_reg_arg(1, SHR_R0);
2505         tmp3 = (op & 0x300) >> 8;
2506         emith_add_r_imm(tmp, (op & 0xff) << tmp3);
2507         emit_memhandler_write(tmp3);
2508         goto end_op;
2509       case 0x0400: // MOV.B @(disp,GBR),R0   11000100dddddddd
2510       case 0x0500: // MOV.W @(disp,GBR),R0   11000101dddddddd
2511       case 0x0600: // MOV.L @(disp,GBR),R0   11000110dddddddd
2512         tmp = (op & 0x300) >> 8;
2513         emit_memhandler_read_rr(SHR_R0, SHR_GBR, (op & 0xff) << tmp, tmp);
2514         goto end_op;
2515       case 0x0300: // TRAPA #imm      11000011iiiiiiii
2516         tmp = rcache_get_reg(SHR_SP, RC_GR_RMW);
2517         emith_sub_r_imm(tmp, 4*2);
2518         // push SR
2519         tmp = rcache_get_reg_arg(0, SHR_SP);
2520         emith_add_r_imm(tmp, 4);
2521         tmp = rcache_get_reg_arg(1, SHR_SR);
2522         emith_clear_msb(tmp, tmp, 22);
2523         emit_memhandler_write(2);
2524         // push PC
2525         rcache_get_reg_arg(0, SHR_SP);
2526         tmp = rcache_get_tmp_arg(1);
2527         emith_move_r_imm(tmp, pc);
2528         emit_memhandler_write(2);
2529         // obtain new PC
2530         emit_memhandler_read_rr(SHR_PC, SHR_VBR, (op & 0xff) * 4, 2);
2531         // indirect jump -> back to dispatcher
2532         rcache_flush();
2533         emith_jump(sh2_drc_dispatcher);
2534         goto end_op;
2535       case 0x0800: // TST #imm,R0           11001000iiiiiiii
2536         tmp = rcache_get_reg(SHR_R0, RC_GR_READ);
2537         sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
2538         emith_bic_r_imm(sr, T);
2539         emith_tst_r_imm(tmp, op & 0xff);
2540         emit_or_t_if_eq(sr);
2541         goto end_op;
2542       case 0x0900: // AND #imm,R0           11001001iiiiiiii
2543         tmp = rcache_get_reg(SHR_R0, RC_GR_RMW);
2544         emith_and_r_imm(tmp, op & 0xff);
2545         goto end_op;
2546       case 0x0a00: // XOR #imm,R0           11001010iiiiiiii
2547         tmp = rcache_get_reg(SHR_R0, RC_GR_RMW);
2548         emith_eor_r_imm(tmp, op & 0xff);
2549         goto end_op;
2550       case 0x0b00: // OR  #imm,R0           11001011iiiiiiii
2551         tmp = rcache_get_reg(SHR_R0, RC_GR_RMW);
2552         emith_or_r_imm(tmp, op & 0xff);
2553         goto end_op;
2554       case 0x0c00: // TST.B #imm,@(R0,GBR)  11001100iiiiiiii
2555         tmp = emit_indirect_indexed_read(SHR_R0, SHR_GBR, 0);
2556         sr  = rcache_get_reg(SHR_SR, RC_GR_RMW);
2557         emith_bic_r_imm(sr, T);
2558         emith_tst_r_imm(tmp, op & 0xff);
2559         emit_or_t_if_eq(sr);
2560         rcache_free_tmp(tmp);
2561         goto end_op;
2562       case 0x0d00: // AND.B #imm,@(R0,GBR)  11001101iiiiiiii
2563         tmp = emit_indirect_indexed_read(SHR_R0, SHR_GBR, 0);
2564         emith_and_r_imm(tmp, op & 0xff);
2565         goto end_rmw_op;
2566       case 0x0e00: // XOR.B #imm,@(R0,GBR)  11001110iiiiiiii
2567         tmp = emit_indirect_indexed_read(SHR_R0, SHR_GBR, 0);
2568         emith_eor_r_imm(tmp, op & 0xff);
2569         goto end_rmw_op;
2570       case 0x0f00: // OR.B  #imm,@(R0,GBR)  11001111iiiiiiii
2571         tmp = emit_indirect_indexed_read(SHR_R0, SHR_GBR, 0);
2572         emith_or_r_imm(tmp, op & 0xff);
2573       end_rmw_op:
2574         tmp2 = rcache_get_tmp_arg(1);
2575         emith_move_r_r(tmp2, tmp);
2576         rcache_free_tmp(tmp);
2577         tmp3 = rcache_get_reg_arg(0, SHR_GBR);
2578         tmp4 = rcache_get_reg(SHR_R0, RC_GR_READ);
2579         emith_add_r_r(tmp3, tmp4);
2580         emit_memhandler_write(0);
2581         goto end_op;
2582       }
2583       goto default_;
2584
2585     /////////////////////////////////////////////
2586     case 0x0e:
2587       // MOV #imm,Rn   1110nnnniiiiiiii
2588       emit_move_r_imm32(GET_Rn(), (u32)(signed int)(signed char)op);
2589       goto end_op;
2590
2591     default:
2592     default_:
2593       elprintf_sh2(sh2, EL_ANOMALY,
2594         "drc: illegal op %04x @ %08x", op, pc - 2);
2595
2596       tmp = rcache_get_reg(SHR_SP, RC_GR_RMW);
2597       emith_sub_r_imm(tmp, 4*2);
2598       // push SR
2599       tmp = rcache_get_reg_arg(0, SHR_SP);
2600       emith_add_r_imm(tmp, 4);
2601       tmp = rcache_get_reg_arg(1, SHR_SR);
2602       emith_clear_msb(tmp, tmp, 22);
2603       emit_memhandler_write(2);
2604       // push PC
2605       rcache_get_reg_arg(0, SHR_SP);
2606       tmp = rcache_get_tmp_arg(1);
2607       emith_move_r_imm(tmp, pc - 2);
2608       emit_memhandler_write(2);
2609       // obtain new PC
2610       emit_memhandler_read_rr(SHR_PC, SHR_VBR, 4 * 4, 2);
2611       // indirect jump -> back to dispatcher
2612       rcache_flush();
2613       emith_jump(sh2_drc_dispatcher);
2614       break;
2615     }
2616
2617 end_op:
2618     rcache_unlock_all();
2619
2620     cycles += opd->cycles;
2621
2622     if (op_flags[i+1] & OF_DELAY_OP) {
2623       do_host_disasm(tcache_id);
2624       continue;
2625     }
2626
2627     // test irq?
2628     if (drcf.test_irq && !drcf.pending_branch_direct) {
2629       sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
2630       FLUSH_CYCLES(sr);
2631       if (!drcf.pending_branch_indirect)
2632         emit_move_r_imm32(SHR_PC, pc);
2633       rcache_flush();
2634       emith_call(sh2_drc_test_irq);
2635       drcf.test_irq = 0;
2636     }
2637
2638     // branch handling (with/without delay)
2639     if (drcf.pending_branch_direct)
2640     {
2641       struct op_data *opd_b =
2642         (op_flags[i] & OF_DELAY_OP) ? &ops[i-1] : opd;
2643       u32 target_pc = opd_b->imm;
2644       int cond = -1;
2645       void *target = NULL;
2646
2647       sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
2648       FLUSH_CYCLES(sr);
2649
2650       if (opd_b->op != OP_BRANCH)
2651         cond = (opd_b->op == OP_BRANCH_CF) ? DCOND_EQ : DCOND_NE;
2652       if (cond != -1) {
2653         int ctaken = (op_flags[i] & OF_DELAY_OP) ? 1 : 2;
2654
2655         if (delay_dep_fw & BITMASK1(SHR_T))
2656           emith_tst_r_imm(sr, T_save);
2657         else
2658           emith_tst_r_imm(sr, T);
2659
2660         emith_sub_r_imm_c(cond, sr, ctaken<<12);
2661       }
2662       rcache_clean();
2663
2664 #if LINK_BRANCHES
2665       if (find_in_array(branch_target_pc, branch_target_count, target_pc) >= 0)
2666       {
2667         // local branch
2668         // XXX: jumps back can be linked already
2669         if (branch_patch_count < MAX_LOCAL_BRANCHES) {
2670           target = tcache_ptr;
2671           branch_patch_pc[branch_patch_count] = target_pc;
2672           branch_patch_ptr[branch_patch_count] = target;
2673           branch_patch_count++;
2674         }
2675         else
2676           dbg(1, "warning: too many local branches");
2677       }
2678
2679       if (target == NULL)
2680 #endif
2681       {
2682         // can't resolve branch locally, make a block exit
2683         emit_move_r_imm32(SHR_PC, target_pc);
2684         rcache_clean();
2685
2686         target = dr_prepare_ext_branch(target_pc, sh2->is_slave, tcache_id);
2687         if (target == NULL)
2688           return NULL;
2689       }
2690
2691       if (cond != -1)
2692         emith_jump_cond_patchable(cond, target);
2693       else {
2694         emith_jump_patchable(target);
2695         rcache_invalidate();
2696       }
2697
2698       drcf.pending_branch_direct = 0;
2699     }
2700     else if (drcf.pending_branch_indirect) {
2701       sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
2702       FLUSH_CYCLES(sr);
2703       rcache_flush();
2704       emith_jump(sh2_drc_dispatcher);
2705       drcf.pending_branch_indirect = 0;
2706     }
2707
2708     do_host_disasm(tcache_id);
2709   }
2710
2711   tmp = rcache_get_reg(SHR_SR, RC_GR_RMW);
2712   FLUSH_CYCLES(tmp);
2713   rcache_flush();
2714
2715   // check the last op
2716   if (op_flags[i-1] & OF_DELAY_OP)
2717     opd = &ops[i-2];
2718   else
2719     opd = &ops[i-1];
2720
2721   if (opd->op != OP_BRANCH && opd->op != OP_BRANCH_R
2722       && opd->op != OP_BRANCH_RF && opd->op != OP_RTE)
2723   {
2724     void *target;
2725
2726     emit_move_r_imm32(SHR_PC, pc);
2727     rcache_flush();
2728
2729     target = dr_prepare_ext_branch(pc, sh2->is_slave, tcache_id);
2730     if (target == NULL)
2731       return NULL;
2732     emith_jump_patchable(target);
2733   }
2734
2735   // link local branches
2736   for (i = 0; i < branch_patch_count; i++) {
2737     void *target;
2738     int t;
2739     t = find_in_array(branch_target_pc, branch_target_count, branch_patch_pc[i]);
2740     target = branch_target_ptr[t];
2741     if (target == NULL) {
2742       // flush pc and go back to dispatcher (this should no longer happen)
2743       dbg(1, "stray branch to %08x %p", branch_patch_pc[i], tcache_ptr);
2744       target = tcache_ptr;
2745       emit_move_r_imm32(SHR_PC, branch_patch_pc[i]);
2746       rcache_flush();
2747       emith_jump(sh2_drc_dispatcher);
2748     }
2749     emith_jump_patch(branch_patch_ptr[i], target);
2750   }
2751
2752   // mark memory blocks as containing compiled code
2753   // override any overlay blocks as they become unreachable anyway
2754   if ((block->addr & 0xc7fc0000) == 0x06000000
2755       || (block->addr & 0xfffff000) == 0xc0000000)
2756   {
2757     u16 *drc_ram_blk = NULL;
2758     u32 addr, mask = 0, shift = 0;
2759
2760     if (tcache_id != 0) {
2761       // data array, BIOS
2762       drc_ram_blk = Pico32xMem->drcblk_da[sh2->is_slave];
2763       shift = SH2_DRCBLK_DA_SHIFT;
2764       mask = 0xfff;
2765     }
2766     else {
2767       // SDRAM
2768       drc_ram_blk = Pico32xMem->drcblk_ram;
2769       shift = SH2_DRCBLK_RAM_SHIFT;
2770       mask = 0x3ffff;
2771     }
2772
2773     // mark recompiled insns
2774     drc_ram_blk[(base_pc & mask) >> shift] = 1;
2775     for (pc = base_pc; pc < end_pc; pc += 2)
2776       drc_ram_blk[(pc & mask) >> shift] = 1;
2777
2778     // mark literals
2779     for (i = 0; i < literal_addr_count; i++) {
2780       tmp = literal_addr[i];
2781       drc_ram_blk[(tmp & mask) >> shift] = 1;
2782     }
2783
2784     // add to invalidation lookup lists
2785     addr = base_pc & ~(INVAL_PAGE_SIZE - 1);
2786     for (; addr < end_literals; addr += INVAL_PAGE_SIZE) {
2787       i = (addr & mask) / INVAL_PAGE_SIZE;
2788       add_to_block_list(&inval_lookup[tcache_id][i], block);
2789     }
2790   }
2791
2792   tcache_ptrs[tcache_id] = tcache_ptr;
2793
2794   host_instructions_updated(block_entry_ptr, tcache_ptr);
2795
2796   do_host_disasm(tcache_id);
2797
2798   if (drcf.literals_disabled && literal_addr_count)
2799     dbg(1, "literals_disabled && literal_addr_count?");
2800   dbg(2, " block #%d,%d tcache %d/%d, insns %d -> %d %.3f",
2801     tcache_id, blkid_main,
2802     tcache_ptr - tcache_bases[tcache_id], tcache_sizes[tcache_id],
2803     insns_compiled, host_insn_count, (float)host_insn_count / insns_compiled);
2804   if ((sh2->pc & 0xc6000000) == 0x02000000) // ROM
2805     dbg(2, "  hash collisions %d/%d", hash_collisions, block_counts[tcache_id]);
2806 /*
2807  printf("~~~\n");
2808  tcache_dsm_ptrs[tcache_id] = block_entry_ptr;
2809  do_host_disasm(tcache_id);
2810  printf("~~~\n");
2811 */
2812
2813 #if (DRC_DEBUG & 4)
2814   fflush(stdout);
2815 #endif
2816
2817   return block_entry_ptr;
2818 }
2819
2820 static void sh2_generate_utils(void)
2821 {
2822   int arg0, arg1, arg2, sr, tmp;
2823
2824   sh2_drc_write32 = p32x_sh2_write32;
2825   sh2_drc_read8  = p32x_sh2_read8;
2826   sh2_drc_read16 = p32x_sh2_read16;
2827   sh2_drc_read32 = p32x_sh2_read32;
2828
2829   host_arg2reg(arg0, 0);
2830   host_arg2reg(arg1, 1);
2831   host_arg2reg(arg2, 2);
2832   emith_move_r_r(arg0, arg0); // nop
2833
2834   // sh2_drc_exit(void)
2835   sh2_drc_exit = (void *)tcache_ptr;
2836   emit_do_static_regs(1, arg2);
2837   emith_sh2_drc_exit();
2838
2839   // sh2_drc_dispatcher(void)
2840   sh2_drc_dispatcher = (void *)tcache_ptr;
2841   sr = rcache_get_reg(SHR_SR, RC_GR_READ);
2842   emith_cmp_r_imm(sr, 0);
2843   emith_jump_cond(DCOND_LT, sh2_drc_exit);
2844   rcache_invalidate();
2845   emith_ctx_read(arg0, SHR_PC * 4);
2846   emith_ctx_read(arg1, offsetof(SH2, is_slave));
2847   emith_add_r_r_imm(arg2, CONTEXT_REG, offsetof(SH2, drc_tmp));
2848   emith_call(dr_lookup_block);
2849   emit_block_entry();
2850   // lookup failed, call sh2_translate()
2851   emith_move_r_r(arg0, CONTEXT_REG);
2852   emith_ctx_read(arg1, offsetof(SH2, drc_tmp)); // tcache_id
2853   emith_call(sh2_translate);
2854   emit_block_entry();
2855   // sh2_translate() failed, flush cache and retry
2856   emith_ctx_read(arg0, offsetof(SH2, drc_tmp));
2857   emith_call(flush_tcache);
2858   emith_move_r_r(arg0, CONTEXT_REG);
2859   emith_ctx_read(arg1, offsetof(SH2, drc_tmp));
2860   emith_call(sh2_translate);
2861   emit_block_entry();
2862   // XXX: can't translate, fail
2863   emith_call(dr_failure);
2864
2865   // sh2_drc_test_irq(void)
2866   // assumes it's called from main function (may jump to dispatcher)
2867   sh2_drc_test_irq = (void *)tcache_ptr;
2868   emith_ctx_read(arg1, offsetof(SH2, pending_level));
2869   sr = rcache_get_reg(SHR_SR, RC_GR_READ);
2870   emith_lsr(arg0, sr, I_SHIFT);
2871   emith_and_r_imm(arg0, 0x0f);
2872   emith_cmp_r_r(arg1, arg0); // pending_level > ((sr >> 4) & 0x0f)?
2873   EMITH_SJMP_START(DCOND_GT);
2874   emith_ret_c(DCOND_LE);     // nope, return
2875   EMITH_SJMP_END(DCOND_GT);
2876   // adjust SP
2877   tmp = rcache_get_reg(SHR_SP, RC_GR_RMW);
2878   emith_sub_r_imm(tmp, 4*2);
2879   rcache_clean();
2880   // push SR
2881   tmp = rcache_get_reg_arg(0, SHR_SP);
2882   emith_add_r_imm(tmp, 4);
2883   tmp = rcache_get_reg_arg(1, SHR_SR);
2884   emith_clear_msb(tmp, tmp, 22);
2885   emith_move_r_r(arg2, CONTEXT_REG);
2886   emith_call(p32x_sh2_write32); // XXX: use sh2_drc_write32?
2887   rcache_invalidate();
2888   // push PC
2889   rcache_get_reg_arg(0, SHR_SP);
2890   emith_ctx_read(arg1, SHR_PC * 4);
2891   emith_move_r_r(arg2, CONTEXT_REG);
2892   emith_call(p32x_sh2_write32);
2893   rcache_invalidate();
2894   // update I, cycles, do callback
2895   emith_ctx_read(arg1, offsetof(SH2, pending_level));
2896   sr = rcache_get_reg(SHR_SR, RC_GR_RMW);
2897   emith_bic_r_imm(sr, I);
2898   emith_or_r_r_lsl(sr, arg1, I_SHIFT);
2899   emith_sub_r_imm(sr, 13 << 12); // at least 13 cycles
2900   rcache_flush();
2901   emith_move_r_r(arg0, CONTEXT_REG);
2902   emith_call_ctx(offsetof(SH2, irq_callback)); // vector = sh2->irq_callback(sh2, level);
2903   // obtain new PC
2904   emith_lsl(arg0, arg0, 2);
2905   emith_ctx_read(arg1, SHR_VBR * 4);
2906   emith_add_r_r(arg0, arg1);
2907   emit_memhandler_read(2);
2908   emith_ctx_write(arg0, SHR_PC * 4);
2909 #ifdef __i386__
2910   emith_add_r_imm(xSP, 4); // fix stack
2911 #endif
2912   emith_jump(sh2_drc_dispatcher);
2913   rcache_invalidate();
2914
2915   // sh2_drc_entry(SH2 *sh2)
2916   sh2_drc_entry = (void *)tcache_ptr;
2917   emith_sh2_drc_entry();
2918   emith_move_r_r(CONTEXT_REG, arg0); // move ctx, arg0
2919   emit_do_static_regs(0, arg2);
2920   emith_call(sh2_drc_test_irq);
2921   emith_jump(sh2_drc_dispatcher);
2922
2923   // sh2_drc_write8(u32 a, u32 d)
2924   sh2_drc_write8 = (void *)tcache_ptr;
2925   emith_ctx_read(arg2, offsetof(SH2, write8_tab));
2926   emith_sh2_wcall(arg0, arg2);
2927
2928   // sh2_drc_write16(u32 a, u32 d)
2929   sh2_drc_write16 = (void *)tcache_ptr;
2930   emith_ctx_read(arg2, offsetof(SH2, write16_tab));
2931   emith_sh2_wcall(arg0, arg2);
2932
2933 #ifdef PDB_NET
2934   // debug
2935   #define MAKE_READ_WRAPPER(func) { \
2936     void *tmp = (void *)tcache_ptr; \
2937     emith_push_ret(); \
2938     emith_call(func); \
2939     emith_ctx_read(arg2, offsetof(SH2, pdb_io_csum[0]));  \
2940     emith_addf_r_r(arg2, arg0);                           \
2941     emith_ctx_write(arg2, offsetof(SH2, pdb_io_csum[0])); \
2942     emith_ctx_read(arg2, offsetof(SH2, pdb_io_csum[1]));  \
2943     emith_adc_r_imm(arg2, 0x01000000);                    \
2944     emith_ctx_write(arg2, offsetof(SH2, pdb_io_csum[1])); \
2945     emith_pop_and_ret(); \
2946     func = tmp; \
2947   }
2948   #define MAKE_WRITE_WRAPPER(func) { \
2949     void *tmp = (void *)tcache_ptr; \
2950     emith_ctx_read(arg2, offsetof(SH2, pdb_io_csum[0]));  \
2951     emith_addf_r_r(arg2, arg1);                           \
2952     emith_ctx_write(arg2, offsetof(SH2, pdb_io_csum[0])); \
2953     emith_ctx_read(arg2, offsetof(SH2, pdb_io_csum[1]));  \
2954     emith_adc_r_imm(arg2, 0x01000000);                    \
2955     emith_ctx_write(arg2, offsetof(SH2, pdb_io_csum[1])); \
2956     emith_move_r_r(arg2, CONTEXT_REG);                    \
2957     emith_jump(func); \
2958     func = tmp; \
2959   }
2960
2961   MAKE_READ_WRAPPER(sh2_drc_read8);
2962   MAKE_READ_WRAPPER(sh2_drc_read16);
2963   MAKE_READ_WRAPPER(sh2_drc_read32);
2964   MAKE_WRITE_WRAPPER(sh2_drc_write8);
2965   MAKE_WRITE_WRAPPER(sh2_drc_write16);
2966   MAKE_WRITE_WRAPPER(sh2_drc_write32);
2967 #if (DRC_DEBUG & 4)
2968   host_dasm_new_symbol(sh2_drc_read8);
2969   host_dasm_new_symbol(sh2_drc_read16);
2970   host_dasm_new_symbol(sh2_drc_read32);
2971   host_dasm_new_symbol(sh2_drc_write32);
2972 #endif
2973 #endif
2974
2975   rcache_invalidate();
2976 #if (DRC_DEBUG & 4)
2977   host_dasm_new_symbol(sh2_drc_entry);
2978   host_dasm_new_symbol(sh2_drc_dispatcher);
2979   host_dasm_new_symbol(sh2_drc_exit);
2980   host_dasm_new_symbol(sh2_drc_test_irq);
2981   host_dasm_new_symbol(sh2_drc_write8);
2982   host_dasm_new_symbol(sh2_drc_write16);
2983 #endif
2984 }
2985
2986 static void sh2_smc_rm_block_entry(struct block_desc *bd, int tcache_id, u32 ram_mask)
2987 {
2988   struct block_link *bl, *bl_next, *bl_unresolved;
2989   u32 i, addr, end_addr;
2990   void *tmp;
2991
2992   dbg(2, "  killing entry %08x-%08x-%08x, blkid %d,%d",
2993     bd->addr, bd->addr + bd->size_nolit, bd->addr + bd->size,
2994     tcache_id, bd - block_tables[tcache_id]);
2995   if (bd->addr == 0 || bd->entry_count == 0) {
2996     dbg(1, "  killing dead block!? %08x", bd->addr);
2997     return;
2998   }
2999
3000   // remove from inval_lookup
3001   addr = bd->addr & ~(INVAL_PAGE_SIZE - 1);
3002   end_addr = bd->addr + bd->size;
3003   for (; addr < end_addr; addr += INVAL_PAGE_SIZE) {
3004     i = (addr & ram_mask) / INVAL_PAGE_SIZE;
3005     rm_from_block_list(&inval_lookup[tcache_id][i], bd);
3006   }
3007
3008   tmp = tcache_ptr;
3009   bl_unresolved = unresolved_links[tcache_id];
3010
3011   // remove from hash table, make incoming links unresolved
3012   // XXX: maybe patch branches w/flush instead?
3013   for (i = 0; i < bd->entry_count; i++) {
3014     rm_from_hashlist(&bd->entryp[i], tcache_id);
3015
3016     // since we never reuse tcache space of dead blocks,
3017     // insert jump to dispatcher for blocks that are linked to this
3018     tcache_ptr = bd->entryp[i].tcache_ptr;
3019     emit_move_r_imm32(SHR_PC, bd->entryp[i].pc);
3020     rcache_flush();
3021     emith_jump(sh2_drc_dispatcher);
3022
3023     host_instructions_updated(bd->entryp[i].tcache_ptr, tcache_ptr);
3024
3025     for (bl = bd->entryp[i].links; bl != NULL; ) {
3026       bl_next = bl->next;
3027       bl->next = bl_unresolved;
3028       bl_unresolved = bl;
3029       bl = bl_next;
3030     }
3031   }
3032
3033   tcache_ptr = tmp;
3034   unresolved_links[tcache_id] = bl_unresolved;
3035
3036   bd->addr = bd->size = bd->size_nolit = 0;
3037   bd->entry_count = 0;
3038 }
3039
3040 static void sh2_smc_rm_block(u32 a, u16 *drc_ram_blk, int tcache_id, u32 shift, u32 mask)
3041 {
3042   struct block_list **blist = NULL, *entry;
3043   u32 from = ~0, to = 0, end_addr, taddr, i;
3044   struct block_desc *block;
3045
3046   blist = &inval_lookup[tcache_id][(a & mask) / INVAL_PAGE_SIZE];
3047   entry = *blist;
3048   while (entry != NULL) {
3049     block = entry->block;
3050     end_addr = block->addr + block->size;
3051     if (block->addr <= a && a < end_addr) {
3052       // get addr range that includes all removed blocks
3053       if (from > block->addr)
3054         from = block->addr;
3055       if (to < end_addr)
3056         to = end_addr;
3057
3058       sh2_smc_rm_block_entry(block, tcache_id, mask);
3059       if (a >= block->addr + block->size_nolit)
3060         literal_disabled_frames = 3;
3061
3062       // entry lost, restart search
3063       entry = *blist;
3064       continue;
3065     }
3066     entry = entry->next;
3067   }
3068
3069   if (from >= to)
3070     return;
3071
3072   // update range around a to match latest state
3073   from &= ~(INVAL_PAGE_SIZE - 1);
3074   to |= (INVAL_PAGE_SIZE - 1);
3075   for (taddr = from; taddr < to; taddr += INVAL_PAGE_SIZE) {
3076     i = (taddr & mask) / INVAL_PAGE_SIZE;
3077     entry = inval_lookup[tcache_id][i];
3078
3079     for (; entry != NULL; entry = entry->next) {
3080       block = entry->block;
3081
3082       if (block->addr > a) {
3083         if (to > block->addr)
3084           to = block->addr;
3085       }
3086       else {
3087         end_addr = block->addr + block->size;
3088         if (from < end_addr)
3089           from = end_addr;
3090       }
3091     }
3092   }
3093
3094   // clear code marks
3095   if (from < to) {
3096     u16 *p = drc_ram_blk + ((from & mask) >> shift);
3097     memset(p, 0, (to - from) >> (shift - 1));
3098   }
3099 }
3100
3101 void sh2_drc_wcheck_ram(unsigned int a, int val, int cpuid)
3102 {
3103   dbg(2, "%csh2 smc check @%08x", cpuid ? 's' : 'm', a);
3104   sh2_smc_rm_block(a, Pico32xMem->drcblk_ram, 0, SH2_DRCBLK_RAM_SHIFT, 0x3ffff);
3105 }
3106
3107 void sh2_drc_wcheck_da(unsigned int a, int val, int cpuid)
3108 {
3109   dbg(2, "%csh2 smc check @%08x", cpuid ? 's' : 'm', a);
3110   sh2_smc_rm_block(a, Pico32xMem->drcblk_da[cpuid],
3111     1 + cpuid, SH2_DRCBLK_DA_SHIFT, 0xfff);
3112 }
3113
3114 int sh2_execute_drc(SH2 *sh2c, int cycles)
3115 {
3116   int ret_cycles;
3117
3118   // cycles are kept in SHR_SR unused bits (upper 20)
3119   // bit11 contains T saved for delay slot
3120   // others are usual SH2 flags
3121   sh2c->sr &= 0x3f3;
3122   sh2c->sr |= cycles << 12;
3123   sh2_drc_entry(sh2c);
3124
3125   // TODO: irq cycles
3126   ret_cycles = (signed int)sh2c->sr >> 12;
3127   if (ret_cycles > 0)
3128     dbg(1, "warning: drc returned with cycles: %d", ret_cycles);
3129
3130   sh2c->sr &= 0x3f3;
3131   return ret_cycles;
3132 }
3133
3134 #if (DRC_DEBUG & 2)
3135 void block_stats(void)
3136 {
3137   int c, b, i, total = 0;
3138
3139   printf("block stats:\n");
3140   for (b = 0; b < ARRAY_SIZE(block_tables); b++)
3141     for (i = 0; i < block_counts[b]; i++)
3142       if (block_tables[b][i].addr != 0)
3143         total += block_tables[b][i].refcount;
3144
3145   for (c = 0; c < 10; c++) {
3146     struct block_desc *blk, *maxb = NULL;
3147     int max = 0;
3148     for (b = 0; b < ARRAY_SIZE(block_tables); b++) {
3149       for (i = 0; i < block_counts[b]; i++) {
3150         blk = &block_tables[b][i];
3151         if (blk->addr != 0 && blk->refcount > max) {
3152           max = blk->refcount;
3153           maxb = blk;
3154         }
3155       }
3156     }
3157     if (maxb == NULL)
3158       break;
3159     printf("%08x %9d %2.3f%%\n", maxb->addr, maxb->refcount,
3160       (double)maxb->refcount / total * 100.0);
3161     maxb->refcount = 0;
3162   }
3163
3164   for (b = 0; b < ARRAY_SIZE(block_tables); b++)
3165     for (i = 0; i < block_counts[b]; i++)
3166       block_tables[b][i].refcount = 0;
3167 }
3168 #else
3169 #define block_stats()
3170 #endif
3171
3172 void sh2_drc_flush_all(void)
3173 {
3174   block_stats();
3175   flush_tcache(0);
3176   flush_tcache(1);
3177   flush_tcache(2);
3178 }
3179
3180 void sh2_drc_mem_setup(SH2 *sh2)
3181 {
3182   // fill the convenience pointers
3183   sh2->p_bios = sh2->is_slave ? Pico32xMem->sh2_rom_s.w : Pico32xMem->sh2_rom_m.w;
3184   sh2->p_da = sh2->data_array;
3185   sh2->p_sdram = Pico32xMem->sdram;
3186   sh2->p_rom = Pico.rom;
3187 }
3188
3189 void sh2_drc_frame(void)
3190 {
3191   if (literal_disabled_frames > 0)
3192     literal_disabled_frames--;
3193 }
3194
3195 int sh2_drc_init(SH2 *sh2)
3196 {
3197   int i;
3198
3199   if (block_tables[0] == NULL)
3200   {
3201     for (i = 0; i < TCACHE_BUFFERS; i++) {
3202       block_tables[i] = calloc(block_max_counts[i], sizeof(*block_tables[0]));
3203       if (block_tables[i] == NULL)
3204         goto fail;
3205       // max 2 block links (exits) per block
3206       block_link_pool[i] = calloc(block_link_pool_max_counts[i],
3207                           sizeof(*block_link_pool[0]));
3208       if (block_link_pool[i] == NULL)
3209         goto fail;
3210
3211       inval_lookup[i] = calloc(ram_sizes[i] / INVAL_PAGE_SIZE,
3212                                sizeof(inval_lookup[0]));
3213       if (inval_lookup[i] == NULL)
3214         goto fail;
3215
3216       hash_tables[i] = calloc(hash_table_sizes[i], sizeof(*hash_tables[0]));
3217       if (hash_tables[i] == NULL)
3218         goto fail;
3219     }
3220     memset(block_counts, 0, sizeof(block_counts));
3221     memset(block_link_pool_counts, 0, sizeof(block_link_pool_counts));
3222
3223     drc_cmn_init();
3224     tcache_ptr = tcache;
3225     sh2_generate_utils();
3226     host_instructions_updated(tcache, tcache_ptr);
3227
3228     tcache_bases[0] = tcache_ptrs[0] = tcache_ptr;
3229     for (i = 1; i < ARRAY_SIZE(tcache_bases); i++)
3230       tcache_bases[i] = tcache_ptrs[i] = tcache_bases[i - 1] + tcache_sizes[i - 1];
3231
3232 #if (DRC_DEBUG & 4)
3233     for (i = 0; i < ARRAY_SIZE(block_tables); i++)
3234       tcache_dsm_ptrs[i] = tcache_bases[i];
3235     // disasm the utils
3236     tcache_dsm_ptrs[0] = tcache;
3237     do_host_disasm(0);
3238 #endif
3239 #if (DRC_DEBUG & 1)
3240     hash_collisions = 0;
3241 #endif
3242   }
3243
3244   return 0;
3245
3246 fail:
3247   sh2_drc_finish(sh2);
3248   return -1;
3249 }
3250
3251 void sh2_drc_finish(SH2 *sh2)
3252 {
3253   int i;
3254
3255   if (block_tables[0] == NULL)
3256     return;
3257
3258   sh2_drc_flush_all();
3259
3260   for (i = 0; i < TCACHE_BUFFERS; i++) {
3261 #if (DRC_DEBUG & 4)
3262     printf("~~~ tcache %d\n", i);
3263     tcache_dsm_ptrs[i] = tcache_bases[i];
3264     tcache_ptr = tcache_ptrs[i];
3265     do_host_disasm(i);
3266 #endif
3267
3268     if (block_tables[i] != NULL)
3269       free(block_tables[i]);
3270     block_tables[i] = NULL;
3271     if (block_link_pool[i] == NULL)
3272       free(block_link_pool[i]);
3273     block_link_pool[i] = NULL;
3274
3275     if (inval_lookup[i] == NULL)
3276       free(inval_lookup[i]);
3277     inval_lookup[i] = NULL;
3278
3279     if (hash_tables[i] != NULL) {
3280       free(hash_tables[i]);
3281       hash_tables[i] = NULL;
3282     }
3283   }
3284
3285   drc_cmn_cleanup();
3286 }
3287
3288 #endif /* DRC_SH2 */
3289
3290 static void *dr_get_pc_base(u32 pc, int is_slave)
3291 {
3292   void *ret = NULL;
3293   u32 mask = 0;
3294
3295   if ((pc & ~0x7ff) == 0) {
3296     // BIOS
3297     ret = is_slave ? Pico32xMem->sh2_rom_s.w : Pico32xMem->sh2_rom_m.w;
3298     mask = 0x7ff;
3299   }
3300   else if ((pc & 0xfffff000) == 0xc0000000) {
3301     // data array
3302     ret = sh2s[is_slave].data_array;
3303     mask = 0xfff;
3304   }
3305   else if ((pc & 0xc6000000) == 0x06000000) {
3306     // SDRAM
3307     ret = Pico32xMem->sdram;
3308     mask = 0x03ffff;
3309   }
3310   else if ((pc & 0xc6000000) == 0x02000000) {
3311     // ROM
3312     if ((pc & 0x3fffff) < Pico.romsize)
3313       ret = Pico.rom;
3314     mask = 0x3fffff;
3315   }
3316
3317   if (ret == NULL)
3318     return (void *)-1; // NULL is valid value
3319
3320   return (char *)ret - (pc & ~mask);
3321 }
3322
3323 void scan_block(u32 base_pc, int is_slave, u8 *op_flags, u32 *end_pc_out,
3324   u32 *end_literals_out)
3325 {
3326   u16 *dr_pc_base;
3327   u32 pc, op, tmp;
3328   u32 end_pc, end_literals = 0;
3329   u32 lowest_mova = 0;
3330   struct op_data *opd;
3331   int next_is_delay = 0;
3332   int end_block = 0;
3333   int i, i_end;
3334
3335   memset(op_flags, 0, BLOCK_INSN_LIMIT);
3336
3337   dr_pc_base = dr_get_pc_base(base_pc, is_slave);
3338
3339   // 1st pass: disassemble
3340   for (i = 0, pc = base_pc; ; i++, pc += 2) {
3341     // we need an ops[] entry after the last one initialized,
3342     // so do it before end_block checks
3343     opd = &ops[i];
3344     opd->op = OP_UNHANDLED;
3345     opd->rm = -1;
3346     opd->source = opd->dest = 0;
3347     opd->cycles = 1;
3348     opd->imm = 0;
3349
3350     if (next_is_delay) {
3351       op_flags[i] |= OF_DELAY_OP;
3352       next_is_delay = 0;
3353     }
3354     else if (end_block || i >= BLOCK_INSN_LIMIT - 2)
3355       break;
3356
3357     op = FETCH_OP(pc);
3358     switch ((op & 0xf000) >> 12)
3359     {
3360     /////////////////////////////////////////////
3361     case 0x00:
3362       switch (op & 0x0f)
3363       {
3364       case 0x02:
3365         switch (GET_Fx())
3366         {
3367         case 0: // STC SR,Rn  0000nnnn00000010
3368           tmp = SHR_SR;
3369           break;
3370         case 1: // STC GBR,Rn 0000nnnn00010010
3371           tmp = SHR_GBR;
3372           break;
3373         case 2: // STC VBR,Rn 0000nnnn00100010
3374           tmp = SHR_VBR;
3375           break;
3376         default:
3377           goto undefined;
3378         }
3379         opd->op = OP_MOVE;
3380         opd->source = BITMASK1(tmp);
3381         opd->dest = BITMASK1(GET_Rn());
3382         break;
3383       case 0x03:
3384         CHECK_UNHANDLED_BITS(0xd0, undefined);
3385         // BRAF Rm    0000mmmm00100011
3386         // BSRF Rm    0000mmmm00000011
3387         opd->op = OP_BRANCH_RF;
3388         opd->rm = GET_Rn();
3389         opd->source = BITMASK1(opd->rm);
3390         opd->dest = BITMASK1(SHR_PC);
3391         if (!(op & 0x20))
3392           opd->dest |= BITMASK1(SHR_PR);
3393         opd->cycles = 2;
3394         next_is_delay = 1;
3395         end_block = 1;
3396         break;
3397       case 0x04: // MOV.B Rm,@(R0,Rn)   0000nnnnmmmm0100
3398       case 0x05: // MOV.W Rm,@(R0,Rn)   0000nnnnmmmm0101
3399       case 0x06: // MOV.L Rm,@(R0,Rn)   0000nnnnmmmm0110
3400         opd->source = BITMASK3(GET_Rm(), SHR_R0, GET_Rn());
3401         break;
3402       case 0x07:
3403         // MUL.L     Rm,Rn      0000nnnnmmmm0111
3404         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3405         opd->dest = BITMASK1(SHR_MACL);
3406         opd->cycles = 2;
3407         break;
3408       case 0x08:
3409         CHECK_UNHANDLED_BITS(0xf00, undefined);
3410         switch (GET_Fx())
3411         {
3412         case 0: // CLRT               0000000000001000
3413           opd->op = OP_SETCLRT;
3414           opd->dest = BITMASK1(SHR_T);
3415           opd->imm = 0;
3416           break;
3417         case 1: // SETT               0000000000011000
3418           opd->op = OP_SETCLRT;
3419           opd->dest = BITMASK1(SHR_T);
3420           opd->imm = 1;
3421           break;
3422         case 2: // CLRMAC             0000000000101000
3423           opd->dest = BITMASK3(SHR_T, SHR_MACL, SHR_MACH);
3424           break;
3425         default:
3426           goto undefined;
3427         }
3428         break;
3429       case 0x09:
3430         switch (GET_Fx())
3431         {
3432         case 0: // NOP        0000000000001001
3433           CHECK_UNHANDLED_BITS(0xf00, undefined);
3434           break;
3435         case 1: // DIV0U      0000000000011001
3436           CHECK_UNHANDLED_BITS(0xf00, undefined);
3437           opd->dest = BITMASK2(SHR_SR, SHR_T);
3438           break;
3439         case 2: // MOVT Rn    0000nnnn00101001
3440           opd->source = BITMASK1(SHR_T);
3441           opd->dest = BITMASK1(GET_Rn());
3442           break;
3443         default:
3444           goto undefined;
3445         }
3446         break;
3447       case 0x0a:
3448         switch (GET_Fx())
3449         {
3450         case 0: // STS      MACH,Rn   0000nnnn00001010
3451           tmp = SHR_MACH;
3452           break;
3453         case 1: // STS      MACL,Rn   0000nnnn00011010
3454           tmp = SHR_MACL;
3455           break;
3456         case 2: // STS      PR,Rn     0000nnnn00101010
3457           tmp = SHR_PR;
3458           break;
3459         default:
3460           goto undefined;
3461         }
3462         opd->op = OP_MOVE;
3463         opd->source = BITMASK1(tmp);
3464         opd->dest = BITMASK1(GET_Rn());
3465         break;
3466       case 0x0b:
3467         CHECK_UNHANDLED_BITS(0xf00, undefined);
3468         switch (GET_Fx())
3469         {
3470         case 0: // RTS        0000000000001011
3471           opd->op = OP_BRANCH_R;
3472           opd->rm = SHR_PR;
3473           opd->source = BITMASK1(opd->rm);
3474           opd->dest = BITMASK1(SHR_PC);
3475           opd->cycles = 2;
3476           next_is_delay = 1;
3477           end_block = 1;
3478           break;
3479         case 1: // SLEEP      0000000000011011
3480           opd->op = OP_SLEEP;
3481           end_block = 1;
3482           break;
3483         case 2: // RTE        0000000000101011
3484           opd->op = OP_RTE;
3485           opd->source = BITMASK1(SHR_SP);
3486           opd->dest = BITMASK2(SHR_SR, SHR_PC);
3487           opd->cycles = 4;
3488           next_is_delay = 1;
3489           end_block = 1;
3490           break;
3491         default:
3492           goto undefined;
3493         }
3494         break;
3495       case 0x0c: // MOV.B    @(R0,Rm),Rn      0000nnnnmmmm1100
3496       case 0x0d: // MOV.W    @(R0,Rm),Rn      0000nnnnmmmm1101
3497       case 0x0e: // MOV.L    @(R0,Rm),Rn      0000nnnnmmmm1110
3498         opd->source = BITMASK2(GET_Rm(), SHR_R0);
3499         opd->dest = BITMASK1(GET_Rn());
3500         break;
3501       case 0x0f: // MAC.L   @Rm+,@Rn+  0000nnnnmmmm1111
3502         opd->source = BITMASK5(GET_Rm(), GET_Rn(), SHR_SR, SHR_MACL, SHR_MACH);
3503         opd->dest = BITMASK4(GET_Rm(), GET_Rn(), SHR_MACL, SHR_MACH);
3504         opd->cycles = 3;
3505         break;
3506       default:
3507         goto undefined;
3508       }
3509       break;
3510
3511     /////////////////////////////////////////////
3512     case 0x01:
3513       // MOV.L Rm,@(disp,Rn) 0001nnnnmmmmdddd
3514       opd->source = BITMASK1(GET_Rm());
3515       opd->source = BITMASK1(GET_Rn());
3516       opd->imm = (op & 0x0f) * 4;
3517       break;
3518
3519     /////////////////////////////////////////////
3520     case 0x02:
3521       switch (op & 0x0f)
3522       {
3523       case 0x00: // MOV.B Rm,@Rn        0010nnnnmmmm0000
3524       case 0x01: // MOV.W Rm,@Rn        0010nnnnmmmm0001
3525       case 0x02: // MOV.L Rm,@Rn        0010nnnnmmmm0010
3526         opd->source = BITMASK1(GET_Rm());
3527         opd->source = BITMASK1(GET_Rn());
3528         break;
3529       case 0x04: // MOV.B Rm,@-Rn       0010nnnnmmmm0100
3530       case 0x05: // MOV.W Rm,@-Rn       0010nnnnmmmm0101
3531       case 0x06: // MOV.L Rm,@-Rn       0010nnnnmmmm0110
3532         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3533         opd->dest = BITMASK1(GET_Rn());
3534         break;
3535       case 0x07: // DIV0S Rm,Rn         0010nnnnmmmm0111
3536         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3537         opd->dest = BITMASK1(SHR_SR);
3538         break;
3539       case 0x08: // TST Rm,Rn           0010nnnnmmmm1000
3540         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3541         opd->dest = BITMASK1(SHR_T);
3542         break;
3543       case 0x09: // AND Rm,Rn           0010nnnnmmmm1001
3544       case 0x0a: // XOR Rm,Rn           0010nnnnmmmm1010
3545       case 0x0b: // OR  Rm,Rn           0010nnnnmmmm1011
3546         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3547         opd->dest = BITMASK1(GET_Rn());
3548         break;
3549       case 0x0c: // CMP/STR Rm,Rn       0010nnnnmmmm1100
3550         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3551         opd->dest = BITMASK1(SHR_T);
3552         break;
3553       case 0x0d: // XTRCT  Rm,Rn        0010nnnnmmmm1101
3554         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3555         opd->dest = BITMASK1(GET_Rn());
3556         break;
3557       case 0x0e: // MULU.W Rm,Rn        0010nnnnmmmm1110
3558       case 0x0f: // MULS.W Rm,Rn        0010nnnnmmmm1111
3559         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3560         opd->dest = BITMASK1(SHR_MACL);
3561         break;
3562       default:
3563         goto undefined;
3564       }
3565       break;
3566
3567     /////////////////////////////////////////////
3568     case 0x03:
3569       switch (op & 0x0f)
3570       {
3571       case 0x00: // CMP/EQ Rm,Rn        0011nnnnmmmm0000
3572       case 0x02: // CMP/HS Rm,Rn        0011nnnnmmmm0010
3573       case 0x03: // CMP/GE Rm,Rn        0011nnnnmmmm0011
3574       case 0x06: // CMP/HI Rm,Rn        0011nnnnmmmm0110
3575       case 0x07: // CMP/GT Rm,Rn        0011nnnnmmmm0111
3576         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3577         opd->dest = BITMASK1(SHR_T);
3578         break;
3579       case 0x04: // DIV1    Rm,Rn       0011nnnnmmmm0100
3580         opd->source = BITMASK3(GET_Rm(), GET_Rn(), SHR_SR);
3581         opd->dest = BITMASK2(GET_Rn(), SHR_SR);
3582         break;
3583       case 0x05: // DMULU.L Rm,Rn       0011nnnnmmmm0101
3584       case 0x0d: // DMULS.L Rm,Rn       0011nnnnmmmm1101
3585         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3586         opd->dest = BITMASK2(SHR_MACL, SHR_MACH);
3587         opd->cycles = 2;
3588         break;
3589       case 0x08: // SUB     Rm,Rn       0011nnnnmmmm1000
3590       case 0x0c: // ADD     Rm,Rn       0011nnnnmmmm1100
3591         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3592         opd->dest = BITMASK1(GET_Rn());
3593         break;
3594       case 0x0a: // SUBC    Rm,Rn       0011nnnnmmmm1010
3595       case 0x0e: // ADDC    Rm,Rn       0011nnnnmmmm1110
3596         opd->source = BITMASK3(GET_Rm(), GET_Rn(), SHR_T);
3597         opd->dest = BITMASK2(GET_Rn(), SHR_T);
3598         break;
3599       case 0x0b: // SUBV    Rm,Rn       0011nnnnmmmm1011
3600       case 0x0f: // ADDV    Rm,Rn       0011nnnnmmmm1111
3601         opd->source = BITMASK2(GET_Rm(), GET_Rn());
3602         opd->dest = BITMASK2(GET_Rn(), SHR_T);
3603         break;
3604       default:
3605         goto undefined;
3606       }
3607       break;
3608
3609     /////////////////////////////////////////////
3610     case 0x04:
3611       switch (op & 0x0f)
3612       {
3613       case 0x00:
3614         switch (GET_Fx())
3615         {
3616         case 0: // SHLL Rn    0100nnnn00000000
3617         case 2: // SHAL Rn    0100nnnn00100000
3618           opd->source = BITMASK1(GET_Rn());
3619           opd->dest = BITMASK2(GET_Rn(), SHR_T);
3620           break;
3621         case 1: // DT Rn      0100nnnn00010000
3622           opd->source = BITMASK1(GET_Rn());
3623           opd->dest = BITMASK2(GET_Rn(), SHR_T);
3624           break;
3625         default:
3626           goto undefined;
3627         }
3628         break;
3629       case 0x01:
3630         switch (GET_Fx())
3631         {
3632         case 0: // SHLR Rn    0100nnnn00000001
3633         case 2: // SHAR Rn    0100nnnn00100001
3634           opd->source = BITMASK1(GET_Rn());
3635           opd->dest = BITMASK2(GET_Rn(), SHR_T);
3636           break;
3637         case 1: // CMP/PZ Rn  0100nnnn00010001
3638           opd->source = BITMASK1(GET_Rn());
3639           opd->dest = BITMASK1(SHR_T);
3640           break;
3641         default:
3642           goto undefined;
3643         }
3644         break;
3645       case 0x02:
3646       case 0x03:
3647         switch (op & 0x3f)
3648         {
3649         case 0x02: // STS.L    MACH,@-Rn 0100nnnn00000010
3650           tmp = SHR_MACH;
3651           break;
3652         case 0x12: // STS.L    MACL,@-Rn 0100nnnn00010010
3653           tmp = SHR_MACL;
3654           break;
3655         case 0x22: // STS.L    PR,@-Rn   0100nnnn00100010
3656           tmp = SHR_PR;
3657           break;
3658         case 0x03: // STC.L    SR,@-Rn   0100nnnn00000011
3659           tmp = SHR_SR;
3660           opd->cycles = 2;
3661           break;
3662         case 0x13: // STC.L    GBR,@-Rn  0100nnnn00010011
3663           tmp = SHR_GBR;
3664           opd->cycles = 2;
3665           break;
3666         case 0x23: // STC.L    VBR,@-Rn  0100nnnn00100011
3667           tmp = SHR_VBR;
3668           opd->cycles = 2;
3669           break;
3670         default:
3671           goto undefined;
3672         }
3673         opd->source = BITMASK2(GET_Rn(), tmp);
3674         opd->dest = BITMASK1(GET_Rn());
3675         break;
3676       case 0x04:
3677       case 0x05:
3678         switch (op & 0x3f)
3679         {
3680         case 0x04: // ROTL   Rn          0100nnnn00000100
3681         case 0x05: // ROTR   Rn          0100nnnn00000101
3682           opd->source = BITMASK1(GET_Rn());
3683           opd->dest = BITMASK2(GET_Rn(), SHR_T);
3684           break;
3685         case 0x24: // ROTCL  Rn          0100nnnn00100100
3686         case 0x25: // ROTCR  Rn          0100nnnn00100101
3687           opd->source = BITMASK2(GET_Rn(), SHR_T);
3688           opd->dest = BITMASK2(GET_Rn(), SHR_T);
3689           break;
3690         case 0x15: // CMP/PL Rn          0100nnnn00010101
3691           opd->source = BITMASK1(GET_Rn());
3692           opd->dest = BITMASK1(SHR_T);
3693           break;
3694         default:
3695           goto undefined;
3696         }
3697         break;
3698       case 0x06:
3699       case 0x07:
3700         switch (op & 0x3f)
3701         {
3702         case 0x06: // LDS.L @Rm+,MACH 0100mmmm00000110
3703           tmp = SHR_MACH;
3704           break;
3705         case 0x16: // LDS.L @Rm+,MACL 0100mmmm00010110
3706           tmp = SHR_MACL;
3707           break;
3708         case 0x26: // LDS.L @Rm+,PR   0100mmmm00100110
3709           tmp = SHR_PR;
3710           break;
3711         case 0x07: // LDC.L @Rm+,SR   0100mmmm00000111
3712           tmp = SHR_SR;
3713           opd->cycles = 3;
3714           break;
3715         case 0x17: // LDC.L @Rm+,GBR  0100mmmm00010111
3716           tmp = SHR_GBR;
3717           opd->cycles = 3;
3718           break;
3719         case 0x27: // LDC.L @Rm+,VBR  0100mmmm00100111
3720           tmp = SHR_VBR;
3721           opd->cycles = 3;
3722           break;
3723         default:
3724           goto undefined;
3725         }
3726         opd->source = BITMASK1(GET_Rn());
3727         opd->dest = BITMASK2(GET_Rn(), tmp);
3728         break;
3729       case 0x08:
3730       case 0x09:
3731         switch (GET_Fx())
3732         {
3733         case 0:
3734           // SHLL2 Rn        0100nnnn00001000
3735           // SHLR2 Rn        0100nnnn00001001
3736           break;
3737         case 1:
3738           // SHLL8 Rn        0100nnnn00011000
3739           // SHLR8 Rn        0100nnnn00011001
3740           break;
3741         case 2:
3742           // SHLL16 Rn       0100nnnn00101000
3743           // SHLR16 Rn       0100nnnn00101001
3744           break;
3745         default:
3746           goto undefined;
3747         }
3748         opd->source = BITMASK1(GET_Rn());
3749         opd->dest = BITMASK1(GET_Rn());
3750         break;
3751       case 0x0a:
3752         switch (GET_Fx())
3753         {
3754         case 0: // LDS      Rm,MACH   0100mmmm00001010
3755           tmp = SHR_MACH;
3756           break;
3757         case 1: // LDS      Rm,MACL   0100mmmm00011010
3758           tmp = SHR_MACL;
3759           break;
3760         case 2: // LDS      Rm,PR     0100mmmm00101010
3761           tmp = SHR_PR;
3762           break;
3763         default:
3764           goto undefined;
3765         }
3766         opd->op = OP_MOVE;
3767         opd->source = BITMASK1(GET_Rn());
3768         opd->dest = BITMASK1(tmp);
3769         break;
3770       case 0x0b:
3771         switch (GET_Fx())
3772         {
3773         case 0: // JSR  @Rm   0100mmmm00001011
3774           opd->dest = BITMASK1(SHR_PR);
3775         case 2: // JMP  @Rm   0100mmmm00101011
3776           opd->op = OP_BRANCH_R;
3777           opd->rm = GET_Rn();
3778           opd->source = BITMASK1(opd->rm);
3779           opd->dest |= BITMASK1(SHR_PC);
3780           opd->cycles = 2;
3781           next_is_delay = 1;
3782           end_block = 1;
3783           break;
3784         case 1: // TAS.B @Rn  0100nnnn00011011
3785           opd->source = BITMASK1(GET_Rn());
3786           opd->dest = BITMASK1(SHR_T);
3787           opd->cycles = 4;
3788           break;
3789         default:
3790           goto undefined;
3791         }
3792         break;
3793       case 0x0e:
3794         switch (GET_Fx())
3795         {
3796         case 0: // LDC Rm,SR   0100mmmm00001110
3797           tmp = SHR_SR;
3798           break;
3799         case 1: // LDC Rm,GBR  0100mmmm00011110
3800           tmp = SHR_GBR;
3801           break;
3802         case 2: // LDC Rm,VBR  0100mmmm00101110
3803           tmp = SHR_VBR;
3804           break;
3805         default:
3806           goto undefined;
3807         }
3808         opd->op = OP_MOVE;
3809         opd->source = BITMASK1(GET_Rn());
3810         opd->dest = BITMASK1(tmp);
3811         break;
3812       case 0x0f:
3813         // MAC.W @Rm+,@Rn+  0100nnnnmmmm1111
3814         opd->source = BITMASK5(GET_Rm(), GET_Rn(), SHR_SR, SHR_MACL, SHR_MACH);
3815         opd->dest = BITMASK4(GET_Rm(), GET_Rn(), SHR_MACL, SHR_MACH);
3816         opd->cycles = 3;
3817         break;
3818       default:
3819         goto undefined;
3820       }
3821       break;
3822
3823     /////////////////////////////////////////////
3824     case 0x05:
3825       // MOV.L @(disp,Rm),Rn 0101nnnnmmmmdddd
3826       opd->source = BITMASK1(GET_Rm());
3827       opd->dest = BITMASK1(GET_Rn());
3828       opd->imm = (op & 0x0f) * 4;
3829       break;
3830
3831     /////////////////////////////////////////////
3832     case 0x06:
3833       switch (op & 0x0f)
3834       {
3835       case 0x04: // MOV.B @Rm+,Rn       0110nnnnmmmm0100
3836       case 0x05: // MOV.W @Rm+,Rn       0110nnnnmmmm0101
3837       case 0x06: // MOV.L @Rm+,Rn       0110nnnnmmmm0110
3838         opd->dest = BITMASK1(GET_Rm());
3839       case 0x00: // MOV.B @Rm,Rn        0110nnnnmmmm0000
3840       case 0x01: // MOV.W @Rm,Rn        0110nnnnmmmm0001
3841       case 0x02: // MOV.L @Rm,Rn        0110nnnnmmmm0010
3842         opd->source = BITMASK1(GET_Rm());
3843         opd->dest |= BITMASK1(GET_Rn());
3844         break;
3845       case 0x0a: // NEGC   Rm,Rn        0110nnnnmmmm1010
3846         opd->source = BITMASK2(GET_Rm(), SHR_T);
3847         opd->dest = BITMASK2(GET_Rn(), SHR_T);
3848         break;
3849       case 0x03: // MOV    Rm,Rn        0110nnnnmmmm0011
3850         opd->op = OP_MOVE;
3851         goto arith_rmrn;
3852       case 0x07: // NOT    Rm,Rn        0110nnnnmmmm0111
3853       case 0x08: // SWAP.B Rm,Rn        0110nnnnmmmm1000
3854       case 0x09: // SWAP.W Rm,Rn        0110nnnnmmmm1001
3855       case 0x0b: // NEG    Rm,Rn        0110nnnnmmmm1011
3856       case 0x0c: // EXTU.B Rm,Rn        0110nnnnmmmm1100
3857       case 0x0d: // EXTU.W Rm,Rn        0110nnnnmmmm1101
3858       case 0x0e: // EXTS.B Rm,Rn        0110nnnnmmmm1110
3859       case 0x0f: // EXTS.W Rm,Rn        0110nnnnmmmm1111
3860       arith_rmrn:
3861         opd->source = BITMASK1(GET_Rm());
3862         opd->dest = BITMASK1(GET_Rn());
3863         break;
3864       }
3865       break;
3866
3867     /////////////////////////////////////////////
3868     case 0x07:
3869       // ADD #imm,Rn  0111nnnniiiiiiii
3870       opd->source = opd->dest = BITMASK1(GET_Rn());
3871       opd->imm = (int)(signed char)op;
3872       break;
3873
3874     /////////////////////////////////////////////
3875     case 0x08:
3876       switch (op & 0x0f00)
3877       {
3878       case 0x0000: // MOV.B R0,@(disp,Rn)  10000000nnnndddd
3879         opd->source = BITMASK2(GET_Rm(), SHR_R0);
3880         opd->imm = (op & 0x0f);
3881         break;
3882       case 0x0100: // MOV.W R0,@(disp,Rn)  10000001nnnndddd
3883         opd->source = BITMASK2(GET_Rm(), SHR_R0);
3884         opd->imm = (op & 0x0f) * 2;
3885         break;
3886       case 0x0400: // MOV.B @(disp,Rm),R0  10000100mmmmdddd
3887         opd->source = BITMASK1(GET_Rm());
3888         opd->dest = BITMASK1(SHR_R0);
3889         opd->imm = (op & 0x0f);
3890         break;
3891       case 0x0500: // MOV.W @(disp,Rm),R0  10000101mmmmdddd
3892         opd->source = BITMASK1(GET_Rm());
3893         opd->dest = BITMASK1(SHR_R0);
3894         opd->imm = (op & 0x0f) * 2;
3895         break;
3896       case 0x0800: // CMP/EQ #imm,R0       10001000iiiiiiii
3897         opd->source = BITMASK1(SHR_R0);
3898         opd->dest = BITMASK1(SHR_T);
3899         opd->imm = (int)(signed char)op;
3900         break;
3901       case 0x0d00: // BT/S label 10001101dddddddd
3902       case 0x0f00: // BF/S label 10001111dddddddd
3903         next_is_delay = 1;
3904         // fallthrough
3905       case 0x0900: // BT   label 10001001dddddddd
3906       case 0x0b00: // BF   label 10001011dddddddd
3907         opd->op = (op & 0x0200) ? OP_BRANCH_CF : OP_BRANCH_CT;
3908         opd->source = BITMASK1(SHR_T);
3909         opd->dest = BITMASK1(SHR_PC);
3910         opd->imm = ((signed int)(op << 24) >> 23);
3911         opd->imm += pc + 4;
3912         if (base_pc <= opd->imm && opd->imm < base_pc + BLOCK_INSN_LIMIT * 2)
3913           op_flags[(opd->imm - base_pc) / 2] |= OF_BTARGET;
3914         break;
3915       default:
3916         goto undefined;
3917       }
3918       break;
3919
3920     /////////////////////////////////////////////
3921     case 0x09:
3922       // MOV.W @(disp,PC),Rn  1001nnnndddddddd
3923       opd->op = OP_LOAD_POOL;
3924       tmp = pc + 2;
3925       if (op_flags[i] & OF_DELAY_OP) {
3926         if (ops[i-1].op == OP_BRANCH)
3927           tmp = ops[i-1].imm;
3928         else
3929           tmp = 0;
3930       }
3931       opd->source = BITMASK1(SHR_PC);
3932       opd->dest = BITMASK1(GET_Rn());
3933       if (tmp)
3934         opd->imm = tmp + 2 + (op & 0xff) * 2;
3935       opd->size = 1;
3936       break;
3937
3938     /////////////////////////////////////////////
3939     case 0x0b:
3940       // BSR  label 1011dddddddddddd
3941       opd->dest = BITMASK1(SHR_PR);
3942     case 0x0a:
3943       // BRA  label 1010dddddddddddd
3944       opd->op = OP_BRANCH;
3945       opd->dest |= BITMASK1(SHR_PC);
3946       opd->imm = ((signed int)(op << 20) >> 19);
3947       opd->imm += pc + 4;
3948       opd->cycles = 2;
3949       next_is_delay = 1;
3950       end_block = 1;
3951       if (base_pc <= opd->imm && opd->imm < base_pc + BLOCK_INSN_LIMIT * 2)
3952         op_flags[(opd->imm - base_pc) / 2] |= OF_BTARGET;
3953       break;
3954
3955     /////////////////////////////////////////////
3956     case 0x0c:
3957       switch (op & 0x0f00)
3958       {
3959       case 0x0000: // MOV.B R0,@(disp,GBR)   11000000dddddddd
3960       case 0x0100: // MOV.W R0,@(disp,GBR)   11000001dddddddd
3961       case 0x0200: // MOV.L R0,@(disp,GBR)   11000010dddddddd
3962         opd->source = BITMASK2(SHR_GBR, SHR_R0);
3963         opd->size = (op & 0x300) >> 8;
3964         opd->imm = (op & 0xff) << opd->size;
3965         break;
3966       case 0x0400: // MOV.B @(disp,GBR),R0   11000100dddddddd
3967       case 0x0500: // MOV.W @(disp,GBR),R0   11000101dddddddd
3968       case 0x0600: // MOV.L @(disp,GBR),R0   11000110dddddddd
3969         opd->source = BITMASK1(SHR_GBR);
3970         opd->dest = BITMASK1(SHR_R0);
3971         opd->size = (op & 0x300) >> 8;
3972         opd->imm = (op & 0xff) << opd->size;
3973         break;
3974       case 0x0300: // TRAPA #imm      11000011iiiiiiii
3975         opd->source = BITMASK2(SHR_PC, SHR_SR);
3976         opd->dest = BITMASK1(SHR_PC);
3977         opd->imm = (op & 0xff) * 4;
3978         opd->cycles = 8;
3979         end_block = 1; // FIXME
3980         break;
3981       case 0x0700: // MOVA @(disp,PC),R0    11000111dddddddd
3982         opd->op = OP_MOVA;
3983         tmp = pc + 2;
3984         if (op_flags[i] & OF_DELAY_OP) {
3985           if (ops[i-1].op == OP_BRANCH)
3986             tmp = ops[i-1].imm;
3987           else
3988             tmp = 0;
3989         }
3990         opd->dest = BITMASK1(SHR_R0);
3991         if (tmp) {
3992           opd->imm = (tmp + 2 + (op & 0xff) * 4) & ~3;
3993           if (opd->imm >= base_pc) {
3994             if (lowest_mova == 0 || opd->imm < lowest_mova)
3995               lowest_mova = opd->imm;
3996           }
3997         }
3998         break;
3999       case 0x0800: // TST #imm,R0           11001000iiiiiiii
4000         opd->source = BITMASK1(SHR_R0);
4001         opd->dest = BITMASK1(SHR_T);
4002         opd->imm = op & 0xff;
4003         break;
4004       case 0x0900: // AND #imm,R0           11001001iiiiiiii
4005         opd->source = opd->dest = BITMASK1(SHR_R0);
4006         opd->imm = op & 0xff;
4007         break;
4008       case 0x0a00: // XOR #imm,R0           11001010iiiiiiii
4009         opd->source = opd->dest = BITMASK1(SHR_R0);
4010         opd->imm = op & 0xff;
4011         break;
4012       case 0x0b00: // OR  #imm,R0           11001011iiiiiiii
4013         opd->source = opd->dest = BITMASK1(SHR_R0);
4014         opd->imm = op & 0xff;
4015         break;
4016       case 0x0c00: // TST.B #imm,@(R0,GBR)  11001100iiiiiiii
4017         opd->source = BITMASK2(SHR_GBR, SHR_R0);
4018         opd->dest = BITMASK1(SHR_T);
4019         opd->imm = op & 0xff;
4020         opd->cycles = 3;
4021         break;
4022       case 0x0d00: // AND.B #imm,@(R0,GBR)  11001101iiiiiiii
4023       case 0x0e00: // XOR.B #imm,@(R0,GBR)  11001110iiiiiiii
4024       case 0x0f00: // OR.B  #imm,@(R0,GBR)  11001111iiiiiiii
4025         opd->source = BITMASK2(SHR_GBR, SHR_R0);
4026         opd->imm = op & 0xff;
4027         opd->cycles = 3;
4028         break;
4029       default:
4030         goto undefined;
4031       }
4032       break;
4033
4034     /////////////////////////////////////////////
4035     case 0x0d:
4036       // MOV.L @(disp,PC),Rn  1101nnnndddddddd
4037       opd->op = OP_LOAD_POOL;
4038       tmp = pc + 2;
4039       if (op_flags[i] & OF_DELAY_OP) {
4040         if (ops[i-1].op == OP_BRANCH)
4041           tmp = ops[i-1].imm;
4042         else
4043           tmp = 0;
4044       }
4045       opd->source = BITMASK1(SHR_PC);
4046       opd->dest = BITMASK1(GET_Rn());
4047       if (tmp)
4048         opd->imm = (tmp + 2 + (op & 0xff) * 4) & ~3;
4049       opd->size = 2;
4050       break;
4051
4052     /////////////////////////////////////////////
4053     case 0x0e:
4054       // MOV #imm,Rn   1110nnnniiiiiiii
4055       opd->dest = BITMASK1(GET_Rn());
4056       opd->imm = (u32)(signed int)(signed char)op;
4057       break;
4058
4059     default:
4060     undefined:
4061       elprintf(EL_ANOMALY, "%csh2 drc: unhandled op %04x @ %08x",
4062         is_slave ? 's' : 'm', op, pc);
4063       break;
4064     }
4065   }
4066   i_end = i;
4067   end_pc = pc;
4068
4069   // 2nd pass: some analysis
4070   for (i = 0; i < i_end; i++) {
4071     opd = &ops[i];
4072
4073     // propagate T (TODO: DIV0U)
4074     if ((opd->op == OP_SETCLRT && !opd->imm) || opd->op == OP_BRANCH_CT)
4075       op_flags[i + 1] |= OF_T_CLEAR;
4076     else if ((opd->op == OP_SETCLRT && opd->imm) || opd->op == OP_BRANCH_CF)
4077       op_flags[i + 1] |= OF_T_SET;
4078
4079     if ((op_flags[i] & OF_BTARGET) || (opd->dest & BITMASK1(SHR_T)))
4080       op_flags[i] &= ~(OF_T_SET | OF_T_CLEAR);
4081     else
4082       op_flags[i + 1] |= op_flags[i] & (OF_T_SET | OF_T_CLEAR);
4083
4084     if ((opd->op == OP_BRANCH_CT && (op_flags[i] & OF_T_SET))
4085         || (opd->op == OP_BRANCH_CF && (op_flags[i] & OF_T_CLEAR)))
4086     {
4087       opd->op = OP_BRANCH;
4088       opd->cycles = 3;
4089       i_end = i + 1;
4090       if (op_flags[i + 1] & OF_DELAY_OP) {
4091         opd->cycles = 2;
4092         i_end++;
4093       }
4094     }
4095     else if (opd->op == OP_LOAD_POOL)
4096     {
4097       if (opd->imm < end_pc + MAX_LITERAL_OFFSET) {
4098         if (end_literals < opd->imm + opd->size * 2)
4099           end_literals = opd->imm + opd->size * 2;
4100       }
4101     }
4102   }
4103   end_pc = base_pc + i_end * 2;
4104   if (end_literals < end_pc)
4105     end_literals = end_pc;
4106
4107   // end_literals is used to decide to inline a literal or not
4108   // XXX: need better detection if this actually is used in write
4109   if (lowest_mova >= base_pc) {
4110     if (lowest_mova < end_literals) {
4111       dbg(1, "mova for %08x, block %08x", lowest_mova, base_pc);
4112       end_literals = end_pc;
4113     }
4114     if (lowest_mova < end_pc) {
4115       dbg(1, "warning: mova inside of blk for %08x, block %08x",
4116         lowest_mova, base_pc);
4117       end_literals = end_pc;
4118     }
4119   }
4120
4121   *end_pc_out = end_pc;
4122   if (end_literals_out != NULL)
4123     *end_literals_out = end_literals;
4124 }
4125
4126 // vim:shiftwidth=2:ts=2:expandtab