libpcsxcore/new_dynarec/new_dynarec.c

   1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
   2  *   Mupen64plus - new_dynarec.c                                           *
   3  *   Copyright (C) 2009-2011 Ari64                                         *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
  19  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  20
  21 #include <stdlib.h>
  22 #include <stdint.h> //include for uint64_t
  23 #include <assert.h>
  24 #include <errno.h>
  25 #include <sys/mman.h>
  26 #ifdef __MACH__
  27 #include <libkern/OSCacheControl.h>
  28 #endif
  29 #ifdef _3DS
  30 #include <3ds_utils.h>
  31 #endif
  32 #ifdef HAVE_LIBNX
  33 #include <switch.h>
  34 static Jit g_jit;
  35 #endif
  36
  37 #include "new_dynarec_config.h"
  38 #include "../psxhle.h"
  39 #include "../psxinterpreter.h"
  40 #include "../gte.h"
  41 #include "emu_if.h" // emulator interface
  42 #include "linkage_offsets.h"
  43 #include "compiler_features.h"
  44 #include "arm_features.h"
  45
  46 #ifndef ARRAY_SIZE
  47 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
  48 #endif
  49 #ifndef min
  50 #define min(a, b) ((b) < (a) ? (b) : (a))
  51 #endif
  52 #ifndef max
  53 #define max(a, b) ((b) > (a) ? (b) : (a))
  54 #endif
  55
  56 //#define DISASM
  57 //#define ASSEM_PRINT
  58 //#define REGMAP_PRINT // with DISASM only
  59 //#define INV_DEBUG_W
  60 //#define STAT_PRINT
  61
  62 #ifdef ASSEM_PRINT
  63 #define assem_debug printf
  64 #else
  65 #define assem_debug(...)
  66 #endif
  67 //#define inv_debug printf
  68 #define inv_debug(...)
  69
  70 #ifdef __i386__
  71 #include "assem_x86.h"
  72 #endif
  73 #ifdef __x86_64__
  74 #include "assem_x64.h"
  75 #endif
  76 #ifdef __arm__
  77 #include "assem_arm.h"
  78 #endif
  79 #ifdef __aarch64__
  80 #include "assem_arm64.h"
  81 #endif
  82
  83 #define RAM_SIZE 0x200000
  84 #define MAXBLOCK 2048
  85 #define MAX_OUTPUT_BLOCK_SIZE 262144
  86 #define EXPIRITY_OFFSET (MAX_OUTPUT_BLOCK_SIZE * 2)
  87 #define PAGE_COUNT 1024
  88
  89 #if defined(HAVE_CONDITIONAL_CALL) && !defined(DESTRUCTIVE_SHIFT)
  90 #define INVALIDATE_USE_COND_CALL
  91 #endif
  92
  93 #ifdef VITA
  94 // apparently Vita has a 16MB limit, so either we cut tc in half,
  95 // or use this hack (it's a hack because tc size was designed to be power-of-2)
  96 #define TC_REDUCE_BYTES 4096
  97 #else
  98 #define TC_REDUCE_BYTES 0
  99 #endif
 100
 101 struct ndrc_tramp
 102 {
 103   struct tramp_insns ops[2048 / sizeof(struct tramp_insns)];
 104   const void *f[2048 / sizeof(void *)];
 105 };
 106
 107 struct ndrc_mem
 108 {
 109   u_char translation_cache[(1 << TARGET_SIZE_2) - TC_REDUCE_BYTES];
 110   struct ndrc_tramp tramp;
 111 };
 112
 113 #ifdef BASE_ADDR_DYNAMIC
 114 static struct ndrc_mem *ndrc;
 115 #else
 116 static struct ndrc_mem ndrc_ __attribute__((aligned(4096)));
 117 static struct ndrc_mem *ndrc = &ndrc_;
 118 #endif
 119 #ifdef TC_WRITE_OFFSET
 120 # ifdef __GLIBC__
 121 # include <sys/types.h>
 122 # include <sys/stat.h>
 123 # include <fcntl.h>
 124 # include <unistd.h>
 125 # endif
 126 static long ndrc_write_ofs;
 127 #define NDRC_WRITE_OFFSET(x) (void *)((char *)(x) + ndrc_write_ofs)
 128 #else
 129 #define NDRC_WRITE_OFFSET(x) (x)
 130 #endif
 131
 132 // stubs
 133 enum stub_type {
 134   CC_STUB = 1,
 135   //FP_STUB = 2,
 136   LOADB_STUB = 3,
 137   LOADH_STUB = 4,
 138   LOADW_STUB = 5,
 139   //LOADD_STUB = 6,
 140   LOADBU_STUB = 7,
 141   LOADHU_STUB = 8,
 142   STOREB_STUB = 9,
 143   STOREH_STUB = 10,
 144   STOREW_STUB = 11,
 145   //STORED_STUB = 12,
 146   STORELR_STUB = 13,
 147   INVCODE_STUB = 14,
 148   OVERFLOW_STUB = 15,
 149   ALIGNMENT_STUB = 16,
 150 };
 151
 152 // regmap_pre[i]    - regs before [i] insn starts; dirty things here that
 153 //                    don't match .regmap will be written back
 154 // [i].regmap_entry - regs that must be set up if someone jumps here
 155 // [i].regmap       - regs [i] insn will read/(over)write
 156 // branch_regs[i].* - same as above but for branches, takes delay slot into account
 157 struct regstat
 158 {
 159   signed char regmap_entry[HOST_REGS];
 160   signed char regmap[HOST_REGS];
 161   u_int wasdirty;
 162   u_int dirty;
 163   u_int wasconst;                // before; for example 'lw r2, (r2)' wasconst is true
 164   u_int isconst;                 //  ... but isconst is false when r2 is known (hr)
 165   u_int loadedconst;             // host regs that have constants loaded
 166   u_int noevict;                 // can't evict this hr (alloced by current op)
 167   //u_int waswritten;              // MIPS regs that were used as store base before
 168   uint64_t u;
 169 };
 170
 171 struct ht_entry
 172 {
 173   u_int vaddr[2];
 174   void *tcaddr[2];
 175 };
 176
 177 struct code_stub
 178 {
 179   enum stub_type type;
 180   void *addr;
 181   void *retaddr;
 182   u_int a;
 183   uintptr_t b;
 184   uintptr_t c;
 185   u_int d;
 186   u_int e;
 187 };
 188
 189 struct link_entry
 190 {
 191   void *addr;
 192   u_int target;
 193   u_int internal;
 194 };
 195
 196 struct block_info
 197 {
 198   struct block_info *next;
 199   const void *source;
 200   const void *copy;
 201   u_int start; // vaddr of the block start
 202   u_int len;   // of the whole block source
 203   u_int tc_offs;
 204   //u_int tc_len;
 205   u_int reg_sv_flags;
 206   u_char is_dirty;
 207   u_char inv_near_misses;
 208   u_short jump_in_cnt;
 209   struct {
 210     u_int vaddr;
 211     void *addr;
 212   } jump_in[0];
 213 };
 214
 215 struct jump_info
 216 {
 217   int alloc;
 218   int count;
 219   struct {
 220     u_int target_vaddr;
 221     void *stub;
 222   } e[0];
 223 };
 224
 225 static struct decoded_insn
 226 {
 227   u_char itype;
 228   u_char opcode;   // bits 31-26
 229   u_char opcode2;  // (depends on opcode)
 230   u_char rs1;
 231   u_char rs2;
 232   u_char rt1;
 233   u_char rt2;
 234   u_char use_lt1:1;
 235   u_char bt:1;
 236   u_char ooo:1;
 237   u_char is_ds:1;
 238   u_char is_jump:1;
 239   u_char is_ujump:1;
 240   u_char is_load:1;
 241   u_char is_store:1;
 242   u_char is_delay_load:1; // is_load + MFC/CFC
 243   u_char is_exception:1;  // unconditional, also interp. fallback
 244   u_char may_except:1;    // might generate an exception
 245   u_char ls_type:2;       // load/store type (ls_width_type)
 246 } dops[MAXBLOCK];
 247
 248 enum ls_width_type {
 249   LS_8 = 0, LS_16, LS_32, LS_LR
 250 };
 251
 252 static struct compile_info
 253 {
 254   int imm;
 255   u_int ba;
 256   int ccadj;
 257   signed char min_free_regs;
 258   signed char addr;
 259   signed char reserved[2];
 260 } cinfo[MAXBLOCK];
 261
 262   static u_char *out;
 263   static char invalid_code[0x100000];
 264   static struct ht_entry hash_table[65536];
 265   static struct block_info *blocks[PAGE_COUNT];
 266   static struct jump_info *jumps[PAGE_COUNT];
 267   static u_int start;
 268   static u_int *source;
 269   static uint64_t gte_rs[MAXBLOCK]; // gte: 32 data and 32 ctl regs
 270   static uint64_t gte_rt[MAXBLOCK];
 271   static uint64_t gte_unneeded[MAXBLOCK];
 272   static u_int smrv[32]; // speculated MIPS register values
 273   static u_int smrv_strong; // mask or regs that are likely to have correct values
 274   static u_int smrv_weak; // same, but somewhat less likely
 275   static u_int smrv_strong_next; // same, but after current insn executes
 276   static u_int smrv_weak_next;
 277   static uint64_t unneeded_reg[MAXBLOCK];
 278   static uint64_t branch_unneeded_reg[MAXBLOCK];
 279   // see 'struct regstat' for a description
 280   static signed char regmap_pre[MAXBLOCK][HOST_REGS];
 281   // contains 'real' consts at [i] insn, but may differ from what's actually
 282   // loaded in host reg as 'final' value is always loaded, see get_final_value()
 283   static uint32_t current_constmap[HOST_REGS];
 284   static uint32_t constmap[MAXBLOCK][HOST_REGS];
 285   static struct regstat regs[MAXBLOCK];
 286   static struct regstat branch_regs[MAXBLOCK];
 287   static int slen;
 288   static void *instr_addr[MAXBLOCK];
 289   static struct link_entry link_addr[MAXBLOCK];
 290   static int linkcount;
 291   static struct code_stub stubs[MAXBLOCK*3];
 292   static int stubcount;
 293   static u_int literals[1024][2];
 294   static int literalcount;
 295   static int is_delayslot;
 296   static char shadow[1048576]  __attribute__((aligned(16)));
 297   static void *copy;
 298   static u_int expirep;
 299   static u_int stop_after_jal;
 300   static u_int f1_hack;
 301 #ifdef STAT_PRINT
 302   static int stat_bc_direct;
 303   static int stat_bc_pre;
 304   static int stat_bc_restore;
 305   static int stat_ht_lookups;
 306   static int stat_jump_in_lookups;
 307   static int stat_restore_tries;
 308   static int stat_restore_compares;
 309   static int stat_inv_addr_calls;
 310   static int stat_inv_hits;
 311   static int stat_blocks;
 312   static int stat_links;
 313   #define stat_inc(s) s++
 314   #define stat_dec(s) s--
 315   #define stat_clear(s) s = 0
 316 #else
 317   #define stat_inc(s)
 318   #define stat_dec(s)
 319   #define stat_clear(s)
 320 #endif
 321
 322   int new_dynarec_hacks;
 323   int new_dynarec_hacks_pergame;
 324   int new_dynarec_hacks_old;
 325   int new_dynarec_did_compile;
 326
 327   #define HACK_ENABLED(x) ((new_dynarec_hacks | new_dynarec_hacks_pergame) & (x))
 328
 329   extern int cycle_count; // ... until end of the timeslice, counts -N -> 0 (CCREG)
 330   extern int last_count;  // last absolute target, often = next_interupt
 331   extern int pcaddr;
 332   extern int pending_exception;
 333   extern int branch_target;
 334   extern uintptr_t ram_offset;
 335   extern uintptr_t mini_ht[32][2];
 336
 337   /* registers that may be allocated */
 338   /* 1-31 gpr */
 339 #define LOREG 32 // lo
 340 #define HIREG 33 // hi
 341 //#define FSREG 34 // FPU status (FCSR)
 342 //#define CSREG 35 // Coprocessor status
 343 #define CCREG 36 // Cycle count
 344 #define INVCP 37 // Pointer to invalid_code
 345 //#define MMREG 38 // Pointer to memory_map
 346 #define ROREG 39 // ram offset (if psxM != 0x80000000)
 347 #define TEMPREG 40
 348 #define FTEMP 40 // Load/store temporary register (was fpu)
 349 #define PTEMP 41 // Prefetch temporary register
 350 //#define TLREG 42 // TLB mapping offset
 351 #define RHASH 43 // Return address hash
 352 #define RHTBL 44 // Return address hash table address
 353 #define RTEMP 45 // JR/JALR address register
 354 #define MAXREG 45
 355 #define AGEN1 46 // Address generation temporary register (pass5b_preallocate2)
 356 //#define AGEN2 47 // Address generation temporary register
 357
 358   /* instruction types */
 359 #define NOP 0     // No operation
 360 #define LOAD 1    // Load
 361 #define STORE 2   // Store
 362 #define LOADLR 3  // Unaligned load
 363 #define STORELR 4 // Unaligned store
 364 #define MOV 5     // Move (hi/lo only)
 365 #define ALU 6     // Arithmetic/logic
 366 #define MULTDIV 7 // Multiply/divide
 367 #define SHIFT 8   // Shift by register
 368 #define SHIFTIMM 9// Shift by immediate
 369 #define IMM16 10  // 16-bit immediate
 370 #define RJUMP 11  // Unconditional jump to register
 371 #define UJUMP 12  // Unconditional jump
 372 #define CJUMP 13  // Conditional branch (BEQ/BNE/BGTZ/BLEZ)
 373 #define SJUMP 14  // Conditional branch (regimm format)
 374 #define COP0 15   // Coprocessor 0
 375 #define RFE 16
 376 #define SYSCALL 22// SYSCALL,BREAK
 377 #define OTHER 23  // Other/unknown - do nothing
 378 #define HLECALL 26// PCSX fake opcodes for HLE
 379 #define COP2 27   // Coprocessor 2 move
 380 #define C2LS 28   // Coprocessor 2 load/store
 381 #define C2OP 29   // Coprocessor 2 operation
 382 #define INTCALL 30// Call interpreter to handle rare corner cases
 383
 384   /* branch codes */
 385 #define TAKEN 1
 386 #define NOTTAKEN 2
 387
 388 #define DJT_1 (void *)1l // no function, just a label in assem_debug log
 389 #define DJT_2 (void *)2l
 390
 391 // asm linkage
 392 void dyna_linker();
 393 void cc_interrupt();
 394 void jump_syscall   (u_int u0, u_int u1, u_int pc);
 395 void jump_syscall_ds(u_int u0, u_int u1, u_int pc);
 396 void jump_break   (u_int u0, u_int u1, u_int pc);
 397 void jump_break_ds(u_int u0, u_int u1, u_int pc);
 398 void jump_overflow   (u_int u0, u_int u1, u_int pc);
 399 void jump_overflow_ds(u_int u0, u_int u1, u_int pc);
 400 void jump_addrerror   (u_int cause, u_int addr, u_int pc);
 401 void jump_addrerror_ds(u_int cause, u_int addr, u_int pc);
 402 void jump_to_new_pc();
 403 void call_gteStall();
 404 void new_dyna_leave();
 405
 406 void *ndrc_get_addr_ht_param(u_int vaddr, int can_compile);
 407 void *ndrc_get_addr_ht(u_int vaddr);
 408 void ndrc_add_jump_out(u_int vaddr, void *src);
 409 void ndrc_write_invalidate_one(u_int addr);
 410 static void ndrc_write_invalidate_many(u_int addr, u_int end);
 411
 412 static int new_recompile_block(u_int addr);
 413 static void invalidate_block(struct block_info *block);
 414 static void exception_assemble(int i, const struct regstat *i_regs, int ccadj_);
 415
 416 // Needed by assembler
 417 static void wb_register(signed char r, const signed char regmap[], u_int dirty);
 418 static void wb_dirtys(const signed char i_regmap[], u_int i_dirty);
 419 static void wb_needed_dirtys(const signed char i_regmap[], u_int i_dirty, int addr);
 420 static void load_all_regs(const signed char i_regmap[]);
 421 static void load_needed_regs(const signed char i_regmap[], const signed char next_regmap[]);
 422 static void load_regs_entry(int t);
 423 static void load_all_consts(const signed char regmap[], u_int dirty, int i);
 424 static u_int get_host_reglist(const signed char *regmap);
 425
 426 static int get_final_value(int hr, int i, u_int *value);
 427 static void add_stub(enum stub_type type, void *addr, void *retaddr,
 428   u_int a, uintptr_t b, uintptr_t c, u_int d, u_int e);
 429 static void add_stub_r(enum stub_type type, void *addr, void *retaddr,
 430   int i, int addr_reg, const struct regstat *i_regs, int ccadj, u_int reglist);
 431 static void add_to_linker(void *addr, u_int target, int ext);
 432 static void *get_direct_memhandler(void *table, u_int addr,
 433   enum stub_type type, uintptr_t *addr_host);
 434 static void cop2_do_stall_check(u_int op, int i, const struct regstat *i_regs, u_int reglist);
 435 static void pass_args(int a0, int a1);
 436 static void emit_far_jump(const void *f);
 437 static void emit_far_call(const void *f);
 438
 439 #ifdef VITA
 440 #include <psp2/kernel/sysmem.h>
 441 static int sceBlock;
 442 // note: this interacts with RetroArch's Vita bootstrap code: bootstrap/vita/sbrk.c
 443 extern int getVMBlock();
 444 int _newlib_vm_size_user = sizeof(*ndrc);
 445 #endif
 446
 447 static void mprotect_w_x(void *start, void *end, int is_x)
 448 {
 449 #ifdef NO_WRITE_EXEC
 450   #if defined(VITA)
 451   // *Open* enables write on all memory that was
 452   // allocated by sceKernelAllocMemBlockForVM()?
 453   if (is_x)
 454     sceKernelCloseVMDomain();
 455   else
 456     sceKernelOpenVMDomain();
 457   #elif defined(HAVE_LIBNX)
 458   Result rc;
 459   // check to avoid the full flush in jitTransitionToExecutable()
 460   if (g_jit.type != JitType_CodeMemory) {
 461     if (is_x)
 462       rc = jitTransitionToExecutable(&g_jit);
 463     else
 464       rc = jitTransitionToWritable(&g_jit);
 465     if (R_FAILED(rc))
 466       ;//SysPrintf("jitTransition %d %08x\n", is_x, rc);
 467   }
 468   #elif defined(TC_WRITE_OFFSET)
 469   // separated rx and rw areas are always available
 470   #else
 471   u_long mstart = (u_long)start & ~4095ul;
 472   u_long mend = (u_long)end;
 473   if (mprotect((void *)mstart, mend - mstart,
 474                PROT_READ | (is_x ? PROT_EXEC : PROT_WRITE)) != 0)
 475     SysPrintf("mprotect(%c) failed: %s\n", is_x ? 'x' : 'w', strerror(errno));
 476   #endif
 477 #endif
 478 }
 479
 480 static void start_tcache_write(void *start, void *end)
 481 {
 482   mprotect_w_x(start, end, 0);
 483 }
 484
 485 static void end_tcache_write(void *start, void *end)
 486 {
 487 #if defined(__arm__) || defined(__aarch64__)
 488   size_t len = (char *)end - (char *)start;
 489   #if   defined(__BLACKBERRY_QNX__)
 490   msync(start, len, MS_SYNC | MS_CACHE_ONLY | MS_INVALIDATE_ICACHE);
 491   #elif defined(__MACH__)
 492   sys_cache_control(kCacheFunctionPrepareForExecution, start, len);
 493   #elif defined(VITA)
 494   sceKernelSyncVMDomain(sceBlock, start, len);
 495   #elif defined(_3DS)
 496   ctr_flush_invalidate_cache();
 497   #elif defined(HAVE_LIBNX)
 498   if (g_jit.type == JitType_CodeMemory) {
 499     armDCacheClean(start, len);
 500     armICacheInvalidate((char *)start - ndrc_write_ofs, len);
 501     // as of v4.2.1 libnx lacks isb
 502     __asm__ volatile("isb" ::: "memory");
 503   }
 504   #elif defined(__aarch64__)
 505   // as of 2021, __clear_cache() is still broken on arm64
 506   // so here is a custom one :(
 507   clear_cache_arm64(start, end);
 508   #else
 509   __clear_cache(start, end);
 510   #endif
 511   (void)len;
 512 #endif
 513
 514   mprotect_w_x(start, end, 1);
 515 }
 516
 517 static void *start_block(void)
 518 {
 519   u_char *end = out + MAX_OUTPUT_BLOCK_SIZE;
 520   if (end > ndrc->translation_cache + sizeof(ndrc->translation_cache))
 521     end = ndrc->translation_cache + sizeof(ndrc->translation_cache);
 522   start_tcache_write(NDRC_WRITE_OFFSET(out), NDRC_WRITE_OFFSET(end));
 523   return out;
 524 }
 525
 526 static void end_block(void *start)
 527 {
 528   end_tcache_write(NDRC_WRITE_OFFSET(start), NDRC_WRITE_OFFSET(out));
 529 }
 530
 531 #ifdef NDRC_CACHE_FLUSH_ALL
 532
 533 static int needs_clear_cache;
 534
 535 static void mark_clear_cache(void *target)
 536 {
 537   if (!needs_clear_cache) {
 538     start_tcache_write(NDRC_WRITE_OFFSET(ndrc), NDRC_WRITE_OFFSET(ndrc + 1));
 539     needs_clear_cache = 1;
 540   }
 541 }
 542
 543 static void do_clear_cache(void)
 544 {
 545   if (needs_clear_cache) {
 546     end_tcache_write(NDRC_WRITE_OFFSET(ndrc), NDRC_WRITE_OFFSET(ndrc + 1));
 547     needs_clear_cache = 0;
 548   }
 549 }
 550
 551 #else
 552
 553 // also takes care of w^x mappings when patching code
 554 static u_int needs_clear_cache[1<<(TARGET_SIZE_2-17)];
 555
 556 static void mark_clear_cache(void *target)
 557 {
 558   uintptr_t offset = (u_char *)target - ndrc->translation_cache;
 559   u_int mask = 1u << ((offset >> 12) & 31);
 560   if (!(needs_clear_cache[offset >> 17] & mask)) {
 561     char *start = (char *)NDRC_WRITE_OFFSET((uintptr_t)target & ~4095l);
 562     start_tcache_write(start, start + 4095);
 563     needs_clear_cache[offset >> 17] |= mask;
 564   }
 565 }
 566
 567 // Clearing the cache is rather slow on ARM Linux, so mark the areas
 568 // that need to be cleared, and then only clear these areas once.
 569 static void do_clear_cache(void)
 570 {
 571   int i, j;
 572   for (i = 0; i < (1<<(TARGET_SIZE_2-17)); i++)
 573   {
 574     u_int bitmap = needs_clear_cache[i];
 575     if (!bitmap)
 576       continue;
 577     for (j = 0; j < 32; j++)
 578     {
 579       u_char *start, *end;
 580       if (!(bitmap & (1u << j)))
 581         continue;
 582
 583       start = ndrc->translation_cache + i*131072 + j*4096;
 584       end = start + 4095;
 585       for (j++; j < 32; j++) {
 586         if (!(bitmap & (1u << j)))
 587           break;
 588         end += 4096;
 589       }
 590       end_tcache_write(NDRC_WRITE_OFFSET(start), NDRC_WRITE_OFFSET(end));
 591     }
 592     needs_clear_cache[i] = 0;
 593   }
 594 }
 595
 596 #endif // NDRC_CACHE_FLUSH_ALL
 597
 598 #define NO_CYCLE_PENALTY_THR 12
 599
 600 int cycle_multiplier_old;
 601 static int cycle_multiplier_active;
 602
 603 static int CLOCK_ADJUST(int x)
 604 {
 605   int m = cycle_multiplier_active;
 606   int s = (x >> 31) | 1;
 607   return (x * m + s * 50) / 100;
 608 }
 609
 610 static int ds_writes_rjump_rs(int i)
 611 {
 612   return dops[i].rs1 != 0
 613    && (dops[i].rs1 == dops[i+1].rt1 || dops[i].rs1 == dops[i+1].rt2
 614     || dops[i].rs1 == dops[i].rt1); // overwrites itself - same effect
 615 }
 616
 617 // psx addr mirror masking (for invalidation)
 618 static u_int pmmask(u_int vaddr)
 619 {
 620   vaddr &= ~0xe0000000;
 621   if (vaddr < 0x01000000)
 622     vaddr &= ~0x00e00000; // RAM mirrors
 623   return vaddr;
 624 }
 625
 626 static u_int get_page(u_int vaddr)
 627 {
 628   u_int page = pmmask(vaddr) >> 12;
 629   if (page >= PAGE_COUNT / 2)
 630     page = PAGE_COUNT / 2 + (page & (PAGE_COUNT / 2 - 1));
 631   return page;
 632 }
 633
 634 // get a page for looking for a block that has vaddr
 635 // (needed because the block may start in previous page)
 636 static u_int get_page_prev(u_int vaddr)
 637 {
 638   assert(MAXBLOCK <= (1 << 12));
 639   u_int page = get_page(vaddr);
 640   if (page & 511)
 641     page--;
 642   return page;
 643 }
 644
 645 static struct ht_entry *hash_table_get(u_int vaddr)
 646 {
 647   return &hash_table[((vaddr>>16)^vaddr)&0xFFFF];
 648 }
 649
 650 static void hash_table_add(u_int vaddr, void *tcaddr)
 651 {
 652   struct ht_entry *ht_bin = hash_table_get(vaddr);
 653   assert(tcaddr);
 654   ht_bin->vaddr[1] = ht_bin->vaddr[0];
 655   ht_bin->tcaddr[1] = ht_bin->tcaddr[0];
 656   ht_bin->vaddr[0] = vaddr;
 657   ht_bin->tcaddr[0] = tcaddr;
 658 }
 659
 660 static void hash_table_remove(int vaddr)
 661 {
 662   //printf("remove hash: %x\n",vaddr);
 663   struct ht_entry *ht_bin = hash_table_get(vaddr);
 664   if (ht_bin->vaddr[1] == vaddr) {
 665     ht_bin->vaddr[1] = -1;
 666     ht_bin->tcaddr[1] = NULL;
 667   }
 668   if (ht_bin->vaddr[0] == vaddr) {
 669     ht_bin->vaddr[0] = ht_bin->vaddr[1];
 670     ht_bin->tcaddr[0] = ht_bin->tcaddr[1];
 671     ht_bin->vaddr[1] = -1;
 672     ht_bin->tcaddr[1] = NULL;
 673   }
 674 }
 675
 676 static void mark_invalid_code(u_int vaddr, u_int len, char invalid)
 677 {
 678   u_int vaddr_m = vaddr & 0x1fffffff;
 679   u_int i, j;
 680   for (i = vaddr_m & ~0xfff; i < vaddr_m + len; i += 0x1000) {
 681     // ram mirrors, but should not hurt bios
 682     for (j = 0; j < 0x800000; j += 0x200000) {
 683       invalid_code[(i|j) >> 12] =
 684       invalid_code[(i|j|0x80000000u) >> 12] =
 685       invalid_code[(i|j|0xa0000000u) >> 12] = invalid;
 686     }
 687   }
 688   if (!invalid && vaddr + len > inv_code_start && vaddr <= inv_code_end)
 689     inv_code_start = inv_code_end = ~0;
 690 }
 691
 692 static int doesnt_expire_soon(u_char *tcaddr)
 693 {
 694   u_int diff = (u_int)(tcaddr - out) & ((1u << TARGET_SIZE_2) - 1u);
 695   return diff > EXPIRITY_OFFSET + MAX_OUTPUT_BLOCK_SIZE;
 696 }
 697
 698 static unused void check_for_block_changes(u_int start, u_int end)
 699 {
 700   u_int start_page = get_page_prev(start);
 701   u_int end_page = get_page(end - 1);
 702   u_int page;
 703
 704   for (page = start_page; page <= end_page; page++) {
 705     struct block_info *block;
 706     for (block = blocks[page]; block != NULL; block = block->next) {
 707       if (block->is_dirty)
 708         continue;
 709       if (memcmp(block->source, block->copy, block->len)) {
 710         printf("bad block %08x-%08x %016llx %016llx @%08x\n",
 711           block->start, block->start + block->len,
 712           *(long long *)block->source, *(long long *)block->copy, psxRegs.pc);
 713         fflush(stdout);
 714         abort();
 715       }
 716     }
 717   }
 718 }
 719
 720 static void *try_restore_block(u_int vaddr, u_int start_page, u_int end_page)
 721 {
 722   void *found_clean = NULL;
 723   u_int i, page;
 724
 725   stat_inc(stat_restore_tries);
 726   for (page = start_page; page <= end_page; page++) {
 727     struct block_info *block;
 728     for (block = blocks[page]; block != NULL; block = block->next) {
 729       if (vaddr < block->start)
 730         break;
 731       if (!block->is_dirty || vaddr >= block->start + block->len)
 732         continue;
 733       for (i = 0; i < block->jump_in_cnt; i++)
 734         if (block->jump_in[i].vaddr == vaddr)
 735           break;
 736       if (i == block->jump_in_cnt)
 737         continue;
 738       assert(block->source && block->copy);
 739       stat_inc(stat_restore_compares);
 740       if (memcmp(block->source, block->copy, block->len))
 741         continue;
 742
 743       block->is_dirty = block->inv_near_misses = 0;
 744       found_clean = block->jump_in[i].addr;
 745       hash_table_add(vaddr, found_clean);
 746       mark_invalid_code(block->start, block->len, 0);
 747       stat_inc(stat_bc_restore);
 748       inv_debug("INV: restored %08x %p (%d)\n", vaddr, found_clean, block->jump_in_cnt);
 749       return found_clean;
 750     }
 751   }
 752   return NULL;
 753 }
 754
 755 // this doesn't normally happen
 756 static noinline u_int generate_exception(u_int pc)
 757 {
 758   //if (execBreakCheck(&psxRegs, pc))
 759   //  return psxRegs.pc;
 760
 761   // generate an address or bus error
 762   psxRegs.CP0.n.Cause &= 0x300;
 763   psxRegs.CP0.n.EPC = pc;
 764   if (pc & 3) {
 765     psxRegs.CP0.n.Cause |= R3000E_AdEL << 2;
 766     psxRegs.CP0.n.BadVAddr = pc;
 767 #ifdef DRC_DBG
 768     last_count -= 2;
 769 #endif
 770   } else
 771     psxRegs.CP0.n.Cause |= R3000E_IBE << 2;
 772   return (psxRegs.pc = 0x80000080);
 773 }
 774
 775 // Get address from virtual address
 776 // This is called from the recompiled JR/JALR instructions
 777 static void noinline *get_addr(u_int vaddr, int can_compile)
 778 {
 779   u_int start_page = get_page_prev(vaddr);
 780   u_int i, page, end_page = get_page(vaddr);
 781   void *found_clean = NULL;
 782
 783   stat_inc(stat_jump_in_lookups);
 784   for (page = start_page; page <= end_page; page++) {
 785     const struct block_info *block;
 786     for (block = blocks[page]; block != NULL; block = block->next) {
 787       if (vaddr < block->start)
 788         break;
 789       if (block->is_dirty || vaddr >= block->start + block->len)
 790         continue;
 791       for (i = 0; i < block->jump_in_cnt; i++)
 792         if (block->jump_in[i].vaddr == vaddr)
 793           break;
 794       if (i == block->jump_in_cnt)
 795         continue;
 796       found_clean = block->jump_in[i].addr;
 797       hash_table_add(vaddr, found_clean);
 798       return found_clean;
 799     }
 800   }
 801   found_clean = try_restore_block(vaddr, start_page, end_page);
 802   if (found_clean)
 803     return found_clean;
 804
 805   if (!can_compile)
 806     return NULL;
 807
 808   int r = new_recompile_block(vaddr);
 809   if (likely(r == 0))
 810     return ndrc_get_addr_ht(vaddr);
 811
 812   return ndrc_get_addr_ht(generate_exception(vaddr));
 813 }
 814
 815 // Look up address in hash table first
 816 void *ndrc_get_addr_ht_param(u_int vaddr, int can_compile)
 817 {
 818   //check_for_block_changes(vaddr, vaddr + MAXBLOCK);
 819   const struct ht_entry *ht_bin = hash_table_get(vaddr);
 820   u_int vaddr_a = vaddr & ~3;
 821   stat_inc(stat_ht_lookups);
 822   if (ht_bin->vaddr[0] == vaddr_a) return ht_bin->tcaddr[0];
 823   if (ht_bin->vaddr[1] == vaddr_a) return ht_bin->tcaddr[1];
 824   return get_addr(vaddr, can_compile);
 825 }
 826
 827 void *ndrc_get_addr_ht(u_int vaddr)
 828 {
 829   return ndrc_get_addr_ht_param(vaddr, 1);
 830 }
 831
 832 static void clear_all_regs(signed char regmap[])
 833 {
 834   memset(regmap, -1, sizeof(regmap[0]) * HOST_REGS);
 835 }
 836
 837 // get_reg: get allocated host reg from mips reg
 838 // returns -1 if no such mips reg was allocated
 839 #if defined(__arm__) && defined(HAVE_ARMV6) && HOST_REGS == 13 && EXCLUDE_REG == 11
 840
 841 extern signed char get_reg(const signed char regmap[], signed char r);
 842
 843 #else
 844
 845 static signed char get_reg(const signed char regmap[], signed char r)
 846 {
 847   int hr;
 848   for (hr = 0; hr < HOST_REGS; hr++) {
 849     if (hr == EXCLUDE_REG)
 850       continue;
 851     if (regmap[hr] == r)
 852       return hr;
 853   }
 854   return -1;
 855 }
 856
 857 #endif
 858
 859 // get reg suitable for writing
 860 static signed char get_reg_w(const signed char regmap[], signed char r)
 861 {
 862   return r == 0 ? -1 : get_reg(regmap, r);
 863 }
 864
 865 // get reg as mask bit (1 << hr)
 866 static u_int get_regm(const signed char regmap[], signed char r)
 867 {
 868   return (1u << (get_reg(regmap, r) & 31)) & ~(1u << 31);
 869 }
 870
 871 static signed char get_reg_temp(const signed char regmap[])
 872 {
 873   int hr;
 874   for (hr = 0; hr < HOST_REGS; hr++) {
 875     if (hr == EXCLUDE_REG)
 876       continue;
 877     if (regmap[hr] == (signed char)-1)
 878       return hr;
 879   }
 880   return -1;
 881 }
 882
 883 // Find a register that is available for two consecutive cycles
 884 static signed char get_reg2(signed char regmap1[], const signed char regmap2[], int r)
 885 {
 886   int hr;
 887   for (hr=0;hr<HOST_REGS;hr++) if(hr!=EXCLUDE_REG&&regmap1[hr]==r&&regmap2[hr]==r) return hr;
 888   return -1;
 889 }
 890
 891 // reverse reg map: mips -> host
 892 #define RRMAP_SIZE 64
 893 static void make_rregs(const signed char regmap[], signed char rrmap[RRMAP_SIZE],
 894   u_int *regs_can_change)
 895 {
 896   u_int r, hr, hr_can_change = 0;
 897   memset(rrmap, -1, RRMAP_SIZE);
 898   for (hr = 0; hr < HOST_REGS; )
 899   {
 900     r = regmap[hr];
 901     rrmap[r & (RRMAP_SIZE - 1)] = hr;
 902     // only add mips $1-$31+$lo, others shifted out
 903     hr_can_change |= (uint64_t)1 << (hr + ((r - 1) & 32));
 904     hr++;
 905     if (hr == EXCLUDE_REG)
 906       hr++;
 907   }
 908   hr_can_change |= 1u << (rrmap[33] & 31);
 909   hr_can_change |= 1u << (rrmap[CCREG] & 31);
 910   hr_can_change &= ~(1u << 31);
 911   *regs_can_change = hr_can_change;
 912 }
 913
 914 // same as get_reg, but takes rrmap
 915 static signed char get_rreg(signed char rrmap[RRMAP_SIZE], signed char r)
 916 {
 917   assert(0 <= r && r < RRMAP_SIZE);
 918   return rrmap[r];
 919 }
 920
 921 static int count_free_regs(const signed char regmap[])
 922 {
 923   int count=0;
 924   int hr;
 925   for(hr=0;hr<HOST_REGS;hr++)
 926   {
 927     if(hr!=EXCLUDE_REG) {
 928       if(regmap[hr]<0) count++;
 929     }
 930   }
 931   return count;
 932 }
 933
 934 static void dirty_reg(struct regstat *cur, signed char reg)
 935 {
 936   int hr;
 937   if (!reg) return;
 938   hr = get_reg(cur->regmap, reg);
 939   if (hr >= 0)
 940     cur->dirty |= 1<<hr;
 941 }
 942
 943 static void set_const(struct regstat *cur, signed char reg, uint32_t value)
 944 {
 945   int hr;
 946   if (!reg) return;
 947   hr = get_reg(cur->regmap, reg);
 948   if (hr >= 0) {
 949     cur->isconst |= 1<<hr;
 950     current_constmap[hr] = value;
 951   }
 952 }
 953
 954 static void clear_const(struct regstat *cur, signed char reg)
 955 {
 956   int hr;
 957   if (!reg) return;
 958   hr = get_reg(cur->regmap, reg);
 959   if (hr >= 0)
 960     cur->isconst &= ~(1<<hr);
 961 }
 962
 963 static int is_const(const struct regstat *cur, signed char reg)
 964 {
 965   int hr;
 966   if (reg < 0) return 0;
 967   if (!reg) return 1;
 968   hr = get_reg(cur->regmap, reg);
 969   if (hr >= 0)
 970     return (cur->isconst>>hr)&1;
 971   return 0;
 972 }
 973
 974 static uint32_t get_const(const struct regstat *cur, signed char reg)
 975 {
 976   int hr;
 977   if (!reg) return 0;
 978   hr = get_reg(cur->regmap, reg);
 979   if (hr >= 0)
 980     return current_constmap[hr];
 981
 982   SysPrintf("Unknown constant in r%d\n", reg);
 983   abort();
 984 }
 985
 986 // Least soon needed registers
 987 // Look at the next ten instructions and see which registers
 988 // will be used.  Try not to reallocate these.
 989 static void lsn(u_char hsn[], int i)
 990 {
 991   int j;
 992   int b=-1;
 993   for(j=0;j<9;j++)
 994   {
 995     if(i+j>=slen) {
 996       j=slen-i-1;
 997       break;
 998     }
 999     if (dops[i+j].is_ujump)
1000     {
1001       // Don't go past an unconditonal jump
1002       j++;
1003       break;
1004     }
1005   }
1006   for(;j>=0;j--)
1007   {
1008     if(dops[i+j].rs1) hsn[dops[i+j].rs1]=j;
1009     if(dops[i+j].rs2) hsn[dops[i+j].rs2]=j;
1010     if(dops[i+j].rt1) hsn[dops[i+j].rt1]=j;
1011     if(dops[i+j].rt2) hsn[dops[i+j].rt2]=j;
1012     if(dops[i+j].itype==STORE || dops[i+j].itype==STORELR) {
1013       // Stores can allocate zero
1014       hsn[dops[i+j].rs1]=j;
1015       hsn[dops[i+j].rs2]=j;
1016     }
1017     if (ram_offset && (dops[i+j].is_load || dops[i+j].is_store))
1018       hsn[ROREG] = j;
1019     // On some architectures stores need invc_ptr
1020     #if defined(HOST_IMM8)
1021     if (dops[i+j].is_store)
1022       hsn[INVCP] = j;
1023     #endif
1024     if(i+j>=0&&(dops[i+j].itype==UJUMP||dops[i+j].itype==CJUMP||dops[i+j].itype==SJUMP))
1025     {
1026       hsn[CCREG]=j;
1027       b=j;
1028     }
1029   }
1030   if(b>=0)
1031   {
1032     if(cinfo[i+b].ba>=start && cinfo[i+b].ba<(start+slen*4))
1033     {
1034       // Follow first branch
1035       int t=(cinfo[i+b].ba-start)>>2;
1036       j=7-b;if(t+j>=slen) j=slen-t-1;
1037       for(;j>=0;j--)
1038       {
1039         if(dops[t+j].rs1) if(hsn[dops[t+j].rs1]>j+b+2) hsn[dops[t+j].rs1]=j+b+2;
1040         if(dops[t+j].rs2) if(hsn[dops[t+j].rs2]>j+b+2) hsn[dops[t+j].rs2]=j+b+2;
1041         //if(dops[t+j].rt1) if(hsn[dops[t+j].rt1]>j+b+2) hsn[dops[t+j].rt1]=j+b+2;
1042         //if(dops[t+j].rt2) if(hsn[dops[t+j].rt2]>j+b+2) hsn[dops[t+j].rt2]=j+b+2;
1043       }
1044     }
1045     // TODO: preferred register based on backward branch
1046   }
1047   // Delay slot should preferably not overwrite branch conditions or cycle count
1048   if (i > 0 && dops[i-1].is_jump) {
1049     if(dops[i-1].rs1) if(hsn[dops[i-1].rs1]>1) hsn[dops[i-1].rs1]=1;
1050     if(dops[i-1].rs2) if(hsn[dops[i-1].rs2]>1) hsn[dops[i-1].rs2]=1;
1051     hsn[CCREG]=1;
1052     // ...or hash tables
1053     hsn[RHASH]=1;
1054     hsn[RHTBL]=1;
1055   }
1056   // Coprocessor load/store needs FTEMP, even if not declared
1057   if(dops[i].itype==C2LS) {
1058     hsn[FTEMP]=0;
1059   }
1060   // Load/store L/R also uses FTEMP as a temporary register
1061   if (dops[i].itype == LOADLR || dops[i].itype == STORELR) {
1062     hsn[FTEMP]=0;
1063   }
1064   // Don't remove the miniht registers
1065   if(dops[i].itype==UJUMP||dops[i].itype==RJUMP)
1066   {
1067     hsn[RHASH]=0;
1068     hsn[RHTBL]=0;
1069   }
1070 }
1071
1072 // We only want to allocate registers if we're going to use them again soon
1073 static int needed_again(int r, int i)
1074 {
1075   int j;
1076   int b=-1;
1077   int rn=10;
1078
1079   if (i > 0 && dops[i-1].is_ujump)
1080   {
1081     if(cinfo[i-1].ba<start || cinfo[i-1].ba>start+slen*4-4)
1082       return 0; // Don't need any registers if exiting the block
1083   }
1084   for(j=0;j<9;j++)
1085   {
1086     if(i+j>=slen) {
1087       j=slen-i-1;
1088       break;
1089     }
1090     if (dops[i+j].is_ujump)
1091     {
1092       // Don't go past an unconditonal jump
1093       j++;
1094       break;
1095     }
1096     if (dops[i+j].is_exception)
1097     {
1098       break;
1099     }
1100   }
1101   for(;j>=1;j--)
1102   {
1103     if(dops[i+j].rs1==r) rn=j;
1104     if(dops[i+j].rs2==r) rn=j;
1105     if((unneeded_reg[i+j]>>r)&1) rn=10;
1106     if(i+j>=0&&(dops[i+j].itype==UJUMP||dops[i+j].itype==CJUMP||dops[i+j].itype==SJUMP))
1107     {
1108       b=j;
1109     }
1110   }
1111   if(rn<10) return 1;
1112   (void)b;
1113   return 0;
1114 }
1115
1116 // Try to match register allocations at the end of a loop with those
1117 // at the beginning
1118 static int loop_reg(int i, int r, int hr)
1119 {
1120   int j,k;
1121   for(j=0;j<9;j++)
1122   {
1123     if(i+j>=slen) {
1124       j=slen-i-1;
1125       break;
1126     }
1127     if (dops[i+j].is_ujump)
1128     {
1129       // Don't go past an unconditonal jump
1130       j++;
1131       break;
1132     }
1133   }
1134   k=0;
1135   if(i>0){
1136     if(dops[i-1].itype==UJUMP||dops[i-1].itype==CJUMP||dops[i-1].itype==SJUMP)
1137       k--;
1138   }
1139   for(;k<j;k++)
1140   {
1141     assert(r < 64);
1142     if((unneeded_reg[i+k]>>r)&1) return hr;
1143     if(i+k>=0&&(dops[i+k].itype==UJUMP||dops[i+k].itype==CJUMP||dops[i+k].itype==SJUMP))
1144     {
1145       if(cinfo[i+k].ba>=start && cinfo[i+k].ba<(start+i*4))
1146       {
1147         int t=(cinfo[i+k].ba-start)>>2;
1148         int reg=get_reg(regs[t].regmap_entry,r);
1149         if(reg>=0) return reg;
1150         //reg=get_reg(regs[t+1].regmap_entry,r);
1151         //if(reg>=0) return reg;
1152       }
1153     }
1154   }
1155   return hr;
1156 }
1157
1158
1159 // Allocate every register, preserving source/target regs
1160 static void alloc_all(struct regstat *cur,int i)
1161 {
1162   int hr;
1163
1164   for(hr=0;hr<HOST_REGS;hr++) {
1165     if(hr!=EXCLUDE_REG) {
1166       if((cur->regmap[hr]!=dops[i].rs1)&&(cur->regmap[hr]!=dops[i].rs2)&&
1167          (cur->regmap[hr]!=dops[i].rt1)&&(cur->regmap[hr]!=dops[i].rt2))
1168       {
1169         cur->regmap[hr]=-1;
1170         cur->dirty&=~(1<<hr);
1171       }
1172       // Don't need zeros
1173       if(cur->regmap[hr]==0)
1174       {
1175         cur->regmap[hr]=-1;
1176         cur->dirty&=~(1<<hr);
1177       }
1178     }
1179   }
1180 }
1181
1182 #ifndef NDEBUG
1183 static int host_tempreg_in_use;
1184
1185 static void host_tempreg_acquire(void)
1186 {
1187   assert(!host_tempreg_in_use);
1188   host_tempreg_in_use = 1;
1189 }
1190
1191 static void host_tempreg_release(void)
1192 {
1193   host_tempreg_in_use = 0;
1194 }
1195 #else
1196 static void host_tempreg_acquire(void) {}
1197 static void host_tempreg_release(void) {}
1198 #endif
1199
1200 #ifdef ASSEM_PRINT
1201 extern void gen_interupt();
1202 extern void do_insn_cmp();
1203 #define FUNCNAME(f) { f, " " #f }
1204 static const struct {
1205   void *addr;
1206   const char *name;
1207 } function_names[] = {
1208   FUNCNAME(cc_interrupt),
1209   FUNCNAME(gen_interupt),
1210   FUNCNAME(ndrc_get_addr_ht),
1211   FUNCNAME(jump_handler_read8),
1212   FUNCNAME(jump_handler_read16),
1213   FUNCNAME(jump_handler_read32),
1214   FUNCNAME(jump_handler_write8),
1215   FUNCNAME(jump_handler_write16),
1216   FUNCNAME(jump_handler_write32),
1217   FUNCNAME(ndrc_write_invalidate_one),
1218   FUNCNAME(ndrc_write_invalidate_many),
1219   FUNCNAME(jump_to_new_pc),
1220   FUNCNAME(jump_break),
1221   FUNCNAME(jump_break_ds),
1222   FUNCNAME(jump_syscall),
1223   FUNCNAME(jump_syscall_ds),
1224   FUNCNAME(jump_overflow),
1225   FUNCNAME(jump_overflow_ds),
1226   FUNCNAME(jump_addrerror),
1227   FUNCNAME(jump_addrerror_ds),
1228   FUNCNAME(call_gteStall),
1229   FUNCNAME(new_dyna_leave),
1230   FUNCNAME(pcsx_mtc0),
1231   FUNCNAME(pcsx_mtc0_ds),
1232   FUNCNAME(execI),
1233 #ifdef __aarch64__
1234   FUNCNAME(do_memhandler_pre),
1235   FUNCNAME(do_memhandler_post),
1236 #endif
1237 #ifdef DRC_DBG
1238 # ifdef __aarch64__
1239   FUNCNAME(do_insn_cmp_arm64),
1240 # else
1241   FUNCNAME(do_insn_cmp),
1242 # endif
1243 #endif
1244 };
1245
1246 static const char *func_name(const void *a)
1247 {
1248   int i;
1249   for (i = 0; i < sizeof(function_names)/sizeof(function_names[0]); i++)
1250     if (function_names[i].addr == a)
1251       return function_names[i].name;
1252   return "";
1253 }
1254
1255 static const char *fpofs_name(u_int ofs)
1256 {
1257   u_int *p = (u_int *)&dynarec_local + ofs/sizeof(u_int);
1258   static char buf[64];
1259   switch (ofs) {
1260   #define ofscase(x) case LO_##x: return " ; " #x
1261   ofscase(next_interupt);
1262   ofscase(cycle_count);
1263   ofscase(last_count);
1264   ofscase(pending_exception);
1265   ofscase(stop);
1266   ofscase(address);
1267   ofscase(lo);
1268   ofscase(hi);
1269   ofscase(PC);
1270   ofscase(cycle);
1271   ofscase(mem_rtab);
1272   ofscase(mem_wtab);
1273   ofscase(psxH_ptr);
1274   ofscase(invc_ptr);
1275   ofscase(ram_offset);
1276   #undef ofscase
1277   }
1278   buf[0] = 0;
1279   if      (psxRegs.GPR.r <= p && p < &psxRegs.GPR.r[32])
1280     snprintf(buf, sizeof(buf), " ; r%d", (int)(p - psxRegs.GPR.r));
1281   else if (psxRegs.CP0.r <= p && p < &psxRegs.CP0.r[32])
1282     snprintf(buf, sizeof(buf), " ; cp0 $%d", (int)(p - psxRegs.CP0.r));
1283   else if (psxRegs.CP2D.r <= p && p < &psxRegs.CP2D.r[32])
1284     snprintf(buf, sizeof(buf), " ; cp2d $%d", (int)(p - psxRegs.CP2D.r));
1285   else if (psxRegs.CP2C.r <= p && p < &psxRegs.CP2C.r[32])
1286     snprintf(buf, sizeof(buf), " ; cp2c $%d", (int)(p - psxRegs.CP2C.r));
1287   return buf;
1288 }
1289 #else
1290 #define func_name(x) ""
1291 #define fpofs_name(x) ""
1292 #endif
1293
1294 #ifdef __i386__
1295 #include "assem_x86.c"
1296 #endif
1297 #ifdef __x86_64__
1298 #include "assem_x64.c"
1299 #endif
1300 #ifdef __arm__
1301 #include "assem_arm.c"
1302 #endif
1303 #ifdef __aarch64__
1304 #include "assem_arm64.c"
1305 #endif
1306
1307 static void *get_trampoline(const void *f)
1308 {
1309   struct ndrc_tramp *tramp = NDRC_WRITE_OFFSET(&ndrc->tramp);
1310   size_t i;
1311
1312   for (i = 0; i < ARRAY_SIZE(tramp->f); i++) {
1313     if (tramp->f[i] == f || tramp->f[i] == NULL)
1314       break;
1315   }
1316   if (i == ARRAY_SIZE(tramp->f)) {
1317     SysPrintf("trampoline table is full, last func %p\n", f);
1318     abort();
1319   }
1320   if (tramp->f[i] == NULL) {
1321     start_tcache_write(&tramp->f[i], &tramp->f[i + 1]);
1322     tramp->f[i] = f;
1323     end_tcache_write(&tramp->f[i], &tramp->f[i + 1]);
1324 #ifdef HAVE_LIBNX
1325     // invalidate the RX mirror (unsure if necessary, but just in case...)
1326     armDCacheFlush(&ndrc->tramp.f[i], sizeof(ndrc->tramp.f[i]));
1327 #endif
1328   }
1329   return &ndrc->tramp.ops[i];
1330 }
1331
1332 static void emit_far_jump(const void *f)
1333 {
1334   if (can_jump_or_call(f)) {
1335     emit_jmp(f);
1336     return;
1337   }
1338
1339   f = get_trampoline(f);
1340   emit_jmp(f);
1341 }
1342
1343 static void emit_far_call(const void *f)
1344 {
1345   if (can_jump_or_call(f)) {
1346     emit_call(f);
1347     return;
1348   }
1349
1350   f = get_trampoline(f);
1351   emit_call(f);
1352 }
1353
1354 // Check if an address is already compiled
1355 // but don't return addresses which are about to expire from the cache
1356 static void *check_addr(u_int vaddr)
1357 {
1358   struct ht_entry *ht_bin = hash_table_get(vaddr);
1359   size_t i;
1360   for (i = 0; i < ARRAY_SIZE(ht_bin->vaddr); i++) {
1361     if (ht_bin->vaddr[i] == vaddr)
1362       if (doesnt_expire_soon(ht_bin->tcaddr[i]))
1363         return ht_bin->tcaddr[i];
1364   }
1365
1366   // refactor to get_addr_nocompile?
1367   u_int start_page = get_page_prev(vaddr);
1368   u_int page, end_page = get_page(vaddr);
1369
1370   stat_inc(stat_jump_in_lookups);
1371   for (page = start_page; page <= end_page; page++) {
1372     const struct block_info *block;
1373     for (block = blocks[page]; block != NULL; block = block->next) {
1374       if (vaddr < block->start)
1375         break;
1376       if (block->is_dirty || vaddr >= block->start + block->len)
1377         continue;
1378       if (!doesnt_expire_soon(ndrc->translation_cache + block->tc_offs))
1379         continue;
1380       for (i = 0; i < block->jump_in_cnt; i++)
1381         if (block->jump_in[i].vaddr == vaddr)
1382           break;
1383       if (i == block->jump_in_cnt)
1384         continue;
1385
1386       // Update existing entry with current address
1387       void *addr = block->jump_in[i].addr;
1388       if (ht_bin->vaddr[0] == vaddr) {
1389         ht_bin->tcaddr[0] = addr;
1390         return addr;
1391       }
1392       if (ht_bin->vaddr[1] == vaddr) {
1393         ht_bin->tcaddr[1] = addr;
1394         return addr;
1395       }
1396       // Insert into hash table with low priority.
1397       // Don't evict existing entries, as they are probably
1398       // addresses that are being accessed frequently.
1399       if (ht_bin->vaddr[0] == -1) {
1400         ht_bin->vaddr[0] = vaddr;
1401         ht_bin->tcaddr[0] = addr;
1402       }
1403       else if (ht_bin->vaddr[1] == -1) {
1404         ht_bin->vaddr[1] = vaddr;
1405         ht_bin->tcaddr[1] = addr;
1406       }
1407       return addr;
1408     }
1409   }
1410   return NULL;
1411 }
1412
1413 static void blocks_clear(struct block_info **head)
1414 {
1415   struct block_info *cur, *next;
1416
1417   if ((cur = *head)) {
1418     *head = NULL;
1419     while (cur) {
1420       next = cur->next;
1421       free(cur);
1422       cur = next;
1423     }
1424   }
1425 }
1426
1427 static int blocks_remove_matching_addrs(struct block_info **head,
1428   u_int base_offs, int shift)
1429 {
1430   struct block_info *next;
1431   int hit = 0;
1432   while (*head) {
1433     if ((((*head)->tc_offs ^ base_offs) >> shift) == 0) {
1434       inv_debug("EXP: rm block %08x (tc_offs %x)\n", (*head)->start, (*head)->tc_offs);
1435       invalidate_block(*head);
1436       next = (*head)->next;
1437       free(*head);
1438       *head = next;
1439       stat_dec(stat_blocks);
1440       hit = 1;
1441     }
1442     else
1443     {
1444       head = &((*head)->next);
1445     }
1446   }
1447   return hit;
1448 }
1449
1450 // This is called when we write to a compiled block (see do_invstub)
1451 static void unlink_jumps_vaddr_range(u_int start, u_int end)
1452 {
1453   u_int page, start_page = get_page(start), end_page = get_page(end - 1);
1454   int i;
1455
1456   for (page = start_page; page <= end_page; page++) {
1457     struct jump_info *ji = jumps[page];
1458     if (ji == NULL)
1459       continue;
1460     for (i = 0; i < ji->count; ) {
1461       if (ji->e[i].target_vaddr < start || ji->e[i].target_vaddr >= end) {
1462         i++;
1463         continue;
1464       }
1465
1466       inv_debug("INV: rm link to %08x (tc_offs %zx)\n", ji->e[i].target_vaddr,
1467         (u_char *)ji->e[i].stub - ndrc->translation_cache);
1468       void *host_addr = find_extjump_insn(ji->e[i].stub);
1469       mark_clear_cache(host_addr);
1470       set_jump_target(host_addr, ji->e[i].stub); // point back to dyna_linker stub
1471
1472       stat_dec(stat_links);
1473       ji->count--;
1474       if (i < ji->count) {
1475         ji->e[i] = ji->e[ji->count];
1476         continue;
1477       }
1478       i++;
1479     }
1480   }
1481 }
1482
1483 static void unlink_jumps_tc_range(struct jump_info *ji, u_int base_offs, int shift)
1484 {
1485   int i;
1486   if (ji == NULL)
1487     return;
1488   for (i = 0; i < ji->count; ) {
1489     u_int tc_offs = (u_char *)ji->e[i].stub - ndrc->translation_cache;
1490     if (((tc_offs ^ base_offs) >> shift) != 0) {
1491       i++;
1492       continue;
1493     }
1494
1495     inv_debug("EXP: rm link to %08x (tc_offs %x)\n", ji->e[i].target_vaddr, tc_offs);
1496     stat_dec(stat_links);
1497     ji->count--;
1498     if (i < ji->count) {
1499       ji->e[i] = ji->e[ji->count];
1500       continue;
1501     }
1502     i++;
1503   }
1504 }
1505
1506 static void invalidate_block(struct block_info *block)
1507 {
1508   u_int i;
1509
1510   block->is_dirty = 1;
1511   unlink_jumps_vaddr_range(block->start, block->start + block->len);
1512   for (i = 0; i < block->jump_in_cnt; i++)
1513     hash_table_remove(block->jump_in[i].vaddr);
1514 }
1515
1516 static int invalidate_range(u_int start, u_int end,
1517   u32 *inv_start_ret, u32 *inv_end_ret)
1518 {
1519   struct block_info *last_block = NULL;
1520   u_int start_page = get_page_prev(start);
1521   u_int end_page = get_page(end - 1);
1522   u_int start_m = pmmask(start);
1523   u_int end_m = pmmask(end - 1);
1524   u_int inv_start, inv_end;
1525   u_int blk_start_m, blk_end_m;
1526   u_int page;
1527   int hit = 0;
1528
1529   // additional area without code (to supplement invalid_code[]), [start, end)
1530   // avoids excessive ndrc_write_invalidate*() calls
1531   inv_start = start_m & ~0xfff;
1532   inv_end = end_m | 0xfff;
1533
1534   for (page = start_page; page <= end_page; page++) {
1535     struct block_info *block;
1536     for (block = blocks[page]; block != NULL; block = block->next) {
1537       if (block->is_dirty)
1538         continue;
1539       last_block = block;
1540       blk_end_m = pmmask(block->start + block->len);
1541       if (blk_end_m <= start_m) {
1542         inv_start = max(inv_start, blk_end_m);
1543         continue;
1544       }
1545       blk_start_m = pmmask(block->start);
1546       if (end_m <= blk_start_m) {
1547         inv_end = min(inv_end, blk_start_m - 1);
1548         continue;
1549       }
1550       if (!block->source) // "hack" block - leave it alone
1551         continue;
1552
1553       hit++;
1554       invalidate_block(block);
1555       stat_inc(stat_inv_hits);
1556     }
1557   }
1558
1559   if (!hit && last_block && last_block->source) {
1560     // could be some leftover unused block, uselessly trapping writes
1561     last_block->inv_near_misses++;
1562     if (last_block->inv_near_misses > 128) {
1563       invalidate_block(last_block);
1564       stat_inc(stat_inv_hits);
1565       hit++;
1566     }
1567   }
1568   if (hit) {
1569     do_clear_cache();
1570 #ifdef USE_MINI_HT
1571     memset(mini_ht, -1, sizeof(mini_ht));
1572 #endif
1573   }
1574
1575   if (inv_start <= (start_m & ~0xfff) && inv_end >= (start_m | 0xfff))
1576     // the whole page is empty now
1577     mark_invalid_code(start, 1, 1);
1578
1579   if (inv_start_ret) *inv_start_ret = inv_start | (start & 0xe0000000);
1580   if (inv_end_ret) *inv_end_ret = inv_end | (end & 0xe0000000);
1581   return hit;
1582 }
1583
1584 void new_dynarec_invalidate_range(unsigned int start, unsigned int end)
1585 {
1586   invalidate_range(start, end, NULL, NULL);
1587 }
1588
1589 static void ndrc_write_invalidate_many(u_int start, u_int end)
1590 {
1591   // this check is done by the caller
1592   //if (inv_code_start<=addr&&addr<=inv_code_end) { rhits++; return; }
1593   int ret = invalidate_range(start, end, &inv_code_start, &inv_code_end);
1594 #ifdef INV_DEBUG_W
1595   int invc = invalid_code[start >> 12];
1596   u_int len = end - start;
1597   if (ret)
1598     printf("INV ADDR: %08x/%02x hit %d blocks\n", start, len, ret);
1599   else
1600     printf("INV ADDR: %08x/%02x miss, inv %08x-%08x invc %d->%d\n", start, len,
1601       inv_code_start, inv_code_end, invc, invalid_code[start >> 12]);
1602   check_for_block_changes(start, end);
1603 #endif
1604   stat_inc(stat_inv_addr_calls);
1605   (void)ret;
1606 }
1607
1608 void ndrc_write_invalidate_one(u_int addr)
1609 {
1610   ndrc_write_invalidate_many(addr, addr + 4);
1611 }
1612
1613 // This is called when loading a save state.
1614 // Anything could have changed, so invalidate everything.
1615 void new_dynarec_invalidate_all_pages(void)
1616 {
1617   struct block_info *block;
1618   u_int page;
1619   for (page = 0; page < ARRAY_SIZE(blocks); page++) {
1620     for (block = blocks[page]; block != NULL; block = block->next) {
1621       if (block->is_dirty)
1622         continue;
1623       if (!block->source) // hack block?
1624         continue;
1625       invalidate_block(block);
1626     }
1627   }
1628
1629   #ifdef USE_MINI_HT
1630   memset(mini_ht, -1, sizeof(mini_ht));
1631   #endif
1632   do_clear_cache();
1633 }
1634
1635 // Add an entry to jump_out after making a link
1636 // src should point to code by emit_extjump()
1637 void ndrc_add_jump_out(u_int vaddr, void *src)
1638 {
1639   inv_debug("ndrc_add_jump_out: %p -> %x\n", src, vaddr);
1640   u_int page = get_page(vaddr);
1641   struct jump_info *ji;
1642
1643   stat_inc(stat_links);
1644   check_extjump2(src);
1645   ji = jumps[page];
1646   if (ji == NULL) {
1647     ji = malloc(sizeof(*ji) + sizeof(ji->e[0]) * 16);
1648     ji->alloc = 16;
1649     ji->count = 0;
1650   }
1651   else if (ji->count >= ji->alloc) {
1652     ji->alloc += 16;
1653     ji = realloc(ji, sizeof(*ji) + sizeof(ji->e[0]) * ji->alloc);
1654   }
1655   jumps[page] = ji;
1656   ji->e[ji->count].target_vaddr = vaddr;
1657   ji->e[ji->count].stub = src;
1658   ji->count++;
1659 }
1660
1661 /* Register allocation */
1662
1663 static void alloc_set(struct regstat *cur, int reg, int hr)
1664 {
1665   cur->regmap[hr] = reg;
1666   cur->dirty &= ~(1u << hr);
1667   cur->isconst &= ~(1u << hr);
1668   cur->noevict |= 1u << hr;
1669 }
1670
1671 static void evict_alloc_reg(struct regstat *cur, int i, int reg, int preferred_hr)
1672 {
1673   u_char hsn[MAXREG+1];
1674   int j, r, hr;
1675   memset(hsn, 10, sizeof(hsn));
1676   lsn(hsn, i);
1677   //printf("hsn(%x): %d %d %d %d %d %d %d\n",start+i*4,hsn[cur->regmap[0]&63],hsn[cur->regmap[1]&63],hsn[cur->regmap[2]&63],hsn[cur->regmap[3]&63],hsn[cur->regmap[5]&63],hsn[cur->regmap[6]&63],hsn[cur->regmap[7]&63]);
1678   if(i>0) {
1679     // Don't evict the cycle count at entry points, otherwise the entry
1680     // stub will have to write it.
1681     if(dops[i].bt&&hsn[CCREG]>2) hsn[CCREG]=2;
1682     if (i>1 && hsn[CCREG] > 2 && dops[i-2].is_jump) hsn[CCREG]=2;
1683     for(j=10;j>=3;j--)
1684     {
1685       // Alloc preferred register if available
1686       if (!((cur->noevict >> preferred_hr) & 1)
1687           && hsn[cur->regmap[preferred_hr]] == j)
1688       {
1689         alloc_set(cur, reg, preferred_hr);
1690         return;
1691       }
1692       for(r=1;r<=MAXREG;r++)
1693       {
1694         if(hsn[r]==j&&r!=dops[i-1].rs1&&r!=dops[i-1].rs2&&r!=dops[i-1].rt1&&r!=dops[i-1].rt2) {
1695           for(hr=0;hr<HOST_REGS;hr++) {
1696             if (hr == EXCLUDE_REG || ((cur->noevict >> hr) & 1))
1697               continue;
1698             if(hr!=HOST_CCREG||j<hsn[CCREG]) {
1699               if(cur->regmap[hr]==r) {
1700                 alloc_set(cur, reg, hr);
1701                 return;
1702               }
1703             }
1704           }
1705         }
1706       }
1707     }
1708   }
1709   for(j=10;j>=0;j--)
1710   {
1711     for(r=1;r<=MAXREG;r++)
1712     {
1713       if(hsn[r]==j) {
1714         for(hr=0;hr<HOST_REGS;hr++) {
1715           if (hr == EXCLUDE_REG || ((cur->noevict >> hr) & 1))
1716             continue;
1717           if(cur->regmap[hr]==r) {
1718             alloc_set(cur, reg, hr);
1719             return;
1720           }
1721         }
1722       }
1723     }
1724   }
1725   SysPrintf("This shouldn't happen (evict_alloc_reg)\n");
1726   abort();
1727 }
1728
1729 // Note: registers are allocated clean (unmodified state)
1730 // if you intend to modify the register, you must call dirty_reg().
1731 static void alloc_reg(struct regstat *cur,int i,signed char reg)
1732 {
1733   int r,hr;
1734   int preferred_reg = PREFERRED_REG_FIRST
1735     + reg % (PREFERRED_REG_LAST - PREFERRED_REG_FIRST + 1);
1736   if (reg == CCREG) preferred_reg = HOST_CCREG;
1737   if (reg == PTEMP || reg == FTEMP) preferred_reg = 12;
1738   assert(PREFERRED_REG_FIRST != EXCLUDE_REG && EXCLUDE_REG != HOST_REGS);
1739   assert(reg >= 0);
1740
1741   // Don't allocate unused registers
1742   if((cur->u>>reg)&1) return;
1743
1744   // see if it's already allocated
1745   if ((hr = get_reg(cur->regmap, reg)) >= 0) {
1746     cur->noevict |= 1u << hr;
1747     return;
1748   }
1749
1750   // Keep the same mapping if the register was already allocated in a loop
1751   preferred_reg = loop_reg(i,reg,preferred_reg);
1752
1753   // Try to allocate the preferred register
1754   if (cur->regmap[preferred_reg] == -1) {
1755     alloc_set(cur, reg, preferred_reg);
1756     return;
1757   }
1758   r=cur->regmap[preferred_reg];
1759   assert(r < 64);
1760   if((cur->u>>r)&1) {
1761     alloc_set(cur, reg, preferred_reg);
1762     return;
1763   }
1764
1765   // Clear any unneeded registers
1766   // We try to keep the mapping consistent, if possible, because it
1767   // makes branches easier (especially loops).  So we try to allocate
1768   // first (see above) before removing old mappings.  If this is not
1769   // possible then go ahead and clear out the registers that are no
1770   // longer needed.
1771   for(hr=0;hr<HOST_REGS;hr++)
1772   {
1773     r=cur->regmap[hr];
1774     if(r>=0) {
1775       assert(r < 64);
1776       if((cur->u>>r)&1) {cur->regmap[hr]=-1;break;}
1777     }
1778   }
1779
1780   // Try to allocate any available register, but prefer
1781   // registers that have not been used recently.
1782   if (i > 0) {
1783     for (hr = PREFERRED_REG_FIRST; ; ) {
1784       if (cur->regmap[hr] < 0) {
1785         int oldreg = regs[i-1].regmap[hr];
1786         if (oldreg < 0 || (oldreg != dops[i-1].rs1 && oldreg != dops[i-1].rs2
1787              && oldreg != dops[i-1].rt1 && oldreg != dops[i-1].rt2))
1788         {
1789           alloc_set(cur, reg, hr);
1790           return;
1791         }
1792       }
1793       hr++;
1794       if (hr == EXCLUDE_REG)
1795         hr++;
1796       if (hr == HOST_REGS)
1797         hr = 0;
1798       if (hr == PREFERRED_REG_FIRST)
1799         break;
1800     }
1801   }
1802
1803   // Try to allocate any available register
1804   for (hr = PREFERRED_REG_FIRST; ; ) {
1805     if (cur->regmap[hr] < 0) {
1806       alloc_set(cur, reg, hr);
1807       return;
1808     }
1809     hr++;
1810     if (hr == EXCLUDE_REG)
1811       hr++;
1812     if (hr == HOST_REGS)
1813       hr = 0;
1814     if (hr == PREFERRED_REG_FIRST)
1815       break;
1816   }
1817
1818   // Ok, now we have to evict someone
1819   // Pick a register we hopefully won't need soon
1820   evict_alloc_reg(cur, i, reg, preferred_reg);
1821 }
1822
1823 // Allocate a temporary register.  This is done without regard to
1824 // dirty status or whether the register we request is on the unneeded list
1825 // Note: This will only allocate one register, even if called multiple times
1826 static void alloc_reg_temp(struct regstat *cur,int i,signed char reg)
1827 {
1828   int r,hr;
1829
1830   // see if it's already allocated
1831   for (hr = 0; hr < HOST_REGS; hr++)
1832   {
1833     if (hr != EXCLUDE_REG && cur->regmap[hr] == reg) {
1834       cur->noevict |= 1u << hr;
1835       return;
1836     }
1837   }
1838
1839   // Try to allocate any available register
1840   for(hr=HOST_REGS-1;hr>=0;hr--) {
1841     if(hr!=EXCLUDE_REG&&cur->regmap[hr]==-1) {
1842       alloc_set(cur, reg, hr);
1843       return;
1844     }
1845   }
1846
1847   // Find an unneeded register
1848   for(hr=HOST_REGS-1;hr>=0;hr--)
1849   {
1850     r=cur->regmap[hr];
1851     if(r>=0) {
1852       assert(r < 64);
1853       if((cur->u>>r)&1) {
1854         if(i==0||((unneeded_reg[i-1]>>r)&1)) {
1855           alloc_set(cur, reg, hr);
1856           return;
1857         }
1858       }
1859     }
1860   }
1861
1862   // Ok, now we have to evict someone
1863   // Pick a register we hopefully won't need soon
1864   evict_alloc_reg(cur, i, reg, 0);
1865 }
1866
1867 static void mov_alloc(struct regstat *current,int i)
1868 {
1869   if (dops[i].rs1 == HIREG || dops[i].rs1 == LOREG) {
1870     alloc_cc(current,i); // for stalls
1871     dirty_reg(current,CCREG);
1872   }
1873
1874   // Note: Don't need to actually alloc the source registers
1875   //alloc_reg(current,i,dops[i].rs1);
1876   alloc_reg(current,i,dops[i].rt1);
1877
1878   clear_const(current,dops[i].rs1);
1879   clear_const(current,dops[i].rt1);
1880   dirty_reg(current,dops[i].rt1);
1881 }
1882
1883 static void shiftimm_alloc(struct regstat *current,int i)
1884 {
1885   if(dops[i].opcode2<=0x3) // SLL/SRL/SRA
1886   {
1887     if(dops[i].rt1) {
1888       if(dops[i].rs1&&needed_again(dops[i].rs1,i)) alloc_reg(current,i,dops[i].rs1);
1889       else dops[i].use_lt1=!!dops[i].rs1;
1890       alloc_reg(current,i,dops[i].rt1);
1891       dirty_reg(current,dops[i].rt1);
1892       if(is_const(current,dops[i].rs1)) {
1893         int v=get_const(current,dops[i].rs1);
1894         if(dops[i].opcode2==0x00) set_const(current,dops[i].rt1,v<<cinfo[i].imm);
1895         if(dops[i].opcode2==0x02) set_const(current,dops[i].rt1,(u_int)v>>cinfo[i].imm);
1896         if(dops[i].opcode2==0x03) set_const(current,dops[i].rt1,v>>cinfo[i].imm);
1897       }
1898       else clear_const(current,dops[i].rt1);
1899     }
1900   }
1901   else
1902   {
1903     clear_const(current,dops[i].rs1);
1904     clear_const(current,dops[i].rt1);
1905   }
1906
1907   if(dops[i].opcode2>=0x38&&dops[i].opcode2<=0x3b) // DSLL/DSRL/DSRA
1908   {
1909     assert(0);
1910   }
1911   if(dops[i].opcode2==0x3c) // DSLL32
1912   {
1913     assert(0);
1914   }
1915   if(dops[i].opcode2==0x3e) // DSRL32
1916   {
1917     assert(0);
1918   }
1919   if(dops[i].opcode2==0x3f) // DSRA32
1920   {
1921     assert(0);
1922   }
1923 }
1924
1925 static void shift_alloc(struct regstat *current,int i)
1926 {
1927   if(dops[i].rt1) {
1928       if(dops[i].rs1) alloc_reg(current,i,dops[i].rs1);
1929       if(dops[i].rs2) alloc_reg(current,i,dops[i].rs2);
1930       alloc_reg(current,i,dops[i].rt1);
1931       if(dops[i].rt1==dops[i].rs2) {
1932         alloc_reg_temp(current,i,-1);
1933         cinfo[i].min_free_regs=1;
1934       }
1935     clear_const(current,dops[i].rs1);
1936     clear_const(current,dops[i].rs2);
1937     clear_const(current,dops[i].rt1);
1938     dirty_reg(current,dops[i].rt1);
1939   }
1940 }
1941
1942 static void alu_alloc(struct regstat *current,int i)
1943 {
1944   if(dops[i].opcode2>=0x20&&dops[i].opcode2<=0x23) { // ADD/ADDU/SUB/SUBU
1945     if(dops[i].rt1) {
1946       if(dops[i].rs1&&dops[i].rs2) {
1947         alloc_reg(current,i,dops[i].rs1);
1948         alloc_reg(current,i,dops[i].rs2);
1949       }
1950       else {
1951         if(dops[i].rs1&&needed_again(dops[i].rs1,i)) alloc_reg(current,i,dops[i].rs1);
1952         if(dops[i].rs2&&needed_again(dops[i].rs2,i)) alloc_reg(current,i,dops[i].rs2);
1953       }
1954       alloc_reg(current,i,dops[i].rt1);
1955     }
1956     if (dops[i].may_except) {
1957       alloc_cc_optional(current, i); // for exceptions
1958       alloc_reg_temp(current, i, -1);
1959       cinfo[i].min_free_regs = 1;
1960     }
1961   }
1962   else if(dops[i].opcode2==0x2a||dops[i].opcode2==0x2b) { // SLT/SLTU
1963     if(dops[i].rt1) {
1964       alloc_reg(current,i,dops[i].rs1);
1965       alloc_reg(current,i,dops[i].rs2);
1966       alloc_reg(current,i,dops[i].rt1);
1967     }
1968   }
1969   else if(dops[i].opcode2>=0x24&&dops[i].opcode2<=0x27) { // AND/OR/XOR/NOR
1970     if(dops[i].rt1) {
1971       if(dops[i].rs1&&dops[i].rs2) {
1972         alloc_reg(current,i,dops[i].rs1);
1973         alloc_reg(current,i,dops[i].rs2);
1974       }
1975       else
1976       {
1977         if(dops[i].rs1&&needed_again(dops[i].rs1,i)) alloc_reg(current,i,dops[i].rs1);
1978         if(dops[i].rs2&&needed_again(dops[i].rs2,i)) alloc_reg(current,i,dops[i].rs2);
1979       }
1980       alloc_reg(current,i,dops[i].rt1);
1981     }
1982   }
1983   clear_const(current,dops[i].rs1);
1984   clear_const(current,dops[i].rs2);
1985   clear_const(current,dops[i].rt1);
1986   dirty_reg(current,dops[i].rt1);
1987 }
1988
1989 static void imm16_alloc(struct regstat *current,int i)
1990 {
1991   if(dops[i].rs1&&needed_again(dops[i].rs1,i)) alloc_reg(current,i,dops[i].rs1);
1992   else dops[i].use_lt1=!!dops[i].rs1;
1993   if(dops[i].rt1) alloc_reg(current,i,dops[i].rt1);
1994   if(dops[i].opcode==0x0a||dops[i].opcode==0x0b) { // SLTI/SLTIU
1995     clear_const(current,dops[i].rs1);
1996     clear_const(current,dops[i].rt1);
1997   }
1998   else if(dops[i].opcode>=0x0c&&dops[i].opcode<=0x0e) { // ANDI/ORI/XORI
1999     if(is_const(current,dops[i].rs1)) {
2000       int v=get_const(current,dops[i].rs1);
2001       if(dops[i].opcode==0x0c) set_const(current,dops[i].rt1,v&cinfo[i].imm);
2002       if(dops[i].opcode==0x0d) set_const(current,dops[i].rt1,v|cinfo[i].imm);
2003       if(dops[i].opcode==0x0e) set_const(current,dops[i].rt1,v^cinfo[i].imm);
2004     }
2005     else clear_const(current,dops[i].rt1);
2006   }
2007   else if(dops[i].opcode==0x08||dops[i].opcode==0x09) { // ADDI/ADDIU
2008     if(is_const(current,dops[i].rs1)) {
2009       int v=get_const(current,dops[i].rs1);
2010       set_const(current,dops[i].rt1,v+cinfo[i].imm);
2011     }
2012     else clear_const(current,dops[i].rt1);
2013     if (dops[i].may_except) {
2014       alloc_cc_optional(current, i); // for exceptions
2015       alloc_reg_temp(current, i, -1);
2016       cinfo[i].min_free_regs = 1;
2017     }
2018   }
2019   else {
2020     set_const(current,dops[i].rt1,cinfo[i].imm<<16); // LUI
2021   }
2022   dirty_reg(current,dops[i].rt1);
2023 }
2024
2025 static void load_alloc(struct regstat *current,int i)
2026 {
2027   int need_temp = 0;
2028   clear_const(current,dops[i].rt1);
2029   //if(dops[i].rs1!=dops[i].rt1&&needed_again(dops[i].rs1,i)) clear_const(current,dops[i].rs1); // Does this help or hurt?
2030   if(!dops[i].rs1) current->u&=~1LL; // Allow allocating r0 if it's the source register
2031   if (needed_again(dops[i].rs1, i))
2032     alloc_reg(current, i, dops[i].rs1);
2033   if (ram_offset)
2034     alloc_reg(current, i, ROREG);
2035   if (dops[i].may_except) {
2036     alloc_cc_optional(current, i); // for exceptions
2037     need_temp = 1;
2038   }
2039   if(dops[i].rt1&&!((current->u>>dops[i].rt1)&1)) {
2040     alloc_reg(current,i,dops[i].rt1);
2041     assert(get_reg_w(current->regmap, dops[i].rt1)>=0);
2042     dirty_reg(current,dops[i].rt1);
2043     // LWL/LWR need a temporary register for the old value
2044     if(dops[i].opcode==0x22||dops[i].opcode==0x26)
2045     {
2046       alloc_reg(current,i,FTEMP);
2047       need_temp = 1;
2048     }
2049   }
2050   else
2051   {
2052     // Load to r0 or unneeded register (dummy load)
2053     // but we still need a register to calculate the address
2054     if(dops[i].opcode==0x22||dops[i].opcode==0x26)
2055       alloc_reg(current,i,FTEMP); // LWL/LWR need another temporary
2056     need_temp = 1;
2057   }
2058   if (need_temp) {
2059     alloc_reg_temp(current, i, -1);
2060     cinfo[i].min_free_regs = 1;
2061   }
2062 }
2063
2064 // this may eat up to 7 registers
2065 static void store_alloc(struct regstat *current, int i)
2066 {
2067   clear_const(current,dops[i].rs2);
2068   if(!(dops[i].rs2)) current->u&=~1LL; // Allow allocating r0 if necessary
2069   if(needed_again(dops[i].rs1,i)) alloc_reg(current,i,dops[i].rs1);
2070   alloc_reg(current,i,dops[i].rs2);
2071   if (ram_offset)
2072     alloc_reg(current, i, ROREG);
2073   #if defined(HOST_IMM8)
2074   // On CPUs without 32-bit immediates we need a pointer to invalid_code
2075   alloc_reg(current, i, INVCP);
2076   #endif
2077   if (dops[i].opcode == 0x2a || dops[i].opcode == 0x2e) { // SWL/SWL
2078     alloc_reg(current,i,FTEMP);
2079   }
2080   if (dops[i].may_except)
2081     alloc_cc_optional(current, i); // for exceptions
2082   // We need a temporary register for address generation
2083   alloc_reg_temp(current,i,-1);
2084   cinfo[i].min_free_regs=1;
2085 }
2086
2087 static void c2ls_alloc(struct regstat *current, int i)
2088 {
2089   clear_const(current,dops[i].rt1);
2090   if(needed_again(dops[i].rs1,i)) alloc_reg(current,i,dops[i].rs1);
2091   alloc_reg(current,i,FTEMP);
2092   if (ram_offset)
2093     alloc_reg(current, i, ROREG);
2094   #if defined(HOST_IMM8)
2095   // On CPUs without 32-bit immediates we need a pointer to invalid_code
2096   if (dops[i].opcode == 0x3a) // SWC2
2097     alloc_reg(current,i,INVCP);
2098   #endif
2099   if (dops[i].may_except)
2100     alloc_cc_optional(current, i); // for exceptions
2101   // We need a temporary register for address generation
2102   alloc_reg_temp(current,i,-1);
2103   cinfo[i].min_free_regs=1;
2104 }
2105
2106 #ifndef multdiv_alloc
2107 static void multdiv_alloc(struct regstat *current,int i)
2108 {
2109   //  case 0x18: MULT
2110   //  case 0x19: MULTU
2111   //  case 0x1A: DIV
2112   //  case 0x1B: DIVU
2113   clear_const(current,dops[i].rs1);
2114   clear_const(current,dops[i].rs2);
2115   alloc_cc(current,i); // for stalls
2116   dirty_reg(current,CCREG);
2117   current->u &= ~(1ull << HIREG);
2118   current->u &= ~(1ull << LOREG);
2119   alloc_reg(current, i, HIREG);
2120   alloc_reg(current, i, LOREG);
2121   dirty_reg(current, HIREG);
2122   dirty_reg(current, LOREG);
2123   if ((dops[i].opcode2 & 0x3e) == 0x1a || (dops[i].rs1 && dops[i].rs2)) // div(u)
2124   {
2125     alloc_reg(current, i, dops[i].rs1);
2126     alloc_reg(current, i, dops[i].rs2);
2127   }
2128   // else multiply by zero is zero
2129 }
2130 #endif
2131
2132 static void cop0_alloc(struct regstat *current,int i)
2133 {
2134   if(dops[i].opcode2==0) // MFC0
2135   {
2136     if(dops[i].rt1) {
2137       clear_const(current,dops[i].rt1);
2138       alloc_reg(current,i,dops[i].rt1);
2139       dirty_reg(current,dops[i].rt1);
2140     }
2141   }
2142   else if(dops[i].opcode2==4) // MTC0
2143   {
2144     if (((source[i]>>11)&0x1e) == 12) {
2145       alloc_cc(current, i);
2146       dirty_reg(current, CCREG);
2147     }
2148     if(dops[i].rs1){
2149       clear_const(current,dops[i].rs1);
2150       alloc_reg(current,i,dops[i].rs1);
2151       alloc_all(current,i);
2152     }
2153     else {
2154       alloc_all(current,i); // FIXME: Keep r0
2155       current->u&=~1LL;
2156       alloc_reg(current,i,0);
2157     }
2158     cinfo[i].min_free_regs = HOST_REGS;
2159   }
2160 }
2161
2162 static void rfe_alloc(struct regstat *current, int i)
2163 {
2164   alloc_all(current, i);
2165   cinfo[i].min_free_regs = HOST_REGS;
2166 }
2167
2168 static void cop2_alloc(struct regstat *current,int i)
2169 {
2170   if (dops[i].opcode2 < 3) // MFC2/CFC2
2171   {
2172     alloc_cc(current,i); // for stalls
2173     dirty_reg(current,CCREG);
2174     if(dops[i].rt1){
2175       clear_const(current,dops[i].rt1);
2176       alloc_reg(current,i,dops[i].rt1);
2177       dirty_reg(current,dops[i].rt1);
2178     }
2179   }
2180   else if (dops[i].opcode2 > 3) // MTC2/CTC2
2181   {
2182     if(dops[i].rs1){
2183       clear_const(current,dops[i].rs1);
2184       alloc_reg(current,i,dops[i].rs1);
2185     }
2186     else {
2187       current->u&=~1LL;
2188       alloc_reg(current,i,0);
2189     }
2190   }
2191   alloc_reg_temp(current,i,-1);
2192   cinfo[i].min_free_regs=1;
2193 }
2194
2195 static void c2op_alloc(struct regstat *current,int i)
2196 {
2197   alloc_cc(current,i); // for stalls
2198   dirty_reg(current,CCREG);
2199   alloc_reg_temp(current,i,-1);
2200 }
2201
2202 static void syscall_alloc(struct regstat *current,int i)
2203 {
2204   alloc_cc(current,i);
2205   dirty_reg(current,CCREG);
2206   alloc_all(current,i);
2207   cinfo[i].min_free_regs=HOST_REGS;
2208   current->isconst=0;
2209 }
2210
2211 static void delayslot_alloc(struct regstat *current,int i)
2212 {
2213   switch(dops[i].itype) {
2214     case UJUMP:
2215     case CJUMP:
2216     case SJUMP:
2217     case RJUMP:
2218     case SYSCALL:
2219     case HLECALL:
2220     case IMM16:
2221       imm16_alloc(current,i);
2222       break;
2223     case LOAD:
2224     case LOADLR:
2225       load_alloc(current,i);
2226       break;
2227     case STORE:
2228     case STORELR:
2229       store_alloc(current,i);
2230       break;
2231     case ALU:
2232       alu_alloc(current,i);
2233       break;
2234     case SHIFT:
2235       shift_alloc(current,i);
2236       break;
2237     case MULTDIV:
2238       multdiv_alloc(current,i);
2239       break;
2240     case SHIFTIMM:
2241       shiftimm_alloc(current,i);
2242       break;
2243     case MOV:
2244       mov_alloc(current,i);
2245       break;
2246     case COP0:
2247       cop0_alloc(current,i);
2248       break;
2249     case RFE:
2250       rfe_alloc(current,i);
2251       break;
2252     case COP2:
2253       cop2_alloc(current,i);
2254       break;
2255     case C2LS:
2256       c2ls_alloc(current,i);
2257       break;
2258     case C2OP:
2259       c2op_alloc(current,i);
2260       break;
2261   }
2262 }
2263
2264 static void add_stub(enum stub_type type, void *addr, void *retaddr,
2265   u_int a, uintptr_t b, uintptr_t c, u_int d, u_int e)
2266 {
2267   assert(stubcount < ARRAY_SIZE(stubs));
2268   stubs[stubcount].type = type;
2269   stubs[stubcount].addr = addr;
2270   stubs[stubcount].retaddr = retaddr;
2271   stubs[stubcount].a = a;
2272   stubs[stubcount].b = b;
2273   stubs[stubcount].c = c;
2274   stubs[stubcount].d = d;
2275   stubs[stubcount].e = e;
2276   stubcount++;
2277 }
2278
2279 static void add_stub_r(enum stub_type type, void *addr, void *retaddr,
2280   int i, int addr_reg, const struct regstat *i_regs, int ccadj, u_int reglist)
2281 {
2282   add_stub(type, addr, retaddr, i, addr_reg, (uintptr_t)i_regs, ccadj, reglist);
2283 }
2284
2285 // Write out a single register
2286 static void wb_register(signed char r, const signed char regmap[], u_int dirty)
2287 {
2288   int hr;
2289   for(hr=0;hr<HOST_REGS;hr++) {
2290     if(hr!=EXCLUDE_REG) {
2291       if(regmap[hr]==r) {
2292         if((dirty>>hr)&1) {
2293           assert(regmap[hr]<64);
2294           emit_storereg(r,hr);
2295         }
2296         break;
2297       }
2298     }
2299   }
2300 }
2301
2302 static void wb_valid(signed char pre[],signed char entry[],u_int dirty_pre,u_int dirty,uint64_t u)
2303 {
2304   //if(dirty_pre==dirty) return;
2305   int hr, r;
2306   for (hr = 0; hr < HOST_REGS; hr++) {
2307     r = pre[hr];
2308     if (r < 1 || r > 33 || ((u >> r) & 1))
2309       continue;
2310     if (((dirty_pre & ~dirty) >> hr) & 1)
2311       emit_storereg(r, hr);
2312   }
2313 }
2314
2315 // trashes r2
2316 static void pass_args(int a0, int a1)
2317 {
2318   if(a0==1&&a1==0) {
2319     // must swap
2320     emit_mov(a0,2); emit_mov(a1,1); emit_mov(2,0);
2321   }
2322   else if(a0!=0&&a1==0) {
2323     emit_mov(a1,1);
2324     if (a0>=0) emit_mov(a0,0);
2325   }
2326   else {
2327     if(a0>=0&&a0!=0) emit_mov(a0,0);
2328     if(a1>=0&&a1!=1) emit_mov(a1,1);
2329   }
2330 }
2331
2332 static void alu_assemble(int i, const struct regstat *i_regs, int ccadj_)
2333 {
2334   if(dops[i].opcode2>=0x20&&dops[i].opcode2<=0x23) { // ADD/ADDU/SUB/SUBU
2335     int do_oflow = dops[i].may_except; // ADD/SUB with exceptions enabled
2336     if (dops[i].rt1 || do_oflow) {
2337       int do_exception_check = 0;
2338       signed char s1, s2, t, tmp;
2339       t = get_reg_w(i_regs->regmap, dops[i].rt1);
2340       tmp = get_reg_temp(i_regs->regmap);
2341       if (do_oflow)
2342         assert(tmp >= 0);
2343       if (t < 0 && do_oflow)
2344         t = tmp;
2345       if (t >= 0) {
2346         s1 = get_reg(i_regs->regmap, dops[i].rs1);
2347         s2 = get_reg(i_regs->regmap, dops[i].rs2);
2348         if (dops[i].rs1 && dops[i].rs2) {
2349           assert(s1>=0);
2350           assert(s2>=0);
2351           if (dops[i].opcode2 & 2) {
2352             if (do_oflow) {
2353               emit_subs(s1, s2, tmp);
2354               do_exception_check = 1;
2355             }
2356             else
2357               emit_sub(s1,s2,t);
2358           }
2359           else {
2360             if (do_oflow) {
2361               emit_adds(s1, s2, tmp);
2362               do_exception_check = 1;
2363             }
2364             else
2365               emit_add(s1,s2,t);
2366           }
2367         }
2368         else if(dops[i].rs1) {
2369           if(s1>=0) emit_mov(s1,t);
2370           else emit_loadreg(dops[i].rs1,t);
2371         }
2372         else if(dops[i].rs2) {
2373           if (s2 < 0) {
2374             emit_loadreg(dops[i].rs2, t);
2375             s2 = t;
2376           }
2377           if (dops[i].opcode2 & 2) {
2378             if (do_oflow) {
2379               emit_negs(s2, tmp);
2380               do_exception_check = 1;
2381             }
2382             else
2383               emit_neg(s2, t);
2384           }
2385           else if (s2 != t)
2386             emit_mov(s2, t);
2387         }
2388         else
2389           emit_zeroreg(t);
2390       }
2391       if (do_exception_check) {
2392         void *jaddr = out;
2393         emit_jo(0);
2394         if (t >= 0 && tmp != t)
2395           emit_mov(tmp, t);
2396         add_stub_r(OVERFLOW_STUB, jaddr, out, i, 0, i_regs, ccadj_, 0);
2397       }
2398     }
2399   }
2400   else if(dops[i].opcode2==0x2a||dops[i].opcode2==0x2b) { // SLT/SLTU
2401     if(dops[i].rt1) {
2402       signed char s1l,s2l,t;
2403       {
2404         t=get_reg_w(i_regs->regmap, dops[i].rt1);
2405         //assert(t>=0);
2406         if(t>=0) {
2407           s1l=get_reg(i_regs->regmap,dops[i].rs1);
2408           s2l=get_reg(i_regs->regmap,dops[i].rs2);
2409           if(dops[i].rs2==0) // rx<r0
2410           {
2411             if(dops[i].opcode2==0x2a&&dops[i].rs1!=0) { // SLT
2412               assert(s1l>=0);
2413               emit_shrimm(s1l,31,t);
2414             }
2415             else // SLTU (unsigned can not be less than zero, 0<0)
2416               emit_zeroreg(t);
2417           }
2418           else if(dops[i].rs1==0) // r0<rx
2419           {
2420             assert(s2l>=0);
2421             if(dops[i].opcode2==0x2a) // SLT
2422               emit_set_gz32(s2l,t);
2423             else // SLTU (set if not zero)
2424               emit_set_nz32(s2l,t);
2425           }
2426           else{
2427             assert(s1l>=0);assert(s2l>=0);
2428             if(dops[i].opcode2==0x2a) // SLT
2429               emit_set_if_less32(s1l,s2l,t);
2430             else // SLTU
2431               emit_set_if_carry32(s1l,s2l,t);
2432           }
2433         }
2434       }
2435     }
2436   }
2437   else if(dops[i].opcode2>=0x24&&dops[i].opcode2<=0x27) { // AND/OR/XOR/NOR
2438     if(dops[i].rt1) {
2439       signed char s1l,s2l,tl;
2440       tl=get_reg_w(i_regs->regmap, dops[i].rt1);
2441       {
2442         if(tl>=0) {
2443           s1l=get_reg(i_regs->regmap,dops[i].rs1);
2444           s2l=get_reg(i_regs->regmap,dops[i].rs2);
2445           if(dops[i].rs1&&dops[i].rs2) {
2446             assert(s1l>=0);
2447             assert(s2l>=0);
2448             if(dops[i].opcode2==0x24) { // AND
2449               emit_and(s1l,s2l,tl);
2450             } else
2451             if(dops[i].opcode2==0x25) { // OR
2452               emit_or(s1l,s2l,tl);
2453             } else
2454             if(dops[i].opcode2==0x26) { // XOR
2455               emit_xor(s1l,s2l,tl);
2456             } else
2457             if(dops[i].opcode2==0x27) { // NOR
2458               emit_or(s1l,s2l,tl);
2459               emit_not(tl,tl);
2460             }
2461           }
2462           else
2463           {
2464             if(dops[i].opcode2==0x24) { // AND
2465               emit_zeroreg(tl);
2466             } else
2467             if(dops[i].opcode2==0x25||dops[i].opcode2==0x26) { // OR/XOR
2468               if(dops[i].rs1){
2469                 if(s1l>=0) emit_mov(s1l,tl);
2470                 else emit_loadreg(dops[i].rs1,tl); // CHECK: regmap_entry?
2471               }
2472               else
2473               if(dops[i].rs2){
2474                 if(s2l>=0) emit_mov(s2l,tl);
2475                 else emit_loadreg(dops[i].rs2,tl); // CHECK: regmap_entry?
2476               }
2477               else emit_zeroreg(tl);
2478             } else
2479             if(dops[i].opcode2==0x27) { // NOR
2480               if(dops[i].rs1){
2481                 if(s1l>=0) emit_not(s1l,tl);
2482                 else {
2483                   emit_loadreg(dops[i].rs1,tl);
2484                   emit_not(tl,tl);
2485                 }
2486               }
2487               else
2488               if(dops[i].rs2){
2489                 if(s2l>=0) emit_not(s2l,tl);
2490                 else {
2491                   emit_loadreg(dops[i].rs2,tl);
2492                   emit_not(tl,tl);
2493                 }
2494               }
2495               else emit_movimm(-1,tl);
2496             }
2497           }
2498         }
2499       }
2500     }
2501   }
2502 }
2503
2504 static void imm16_assemble(int i, const struct regstat *i_regs, int ccadj_)
2505 {
2506   if (dops[i].opcode==0x0f) { // LUI
2507     if(dops[i].rt1) {
2508       signed char t;
2509       t=get_reg_w(i_regs->regmap, dops[i].rt1);
2510       //assert(t>=0);
2511       if(t>=0) {
2512         if(!((i_regs->isconst>>t)&1))
2513           emit_movimm(cinfo[i].imm<<16,t);
2514       }
2515     }
2516   }
2517   if(dops[i].opcode==0x08||dops[i].opcode==0x09) { // ADDI/ADDIU
2518     int is_addi = dops[i].may_except;
2519     if (dops[i].rt1 || is_addi) {
2520       signed char s, t, tmp;
2521       t=get_reg_w(i_regs->regmap, dops[i].rt1);
2522       s=get_reg(i_regs->regmap,dops[i].rs1);
2523       if(dops[i].rs1) {
2524         tmp = get_reg_temp(i_regs->regmap);
2525         if (is_addi) {
2526           assert(tmp >= 0);
2527           if (t < 0) t = tmp;
2528         }
2529         if(t>=0) {
2530           if(!((i_regs->isconst>>t)&1)) {
2531             int sum, do_exception_check = 0;
2532             if (s < 0) {
2533               if(i_regs->regmap_entry[t]!=dops[i].rs1) emit_loadreg(dops[i].rs1,t);
2534               if (is_addi) {
2535                 emit_addimm_and_set_flags3(t, cinfo[i].imm, tmp);
2536                 do_exception_check = 1;
2537               }
2538               else
2539                 emit_addimm(t, cinfo[i].imm, t);
2540             } else {
2541               if (!((i_regs->wasconst >> s) & 1)) {
2542                 if (is_addi) {
2543                   emit_addimm_and_set_flags3(s, cinfo[i].imm, tmp);
2544                   do_exception_check = 1;
2545                 }
2546                 else
2547                   emit_addimm(s, cinfo[i].imm, t);
2548               }
2549               else {
2550                 int oflow = add_overflow(constmap[i][s], cinfo[i].imm, sum);
2551                 if (is_addi && oflow)
2552                   do_exception_check = 2;
2553                 else
2554                   emit_movimm(sum, t);
2555               }
2556             }
2557             if (do_exception_check) {
2558               void *jaddr = out;
2559               if (do_exception_check == 2)
2560                 emit_jmp(0);
2561               else {
2562                 emit_jo(0);
2563                 if (tmp != t)
2564                   emit_mov(tmp, t);
2565               }
2566               add_stub_r(OVERFLOW_STUB, jaddr, out, i, 0, i_regs, ccadj_, 0);
2567             }
2568           }
2569         }
2570       } else {
2571         if(t>=0) {
2572           if(!((i_regs->isconst>>t)&1))
2573             emit_movimm(cinfo[i].imm,t);
2574         }
2575       }
2576     }
2577   }
2578   else if(dops[i].opcode==0x0a||dops[i].opcode==0x0b) { // SLTI/SLTIU
2579     if(dops[i].rt1) {
2580       //assert(dops[i].rs1!=0); // r0 might be valid, but it's probably a bug
2581       signed char sl,t;
2582       t=get_reg_w(i_regs->regmap, dops[i].rt1);
2583       sl=get_reg(i_regs->regmap,dops[i].rs1);
2584       //assert(t>=0);
2585       if(t>=0) {
2586         if(dops[i].rs1>0) {
2587             if(dops[i].opcode==0x0a) { // SLTI
2588               if(sl<0) {
2589                 if(i_regs->regmap_entry[t]!=dops[i].rs1) emit_loadreg(dops[i].rs1,t);
2590                 emit_slti32(t,cinfo[i].imm,t);
2591               }else{
2592                 emit_slti32(sl,cinfo[i].imm,t);
2593               }
2594             }
2595             else { // SLTIU
2596               if(sl<0) {
2597                 if(i_regs->regmap_entry[t]!=dops[i].rs1) emit_loadreg(dops[i].rs1,t);
2598                 emit_sltiu32(t,cinfo[i].imm,t);
2599               }else{
2600                 emit_sltiu32(sl,cinfo[i].imm,t);
2601               }
2602             }
2603         }else{
2604           // SLTI(U) with r0 is just stupid,
2605           // nonetheless examples can be found
2606           if(dops[i].opcode==0x0a) // SLTI
2607             if(0<cinfo[i].imm) emit_movimm(1,t);
2608             else emit_zeroreg(t);
2609           else // SLTIU
2610           {
2611             if(cinfo[i].imm) emit_movimm(1,t);
2612             else emit_zeroreg(t);
2613           }
2614         }
2615       }
2616     }
2617   }
2618   else if(dops[i].opcode>=0x0c&&dops[i].opcode<=0x0e) { // ANDI/ORI/XORI
2619     if(dops[i].rt1) {
2620       signed char sl,tl;
2621       tl=get_reg_w(i_regs->regmap, dops[i].rt1);
2622       sl=get_reg(i_regs->regmap,dops[i].rs1);
2623       if(tl>=0 && !((i_regs->isconst>>tl)&1)) {
2624         if(dops[i].opcode==0x0c) //ANDI
2625         {
2626           if(dops[i].rs1) {
2627             if(sl<0) {
2628               if(i_regs->regmap_entry[tl]!=dops[i].rs1) emit_loadreg(dops[i].rs1,tl);
2629               emit_andimm(tl,cinfo[i].imm,tl);
2630             }else{
2631               if(!((i_regs->wasconst>>sl)&1))
2632                 emit_andimm(sl,cinfo[i].imm,tl);
2633               else
2634                 emit_movimm(constmap[i][sl]&cinfo[i].imm,tl);
2635             }
2636           }
2637           else
2638             emit_zeroreg(tl);
2639         }
2640         else
2641         {
2642           if(dops[i].rs1) {
2643             if(sl<0) {
2644               if(i_regs->regmap_entry[tl]!=dops[i].rs1) emit_loadreg(dops[i].rs1,tl);
2645             }
2646             if(dops[i].opcode==0x0d) { // ORI
2647               if(sl<0) {
2648                 emit_orimm(tl,cinfo[i].imm,tl);
2649               }else{
2650                 if(!((i_regs->wasconst>>sl)&1))
2651                   emit_orimm(sl,cinfo[i].imm,tl);
2652                 else
2653                   emit_movimm(constmap[i][sl]|cinfo[i].imm,tl);
2654               }
2655             }
2656             if(dops[i].opcode==0x0e) { // XORI
2657               if(sl<0) {
2658                 emit_xorimm(tl,cinfo[i].imm,tl);
2659               }else{
2660                 if(!((i_regs->wasconst>>sl)&1))
2661                   emit_xorimm(sl,cinfo[i].imm,tl);
2662                 else
2663                   emit_movimm(constmap[i][sl]^cinfo[i].imm,tl);
2664               }
2665             }
2666           }
2667           else {
2668             emit_movimm(cinfo[i].imm,tl);
2669           }
2670         }
2671       }
2672     }
2673   }
2674 }
2675
2676 static void shiftimm_assemble(int i, const struct regstat *i_regs)
2677 {
2678   if(dops[i].opcode2<=0x3) // SLL/SRL/SRA
2679   {
2680     if(dops[i].rt1) {
2681       signed char s,t;
2682       t=get_reg_w(i_regs->regmap, dops[i].rt1);
2683       s=get_reg(i_regs->regmap,dops[i].rs1);
2684       //assert(t>=0);
2685       if(t>=0&&!((i_regs->isconst>>t)&1)){
2686         if(dops[i].rs1==0)
2687         {
2688           emit_zeroreg(t);
2689         }
2690         else
2691         {
2692           if(s<0&&i_regs->regmap_entry[t]!=dops[i].rs1) emit_loadreg(dops[i].rs1,t);
2693           if(cinfo[i].imm) {
2694             if(dops[i].opcode2==0) // SLL
2695             {
2696               emit_shlimm(s<0?t:s,cinfo[i].imm,t);
2697             }
2698             if(dops[i].opcode2==2) // SRL
2699             {
2700               emit_shrimm(s<0?t:s,cinfo[i].imm,t);
2701             }
2702             if(dops[i].opcode2==3) // SRA
2703             {
2704               emit_sarimm(s<0?t:s,cinfo[i].imm,t);
2705             }
2706           }else{
2707             // Shift by zero
2708             if(s>=0 && s!=t) emit_mov(s,t);
2709           }
2710         }
2711       }
2712       //emit_storereg(dops[i].rt1,t); //DEBUG
2713     }
2714   }
2715   if(dops[i].opcode2>=0x38&&dops[i].opcode2<=0x3b) // DSLL/DSRL/DSRA
2716   {
2717     assert(0);
2718   }
2719   if(dops[i].opcode2==0x3c) // DSLL32
2720   {
2721     assert(0);
2722   }
2723   if(dops[i].opcode2==0x3e) // DSRL32
2724   {
2725     assert(0);
2726   }
2727   if(dops[i].opcode2==0x3f) // DSRA32
2728   {
2729     assert(0);
2730   }
2731 }
2732
2733 #ifndef shift_assemble
2734 static void shift_assemble(int i, const struct regstat *i_regs)
2735 {
2736   signed char s,t,shift;
2737   if (dops[i].rt1 == 0)
2738     return;
2739   assert(dops[i].opcode2<=0x07); // SLLV/SRLV/SRAV
2740   t = get_reg(i_regs->regmap, dops[i].rt1);
2741   s = get_reg(i_regs->regmap, dops[i].rs1);
2742   shift = get_reg(i_regs->regmap, dops[i].rs2);
2743   if (t < 0)
2744     return;
2745
2746   if(dops[i].rs1==0)
2747     emit_zeroreg(t);
2748   else if(dops[i].rs2==0) {
2749     assert(s>=0);
2750     if(s!=t) emit_mov(s,t);
2751   }
2752   else {
2753     host_tempreg_acquire();
2754     emit_andimm(shift,31,HOST_TEMPREG);
2755     switch(dops[i].opcode2) {
2756     case 4: // SLLV
2757       emit_shl(s,HOST_TEMPREG,t);
2758       break;
2759     case 6: // SRLV
2760       emit_shr(s,HOST_TEMPREG,t);
2761       break;
2762     case 7: // SRAV
2763       emit_sar(s,HOST_TEMPREG,t);
2764       break;
2765     default:
2766       assert(0);
2767     }
2768     host_tempreg_release();
2769   }
2770 }
2771
2772 #endif
2773
2774 enum {
2775   MTYPE_8000 = 0,
2776   MTYPE_8020,
2777   MTYPE_0000,
2778   MTYPE_A000,
2779   MTYPE_1F80,
2780 };
2781
2782 static int get_ptr_mem_type(u_int a)
2783 {
2784   if(a < 0x00200000) {
2785     if(a<0x1000&&((start>>20)==0xbfc||(start>>24)==0xa0))
2786       // return wrong, must use memhandler for BIOS self-test to pass
2787       // 007 does similar stuff from a00 mirror, weird stuff
2788       return MTYPE_8000;
2789     return MTYPE_0000;
2790   }
2791   if(0x1f800000 <= a && a < 0x1f801000)
2792     return MTYPE_1F80;
2793   if(0x80200000 <= a && a < 0x80800000)
2794     return MTYPE_8020;
2795   if(0xa0000000 <= a && a < 0xa0200000)
2796     return MTYPE_A000;
2797   return MTYPE_8000;
2798 }
2799
2800 static int get_ro_reg(const struct regstat *i_regs, int host_tempreg_free)
2801 {
2802   int r = get_reg(i_regs->regmap, ROREG);
2803   if (r < 0 && host_tempreg_free) {
2804     host_tempreg_acquire();
2805     emit_loadreg(ROREG, r = HOST_TEMPREG);
2806   }
2807   if (r < 0)
2808     abort();
2809   return r;
2810 }
2811
2812 static void *emit_fastpath_cmp_jump(int i, const struct regstat *i_regs,
2813   int addr, int *offset_reg, int *addr_reg_override, int ccadj_)
2814 {
2815   void *jaddr = NULL;
2816   int type = 0;
2817   int mr = dops[i].rs1;
2818   assert(addr >= 0);
2819   *offset_reg = -1;
2820   if(((smrv_strong|smrv_weak)>>mr)&1) {
2821     type=get_ptr_mem_type(smrv[mr]);
2822     //printf("set %08x @%08x r%d %d\n", smrv[mr], start+i*4, mr, type);
2823   }
2824   else {
2825     // use the mirror we are running on
2826     type=get_ptr_mem_type(start);
2827     //printf("set nospec   @%08x r%d %d\n", start+i*4, mr, type);
2828   }
2829
2830   if (dops[i].may_except) {
2831     // alignment check
2832     u_int op = dops[i].opcode;
2833     int mask = ((op & 0x37) == 0x21 || op == 0x25) ? 1 : 3; // LH/SH/LHU
2834     void *jaddr2;
2835     emit_testimm(addr, mask);
2836     jaddr2 = out;
2837     emit_jne(0);
2838     add_stub_r(ALIGNMENT_STUB, jaddr2, out, i, addr, i_regs, ccadj_, 0);
2839   }
2840
2841   if(type==MTYPE_8020) { // RAM 80200000+ mirror
2842     host_tempreg_acquire();
2843     emit_andimm(addr,~0x00e00000,HOST_TEMPREG);
2844     addr=*addr_reg_override=HOST_TEMPREG;
2845     type=0;
2846   }
2847   else if(type==MTYPE_0000) { // RAM 0 mirror
2848     host_tempreg_acquire();
2849     emit_orimm(addr,0x80000000,HOST_TEMPREG);
2850     addr=*addr_reg_override=HOST_TEMPREG;
2851     type=0;
2852   }
2853   else if(type==MTYPE_A000) { // RAM A mirror
2854     host_tempreg_acquire();
2855     emit_andimm(addr,~0x20000000,HOST_TEMPREG);
2856     addr=*addr_reg_override=HOST_TEMPREG;
2857     type=0;
2858   }
2859   else if(type==MTYPE_1F80) { // scratchpad
2860     if (psxH == (void *)0x1f800000) {
2861       host_tempreg_acquire();
2862       emit_xorimm(addr,0x1f800000,HOST_TEMPREG);
2863       emit_cmpimm(HOST_TEMPREG,0x1000);
2864       host_tempreg_release();
2865       jaddr=out;
2866       emit_jc(0);
2867     }
2868     else {
2869       // do the usual RAM check, jump will go to the right handler
2870       type=0;
2871     }
2872   }
2873
2874   if (type == 0) // need ram check
2875   {
2876     emit_cmpimm(addr,RAM_SIZE);
2877     jaddr = out;
2878     #ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
2879     // Hint to branch predictor that the branch is unlikely to be taken
2880     if (dops[i].rs1 >= 28)
2881       emit_jno_unlikely(0);
2882     else
2883     #endif
2884       emit_jno(0);
2885     if (ram_offset != 0)
2886       *offset_reg = get_ro_reg(i_regs, 0);
2887   }
2888
2889   return jaddr;
2890 }
2891
2892 // return memhandler, or get directly accessable address and return 0
2893 static void *get_direct_memhandler(void *table, u_int addr,
2894   enum stub_type type, uintptr_t *addr_host)
2895 {
2896   uintptr_t msb = 1ull << (sizeof(uintptr_t)*8 - 1);
2897   uintptr_t l1, l2 = 0;
2898   l1 = ((uintptr_t *)table)[addr>>12];
2899   if (!(l1 & msb)) {
2900     uintptr_t v = l1 << 1;
2901     *addr_host = v + addr;
2902     return NULL;
2903   }
2904   else {
2905     l1 <<= 1;
2906     if (type == LOADB_STUB || type == LOADBU_STUB || type == STOREB_STUB)
2907       l2 = ((uintptr_t *)l1)[0x1000/4 + 0x1000/2 + (addr&0xfff)];
2908     else if (type == LOADH_STUB || type == LOADHU_STUB || type == STOREH_STUB)
2909       l2 = ((uintptr_t *)l1)[0x1000/4 + (addr&0xfff)/2];
2910     else
2911       l2 = ((uintptr_t *)l1)[(addr&0xfff)/4];
2912     if (!(l2 & msb)) {
2913       uintptr_t v = l2 << 1;
2914       *addr_host = v + (addr&0xfff);
2915       return NULL;
2916     }
2917     return (void *)(l2 << 1);
2918   }
2919 }
2920
2921 static u_int get_host_reglist(const signed char *regmap)
2922 {
2923   u_int reglist = 0, hr;
2924   for (hr = 0; hr < HOST_REGS; hr++) {
2925     if (hr != EXCLUDE_REG && regmap[hr] >= 0)
2926       reglist |= 1 << hr;
2927   }
2928   return reglist;
2929 }
2930
2931 static u_int reglist_exclude(u_int reglist, int r1, int r2)
2932 {
2933   if (r1 >= 0)
2934     reglist &= ~(1u << r1);
2935   if (r2 >= 0)
2936     reglist &= ~(1u << r2);
2937   return reglist;
2938 }
2939
2940 // find a temp caller-saved register not in reglist (so assumed to be free)
2941 static int reglist_find_free(u_int reglist)
2942 {
2943   u_int free_regs = ~reglist & CALLER_SAVE_REGS;
2944   if (free_regs == 0)
2945     return -1;
2946   return __builtin_ctz(free_regs);
2947 }
2948
2949 static void do_load_word(int a, int rt, int offset_reg)
2950 {
2951   if (offset_reg >= 0)
2952     emit_ldr_dualindexed(offset_reg, a, rt);
2953   else
2954     emit_readword_indexed(0, a, rt);
2955 }
2956
2957 static void do_store_word(int a, int ofs, int rt, int offset_reg, int preseve_a)
2958 {
2959   if (offset_reg < 0) {
2960     emit_writeword_indexed(rt, ofs, a);
2961     return;
2962   }
2963   if (ofs != 0)
2964     emit_addimm(a, ofs, a);
2965   emit_str_dualindexed(offset_reg, a, rt);
2966   if (ofs != 0 && preseve_a)
2967     emit_addimm(a, -ofs, a);
2968 }
2969
2970 static void do_store_hword(int a, int ofs, int rt, int offset_reg, int preseve_a)
2971 {
2972   if (offset_reg < 0) {
2973     emit_writehword_indexed(rt, ofs, a);
2974     return;
2975   }
2976   if (ofs != 0)
2977     emit_addimm(a, ofs, a);
2978   emit_strh_dualindexed(offset_reg, a, rt);
2979   if (ofs != 0 && preseve_a)
2980     emit_addimm(a, -ofs, a);
2981 }
2982
2983 static void do_store_byte(int a, int rt, int offset_reg)
2984 {
2985   if (offset_reg >= 0)
2986     emit_strb_dualindexed(offset_reg, a, rt);
2987   else
2988     emit_writebyte_indexed(rt, 0, a);
2989 }
2990
2991 static void load_assemble(int i, const struct regstat *i_regs, int ccadj_)
2992 {
2993   int addr = cinfo[i].addr;
2994   int s,tl;
2995   int offset;
2996   void *jaddr=0;
2997   int memtarget=0,c=0;
2998   int offset_reg = -1;
2999   int fastio_reg_override = -1;
3000   u_int reglist=get_host_reglist(i_regs->regmap);
3001   tl=get_reg_w(i_regs->regmap, dops[i].rt1);
3002   s=get_reg(i_regs->regmap,dops[i].rs1);
3003   offset=cinfo[i].imm;
3004   if(i_regs->regmap[HOST_CCREG]==CCREG) reglist&=~(1<<HOST_CCREG);
3005   if(s>=0) {
3006     c=(i_regs->wasconst>>s)&1;
3007     if (c) {
3008       memtarget=((signed int)(constmap[i][s]+offset))<(signed int)0x80000000+RAM_SIZE;
3009     }
3010   }
3011   //printf("load_assemble: c=%d\n",c);
3012   //if(c) printf("load_assemble: const=%lx\n",(long)constmap[i][s]+offset);
3013   if(tl<0 && ((!c||(((u_int)constmap[i][s]+offset)>>16)==0x1f80) || dops[i].rt1==0)) {
3014       // could be FIFO, must perform the read
3015       // ||dummy read
3016       assem_debug("(forced read)\n");
3017       tl = get_reg_temp(i_regs->regmap); // may be == addr
3018       assert(tl>=0);
3019   }
3020   assert(addr >= 0);
3021  if(tl>=0) {
3022   //printf("load_assemble: c=%d\n",c);
3023   //if(c) printf("load_assemble: const=%lx\n",(long)constmap[i][s]+offset);
3024   reglist&=~(1<<tl);
3025   if(!c) {
3026     #ifdef R29_HACK
3027     // Strmnnrmn's speed hack
3028     if(dops[i].rs1!=29||start<0x80001000||start>=0x80000000+RAM_SIZE)
3029     #endif
3030     {
3031       jaddr = emit_fastpath_cmp_jump(i, i_regs, addr,
3032                 &offset_reg, &fastio_reg_override, ccadj_);
3033     }
3034   }
3035   else if (ram_offset && memtarget) {
3036     offset_reg = get_ro_reg(i_regs, 0);
3037   }
3038   int dummy=(dops[i].rt1==0)||(tl!=get_reg_w(i_regs->regmap, dops[i].rt1)); // ignore loads to r0 and unneeded reg
3039   switch (dops[i].opcode) {
3040   case 0x20: // LB
3041     if(!c||memtarget) {
3042       if(!dummy) {
3043         int a = addr;
3044         if (fastio_reg_override >= 0)
3045           a = fastio_reg_override;
3046
3047         if (offset_reg >= 0)
3048           emit_ldrsb_dualindexed(offset_reg, a, tl);
3049         else
3050           emit_movsbl_indexed(0, a, tl);
3051       }
3052       if(jaddr)
3053         add_stub_r(LOADB_STUB,jaddr,out,i,addr,i_regs,ccadj_,reglist);
3054     }
3055     else
3056       inline_readstub(LOADB_STUB,i,constmap[i][s]+offset,i_regs->regmap,dops[i].rt1,ccadj_,reglist);
3057     break;
3058   case 0x21: // LH
3059     if(!c||memtarget) {
3060       if(!dummy) {
3061         int a = addr;
3062         if (fastio_reg_override >= 0)
3063           a = fastio_reg_override;
3064         if (offset_reg >= 0)
3065           emit_ldrsh_dualindexed(offset_reg, a, tl);
3066         else
3067           emit_movswl_indexed(0, a, tl);
3068       }
3069       if(jaddr)
3070         add_stub_r(LOADH_STUB,jaddr,out,i,addr,i_regs,ccadj_,reglist);
3071     }
3072     else
3073       inline_readstub(LOADH_STUB,i,constmap[i][s]+offset,i_regs->regmap,dops[i].rt1,ccadj_,reglist);
3074     break;
3075   case 0x23: // LW
3076     if(!c||memtarget) {
3077       if(!dummy) {
3078         int a = addr;
3079         if (fastio_reg_override >= 0)
3080           a = fastio_reg_override;
3081         do_load_word(a, tl, offset_reg);
3082       }
3083       if(jaddr)
3084         add_stub_r(LOADW_STUB,jaddr,out,i,addr,i_regs,ccadj_,reglist);
3085     }
3086     else
3087       inline_readstub(LOADW_STUB,i,constmap[i][s]+offset,i_regs->regmap,dops[i].rt1,ccadj_,reglist);
3088     break;
3089   case 0x24: // LBU
3090     if(!c||memtarget) {
3091       if(!dummy) {
3092         int a = addr;
3093         if (fastio_reg_override >= 0)
3094           a = fastio_reg_override;
3095
3096         if (offset_reg >= 0)
3097           emit_ldrb_dualindexed(offset_reg, a, tl);
3098         else
3099           emit_movzbl_indexed(0, a, tl);
3100       }
3101       if(jaddr)
3102         add_stub_r(LOADBU_STUB,jaddr,out,i,addr,i_regs,ccadj_,reglist);
3103     }
3104     else
3105       inline_readstub(LOADBU_STUB,i,constmap[i][s]+offset,i_regs->regmap,dops[i].rt1,ccadj_,reglist);
3106     break;
3107   case 0x25: // LHU
3108     if(!c||memtarget) {
3109       if(!dummy) {
3110         int a = addr;
3111         if (fastio_reg_override >= 0)
3112           a = fastio_reg_override;
3113         if (offset_reg >= 0)
3114           emit_ldrh_dualindexed(offset_reg, a, tl);
3115         else
3116           emit_movzwl_indexed(0, a, tl);
3117       }
3118       if(jaddr)
3119         add_stub_r(LOADHU_STUB,jaddr,out,i,addr,i_regs,ccadj_,reglist);
3120     }
3121     else
3122       inline_readstub(LOADHU_STUB,i,constmap[i][s]+offset,i_regs->regmap,dops[i].rt1,ccadj_,reglist);
3123     break;
3124   default:
3125     assert(0);
3126   }
3127  } // tl >= 0
3128  if (fastio_reg_override == HOST_TEMPREG || offset_reg == HOST_TEMPREG)
3129    host_tempreg_release();
3130 }
3131
3132 #ifndef loadlr_assemble
3133 static void loadlr_assemble(int i, const struct regstat *i_regs, int ccadj_)
3134 {
3135   int addr = cinfo[i].addr;
3136   int s,tl,temp,temp2;
3137   int offset;
3138   void *jaddr=0;
3139   int memtarget=0,c=0;
3140   int offset_reg = -1;
3141   int fastio_reg_override = -1;
3142   u_int reglist=get_host_reglist(i_regs->regmap);
3143   tl=get_reg_w(i_regs->regmap, dops[i].rt1);
3144   s=get_reg(i_regs->regmap,dops[i].rs1);
3145   temp=get_reg_temp(i_regs->regmap);
3146   temp2=get_reg(i_regs->regmap,FTEMP);
3147   offset=cinfo[i].imm;
3148   reglist|=1<<temp;
3149   assert(addr >= 0);
3150   if(s>=0) {
3151     c=(i_regs->wasconst>>s)&1;
3152     if(c) {
3153       memtarget=((signed int)(constmap[i][s]+offset))<(signed int)0x80000000+RAM_SIZE;
3154     }
3155   }
3156   if(!c) {
3157     emit_shlimm(addr,3,temp);
3158     if (dops[i].opcode==0x22||dops[i].opcode==0x26) {
3159       emit_andimm(addr,0xFFFFFFFC,temp2); // LWL/LWR
3160     }else{
3161       emit_andimm(addr,0xFFFFFFF8,temp2); // LDL/LDR
3162     }
3163     jaddr = emit_fastpath_cmp_jump(i, i_regs, temp2,
3164               &offset_reg, &fastio_reg_override, ccadj_);
3165   }
3166   else {
3167     if (ram_offset && memtarget) {
3168       offset_reg = get_ro_reg(i_regs, 0);
3169     }
3170     if (dops[i].opcode==0x22||dops[i].opcode==0x26) {
3171       emit_movimm(((constmap[i][s]+offset)<<3)&24,temp); // LWL/LWR
3172     }else{
3173       emit_movimm(((constmap[i][s]+offset)<<3)&56,temp); // LDL/LDR
3174     }
3175   }
3176   if (dops[i].opcode==0x22||dops[i].opcode==0x26) { // LWL/LWR
3177     if(!c||memtarget) {
3178       int a = temp2;
3179       if (fastio_reg_override >= 0)
3180         a = fastio_reg_override;
3181       do_load_word(a, temp2, offset_reg);
3182       if (fastio_reg_override == HOST_TEMPREG || offset_reg == HOST_TEMPREG)
3183         host_tempreg_release();
3184       if(jaddr) add_stub_r(LOADW_STUB,jaddr,out,i,temp2,i_regs,ccadj_,reglist);
3185     }
3186     else
3187       inline_readstub(LOADW_STUB,i,(constmap[i][s]+offset)&0xFFFFFFFC,i_regs->regmap,FTEMP,ccadj_,reglist);
3188     if(dops[i].rt1) {
3189       assert(tl>=0);
3190       emit_andimm(temp,24,temp);
3191       if (dops[i].opcode==0x22) // LWL
3192         emit_xorimm(temp,24,temp);
3193       host_tempreg_acquire();
3194       emit_movimm(-1,HOST_TEMPREG);
3195       if (dops[i].opcode==0x26) {
3196         emit_shr(temp2,temp,temp2);
3197         emit_bic_lsr(tl,HOST_TEMPREG,temp,tl);
3198       }else{
3199         emit_shl(temp2,temp,temp2);
3200         emit_bic_lsl(tl,HOST_TEMPREG,temp,tl);
3201       }
3202       host_tempreg_release();
3203       emit_or(temp2,tl,tl);
3204     }
3205     //emit_storereg(dops[i].rt1,tl); // DEBUG
3206   }
3207   if (dops[i].opcode==0x1A||dops[i].opcode==0x1B) { // LDL/LDR
3208     assert(0);
3209   }
3210 }
3211 #endif
3212
3213 static void do_invstub(int n)
3214 {
3215   literal_pool(20);
3216   assem_debug("do_invstub %x\n", start + stubs[n].e*4);
3217   u_int reglist = stubs[n].a;
3218   u_int addrr = stubs[n].b;
3219   int ofs_start = stubs[n].c;
3220   int ofs_end = stubs[n].d;
3221   int len = ofs_end - ofs_start;
3222   u_int rightr = 0;
3223
3224   set_jump_target(stubs[n].addr, out);
3225   save_regs(reglist);
3226   if (addrr != 0 || ofs_start != 0)
3227     emit_addimm(addrr, ofs_start, 0);
3228   emit_readword(&inv_code_start, 2);
3229   emit_readword(&inv_code_end, 3);
3230   if (len != 0)
3231     emit_addimm(0, len + 4, (rightr = 1));
3232   emit_cmp(0, 2);
3233   emit_cmpcs(3, rightr);
3234   void *jaddr = out;
3235   emit_jc(0);
3236   void *func = (len != 0)
3237     ? (void *)ndrc_write_invalidate_many
3238     : (void *)ndrc_write_invalidate_one;
3239   emit_far_call(func);
3240   set_jump_target(jaddr, out);
3241   restore_regs(reglist);
3242   emit_jmp(stubs[n].retaddr);
3243 }
3244
3245 static void do_store_smc_check(int i, const struct regstat *i_regs, u_int reglist, int addr)
3246 {
3247   if (HACK_ENABLED(NDHACK_NO_SMC_CHECK))
3248     return;
3249   // this can't be used any more since we started to check exact
3250   // block boundaries in invalidate_range()
3251   //if (i_regs->waswritten & (1<<dops[i].rs1))
3252   //  return;
3253   // (naively) assume nobody will run code from stack
3254   if (dops[i].rs1 == 29)
3255     return;
3256
3257   int j, imm_maxdiff = 32, imm_min = cinfo[i].imm, imm_max = cinfo[i].imm, count = 1;
3258   if (i < slen - 1 && dops[i+1].is_store && dops[i+1].rs1 == dops[i].rs1
3259       && abs(cinfo[i+1].imm - cinfo[i].imm) <= imm_maxdiff)
3260     return;
3261   for (j = i - 1; j >= 0; j--) {
3262     if (!dops[j].is_store || dops[j].rs1 != dops[i].rs1
3263         || abs(cinfo[j].imm - cinfo[j+1].imm) > imm_maxdiff)
3264       break;
3265     count++;
3266     if (imm_min > cinfo[j].imm)
3267       imm_min = cinfo[j].imm;
3268     if (imm_max < cinfo[j].imm)
3269       imm_max = cinfo[j].imm;
3270   }
3271 #if defined(HOST_IMM8)
3272   int ir = get_reg(i_regs->regmap, INVCP);
3273   assert(ir >= 0);
3274   host_tempreg_acquire();
3275   emit_ldrb_indexedsr12_reg(ir, addr, HOST_TEMPREG);
3276 #else
3277   emit_cmpmem_indexedsr12_imm(invalid_code, addr, 1);
3278   #error not handled
3279 #endif
3280 #ifdef INVALIDATE_USE_COND_CALL
3281   if (count == 1) {
3282     emit_cmpimm(HOST_TEMPREG, 1);
3283     emit_callne(invalidate_addr_reg[addr]);
3284     host_tempreg_release();
3285     return;
3286   }
3287 #endif
3288   void *jaddr = emit_cbz(HOST_TEMPREG, 0);
3289   host_tempreg_release();
3290   imm_min -= cinfo[i].imm;
3291   imm_max -= cinfo[i].imm;
3292   add_stub(INVCODE_STUB, jaddr, out, reglist|(1<<HOST_CCREG),
3293     addr, imm_min, imm_max, i);
3294 }
3295
3296 // determines if code overwrite checking is needed only
3297 // (also true non-existent 0x20000000 mirror that shouldn't matter)
3298 #define is_ram_addr(a) !((a) & 0x5f800000)
3299
3300 static void store_assemble(int i, const struct regstat *i_regs, int ccadj_)
3301 {
3302   int s,tl;
3303   int addr = cinfo[i].addr;
3304   int offset;
3305   void *jaddr=0;
3306   enum stub_type type=0;
3307   int memtarget=0,c=0;
3308   int offset_reg = -1;
3309   int fastio_reg_override = -1;
3310   u_int addr_const = ~0;
3311   u_int reglist=get_host_reglist(i_regs->regmap);
3312   tl=get_reg(i_regs->regmap,dops[i].rs2);
3313   s=get_reg(i_regs->regmap,dops[i].rs1);
3314   offset=cinfo[i].imm;
3315   if(s>=0) {
3316     c=(i_regs->wasconst>>s)&1;
3317     if (c) {
3318       addr_const = constmap[i][s] + offset;
3319       memtarget = ((signed int)addr_const) < (signed int)(0x80000000 + RAM_SIZE);
3320     }
3321   }
3322   assert(tl>=0);
3323   assert(addr >= 0);
3324   if(i_regs->regmap[HOST_CCREG]==CCREG) reglist&=~(1<<HOST_CCREG);
3325   reglist |= 1u << addr;
3326   if (!c) {
3327     jaddr = emit_fastpath_cmp_jump(i, i_regs, addr,
3328               &offset_reg, &fastio_reg_override, ccadj_);
3329   }
3330   else if (ram_offset && memtarget) {
3331     offset_reg = get_ro_reg(i_regs, 0);
3332   }
3333
3334   switch (dops[i].opcode) {
3335   case 0x28: // SB
3336     if(!c||memtarget) {
3337       int a = addr;
3338       if (fastio_reg_override >= 0)
3339         a = fastio_reg_override;
3340       do_store_byte(a, tl, offset_reg);
3341     }
3342     type = STOREB_STUB;
3343     break;
3344   case 0x29: // SH
3345     if(!c||memtarget) {
3346       int a = addr;
3347       if (fastio_reg_override >= 0)
3348         a = fastio_reg_override;
3349       do_store_hword(a, 0, tl, offset_reg, 1);
3350     }
3351     type = STOREH_STUB;
3352     break;
3353   case 0x2B: // SW
3354     if(!c||memtarget) {
3355       int a = addr;
3356       if (fastio_reg_override >= 0)
3357         a = fastio_reg_override;
3358       do_store_word(a, 0, tl, offset_reg, 1);
3359     }
3360     type = STOREW_STUB;
3361     break;
3362   default:
3363     assert(0);
3364   }
3365   if (fastio_reg_override == HOST_TEMPREG || offset_reg == HOST_TEMPREG)
3366     host_tempreg_release();
3367   if (jaddr) {
3368     // PCSX store handlers don't check invcode again
3369     add_stub_r(type,jaddr,out,i,addr,i_regs,ccadj_,reglist);
3370   }
3371   if (!c || is_ram_addr(addr_const))
3372     do_store_smc_check(i, i_regs, reglist, addr);
3373   if (c && !memtarget)
3374     inline_writestub(type, i, addr_const, i_regs->regmap, dops[i].rs2, ccadj_, reglist);
3375   // basic current block modification detection..
3376   // not looking back as that should be in mips cache already
3377   // (see Spyro2 title->attract mode)
3378   if (start + i*4 < addr_const && addr_const < start + slen*4) {
3379     SysPrintf("write to %08x hits block %08x, pc=%08x\n", addr_const, start, start+i*4);
3380     assert(i_regs->regmap==regs[i].regmap); // not delay slot
3381     if(i_regs->regmap==regs[i].regmap) {
3382       load_all_consts(regs[i].regmap_entry,regs[i].wasdirty,i);
3383       wb_dirtys(regs[i].regmap_entry,regs[i].wasdirty);
3384       emit_movimm(start+i*4+4,0);
3385       emit_writeword(0,&pcaddr);
3386       emit_addimm(HOST_CCREG,2,HOST_CCREG);
3387       emit_far_call(ndrc_get_addr_ht);
3388       emit_jmpreg(0);
3389     }
3390   }
3391 }
3392
3393 static void storelr_assemble(int i, const struct regstat *i_regs, int ccadj_)
3394 {
3395   int addr = cinfo[i].addr;
3396   int s,tl;
3397   int offset;
3398   void *jaddr=0;
3399   void *case1, *case23, *case3;
3400   void *done0, *done1, *done2;
3401   int memtarget=0,c=0;
3402   int offset_reg = -1;
3403   u_int addr_const = ~0;
3404   u_int reglist = get_host_reglist(i_regs->regmap);
3405   tl=get_reg(i_regs->regmap,dops[i].rs2);
3406   s=get_reg(i_regs->regmap,dops[i].rs1);
3407   offset=cinfo[i].imm;
3408   if(s>=0) {
3409     c = (i_regs->isconst >> s) & 1;
3410     if (c) {
3411       addr_const = constmap[i][s] + offset;
3412       memtarget = ((signed int)addr_const) < (signed int)(0x80000000 + RAM_SIZE);
3413     }
3414   }
3415   assert(tl>=0);
3416   assert(addr >= 0);
3417   reglist |= 1u << addr;
3418   if(!c) {
3419     emit_cmpimm(addr, RAM_SIZE);
3420     jaddr=out;
3421     emit_jno(0);
3422   }
3423   else
3424   {
3425     if(!memtarget||!dops[i].rs1) {
3426       jaddr=out;
3427       emit_jmp(0);
3428     }
3429   }
3430   if (ram_offset)
3431     offset_reg = get_ro_reg(i_regs, 0);
3432
3433   emit_testimm(addr,2);
3434   case23=out;
3435   emit_jne(0);
3436   emit_testimm(addr,1);
3437   case1=out;
3438   emit_jne(0);
3439   // 0
3440   if (dops[i].opcode == 0x2A) { // SWL
3441     // Write msb into least significant byte
3442     if (dops[i].rs2) emit_rorimm(tl, 24, tl);
3443     do_store_byte(addr, tl, offset_reg);
3444     if (dops[i].rs2) emit_rorimm(tl, 8, tl);
3445   }
3446   else if (dops[i].opcode == 0x2E) { // SWR
3447     // Write entire word
3448     do_store_word(addr, 0, tl, offset_reg, 1);
3449   }
3450   done0 = out;
3451   emit_jmp(0);
3452   // 1
3453   set_jump_target(case1, out);
3454   if (dops[i].opcode == 0x2A) { // SWL
3455     // Write two msb into two least significant bytes
3456     if (dops[i].rs2) emit_rorimm(tl, 16, tl);
3457     do_store_hword(addr, -1, tl, offset_reg, 1);
3458     if (dops[i].rs2) emit_rorimm(tl, 16, tl);
3459   }
3460   else if (dops[i].opcode == 0x2E) { // SWR
3461     // Write 3 lsb into three most significant bytes
3462     do_store_byte(addr, tl, offset_reg);
3463     if (dops[i].rs2) emit_rorimm(tl, 8, tl);
3464     do_store_hword(addr, 1, tl, offset_reg, 1);
3465     if (dops[i].rs2) emit_rorimm(tl, 24, tl);
3466   }
3467   done1=out;
3468   emit_jmp(0);
3469   // 2,3
3470   set_jump_target(case23, out);
3471   emit_testimm(addr,1);
3472   case3 = out;
3473   emit_jne(0);
3474   // 2
3475   if (dops[i].opcode==0x2A) { // SWL
3476     // Write 3 msb into three least significant bytes
3477     if (dops[i].rs2) emit_rorimm(tl, 8, tl);
3478     do_store_hword(addr, -2, tl, offset_reg, 1);
3479     if (dops[i].rs2) emit_rorimm(tl, 16, tl);
3480     do_store_byte(addr, tl, offset_reg);
3481     if (dops[i].rs2) emit_rorimm(tl, 8, tl);
3482   }
3483   else if (dops[i].opcode == 0x2E) { // SWR
3484     // Write two lsb into two most significant bytes
3485     do_store_hword(addr, 0, tl, offset_reg, 1);
3486   }
3487   done2 = out;
3488   emit_jmp(0);
3489   // 3
3490   set_jump_target(case3, out);
3491   if (dops[i].opcode == 0x2A) { // SWL
3492     do_store_word(addr, -3, tl, offset_reg, 1);
3493   }
3494   else if (dops[i].opcode == 0x2E) { // SWR
3495     do_store_byte(addr, tl, offset_reg);
3496   }
3497   set_jump_target(done0, out);
3498   set_jump_target(done1, out);
3499   set_jump_target(done2, out);
3500   if (offset_reg == HOST_TEMPREG)
3501     host_tempreg_release();
3502   if (!c || !memtarget)
3503     add_stub_r(STORELR_STUB,jaddr,out,i,addr,i_regs,ccadj_,reglist);
3504   if (!c || is_ram_addr(addr_const))
3505     do_store_smc_check(i, i_regs, reglist, addr);
3506 }
3507
3508 static void cop0_assemble(int i, const struct regstat *i_regs, int ccadj_)
3509 {
3510   if(dops[i].opcode2==0) // MFC0
3511   {
3512     signed char t=get_reg_w(i_regs->regmap, dops[i].rt1);
3513     u_int copr=(source[i]>>11)&0x1f;
3514     if(t>=0&&dops[i].rt1!=0) {
3515       emit_readword(&reg_cop0[copr],t);
3516     }
3517   }
3518   else if(dops[i].opcode2==4) // MTC0
3519   {
3520     int s = get_reg(i_regs->regmap, dops[i].rs1);
3521     int cc = get_reg(i_regs->regmap, CCREG);
3522     char copr=(source[i]>>11)&0x1f;
3523     assert(s>=0);
3524     wb_register(dops[i].rs1,i_regs->regmap,i_regs->dirty);
3525     if (copr == 12 || copr == 13) {
3526       emit_readword(&last_count,HOST_TEMPREG);
3527       if (cc != HOST_CCREG)
3528         emit_loadreg(CCREG, HOST_CCREG);
3529       emit_add(HOST_CCREG, HOST_TEMPREG, HOST_CCREG);
3530       emit_addimm(HOST_CCREG, ccadj_ + 2, HOST_CCREG);
3531       emit_writeword(HOST_CCREG, &psxRegs.cycle);
3532       if (is_delayslot) {
3533         // burn cycles to cause cc_interrupt, which will
3534         // reschedule next_interupt. Relies on CCREG from above.
3535         assem_debug("MTC0 DS %d\n", copr);
3536         emit_writeword(HOST_CCREG,&last_count);
3537         emit_movimm(0,HOST_CCREG);
3538         emit_storereg(CCREG,HOST_CCREG);
3539         emit_loadreg(dops[i].rs1,1);
3540         emit_movimm(copr,0);
3541         emit_far_call(pcsx_mtc0_ds);
3542         emit_loadreg(dops[i].rs1,s);
3543         return;
3544       }
3545       emit_movimm(start+i*4+4,HOST_TEMPREG);
3546       emit_writeword(HOST_TEMPREG,&pcaddr);
3547       emit_movimm(0,HOST_TEMPREG);
3548       emit_writeword(HOST_TEMPREG,&pending_exception);
3549     }
3550     if( s != 1)
3551       emit_mov(s, 1);
3552     emit_movimm(copr, 0);
3553     emit_far_call(pcsx_mtc0);
3554     if (copr == 12 || copr == 13) {
3555       emit_readword(&psxRegs.cycle,HOST_CCREG);
3556       emit_readword(&last_count,HOST_TEMPREG);
3557       emit_sub(HOST_CCREG,HOST_TEMPREG,HOST_CCREG);
3558       //emit_writeword(HOST_TEMPREG,&last_count);
3559       assert(!is_delayslot);
3560       emit_readword(&pending_exception,HOST_TEMPREG);
3561       emit_test(HOST_TEMPREG,HOST_TEMPREG);
3562       void *jaddr = out;
3563       emit_jeq(0);
3564       emit_readword(&pcaddr, 0);
3565       emit_far_call(ndrc_get_addr_ht);
3566       emit_jmpreg(0);
3567       set_jump_target(jaddr, out);
3568       emit_addimm(HOST_CCREG, -ccadj_ - 2, HOST_CCREG);
3569       if (cc != HOST_CCREG)
3570         emit_storereg(CCREG, HOST_CCREG);
3571     }
3572     emit_loadreg(dops[i].rs1,s);
3573   }
3574 }
3575
3576 static void rfe_assemble(int i, const struct regstat *i_regs)
3577 {
3578   emit_readword(&psxRegs.CP0.n.SR, 0);
3579   emit_andimm(0, 0x3c, 1);
3580   emit_andimm(0, ~0xf, 0);
3581   emit_orrshr_imm(1, 2, 0);
3582   emit_writeword(0, &psxRegs.CP0.n.SR);
3583 }
3584
3585 static int cop2_is_stalling_op(int i, int *cycles)
3586 {
3587   if (dops[i].opcode == 0x3a) { // SWC2
3588     *cycles = 0;
3589     return 1;
3590   }
3591   if (dops[i].itype == COP2 && (dops[i].opcode2 == 0 || dops[i].opcode2 == 2)) { // MFC2/CFC2
3592     *cycles = 0;
3593     return 1;
3594   }
3595   if (dops[i].itype == C2OP) {
3596     *cycles = gte_cycletab[source[i] & 0x3f];
3597     return 1;
3598   }
3599   // ... what about MTC2/CTC2/LWC2?
3600   return 0;
3601 }
3602
3603 #if 0
3604 static void log_gte_stall(int stall, u_int cycle)
3605 {
3606   if ((u_int)stall <= 44)
3607     printf("x    stall %2d %u\n", stall, cycle + last_count);
3608 }
3609
3610 static void emit_log_gte_stall(int i, int stall, u_int reglist)
3611 {
3612   save_regs(reglist);
3613   if (stall > 0)
3614     emit_movimm(stall, 0);
3615   else
3616     emit_mov(HOST_TEMPREG, 0);
3617   emit_addimm(HOST_CCREG, cinfo[i].ccadj, 1);
3618   emit_far_call(log_gte_stall);
3619   restore_regs(reglist);
3620 }
3621 #endif
3622
3623 static void cop2_do_stall_check(u_int op, int i, const struct regstat *i_regs, u_int reglist)
3624 {
3625   int j = i, other_gte_op_cycles = -1, stall = -MAXBLOCK, cycles_passed;
3626   int rtmp = reglist_find_free(reglist);
3627
3628   if (HACK_ENABLED(NDHACK_NO_STALLS))
3629     return;
3630   if (get_reg(i_regs->regmap, CCREG) != HOST_CCREG) {
3631     // happens occasionally... cc evicted? Don't bother then
3632     //printf("no cc %08x\n", start + i*4);
3633     return;
3634   }
3635   if (!dops[i].bt) {
3636     for (j = i - 1; j >= 0; j--) {
3637       //if (dops[j].is_ds) break;
3638       if (cop2_is_stalling_op(j, &other_gte_op_cycles) || dops[j].bt)
3639         break;
3640       if (j > 0 && cinfo[j - 1].ccadj > cinfo[j].ccadj)
3641         break;
3642     }
3643     j = max(j, 0);
3644   }
3645   cycles_passed = cinfo[i].ccadj - cinfo[j].ccadj;
3646   if (other_gte_op_cycles >= 0)
3647     stall = other_gte_op_cycles - cycles_passed;
3648   else if (cycles_passed >= 44)
3649     stall = 0; // can't stall
3650   if (stall == -MAXBLOCK && rtmp >= 0) {
3651     // unknown stall, do the expensive runtime check
3652     assem_debug("; cop2_do_stall_check\n");
3653 #if 0 // too slow
3654     save_regs(reglist);
3655     emit_movimm(gte_cycletab[op], 0);
3656     emit_addimm(HOST_CCREG, cinfo[i].ccadj, 1);
3657     emit_far_call(call_gteStall);
3658     restore_regs(reglist);
3659 #else
3660     host_tempreg_acquire();
3661     emit_readword(&psxRegs.gteBusyCycle, rtmp);
3662     emit_addimm(rtmp, -cinfo[i].ccadj, rtmp);
3663     emit_sub(rtmp, HOST_CCREG, HOST_TEMPREG);
3664     emit_cmpimm(HOST_TEMPREG, 44);
3665     emit_cmovb_reg(rtmp, HOST_CCREG);
3666     //emit_log_gte_stall(i, 0, reglist);
3667     host_tempreg_release();
3668 #endif
3669   }
3670   else if (stall > 0) {
3671     //emit_log_gte_stall(i, stall, reglist);
3672     emit_addimm(HOST_CCREG, stall, HOST_CCREG);
3673   }
3674
3675   // save gteBusyCycle, if needed
3676   if (gte_cycletab[op] == 0)
3677     return;
3678   other_gte_op_cycles = -1;
3679   for (j = i + 1; j < slen; j++) {
3680     if (cop2_is_stalling_op(j, &other_gte_op_cycles))
3681       break;
3682     if (dops[j].is_jump) {
3683       // check ds
3684       if (j + 1 < slen && cop2_is_stalling_op(j + 1, &other_gte_op_cycles))
3685         j++;
3686       break;
3687     }
3688   }
3689   if (other_gte_op_cycles >= 0)
3690     // will handle stall when assembling that op
3691     return;
3692   cycles_passed = cinfo[min(j, slen -1)].ccadj - cinfo[i].ccadj;
3693   if (cycles_passed >= 44)
3694     return;
3695   assem_debug("; save gteBusyCycle\n");
3696   host_tempreg_acquire();
3697 #if 0
3698   emit_readword(&last_count, HOST_TEMPREG);
3699   emit_add(HOST_TEMPREG, HOST_CCREG, HOST_TEMPREG);
3700   emit_addimm(HOST_TEMPREG, cinfo[i].ccadj, HOST_TEMPREG);
3701   emit_addimm(HOST_TEMPREG, gte_cycletab[op]), HOST_TEMPREG);
3702   emit_writeword(HOST_TEMPREG, &psxRegs.gteBusyCycle);
3703 #else
3704   emit_addimm(HOST_CCREG, cinfo[i].ccadj + gte_cycletab[op], HOST_TEMPREG);
3705   emit_writeword(HOST_TEMPREG, &psxRegs.gteBusyCycle);
3706 #endif
3707   host_tempreg_release();
3708 }
3709
3710 static int is_mflohi(int i)
3711 {
3712   return (dops[i].itype == MOV && (dops[i].rs1 == HIREG || dops[i].rs1 == LOREG));
3713 }
3714
3715 static int check_multdiv(int i, int *cycles)
3716 {
3717   if (dops[i].itype != MULTDIV)
3718     return 0;
3719   if (dops[i].opcode2 == 0x18 || dops[i].opcode2 == 0x19) // MULT(U)
3720     *cycles = 11; // approx from 7 11 14
3721   else
3722     *cycles = 37;
3723   return 1;
3724 }
3725
3726 static void multdiv_prepare_stall(int i, const struct regstat *i_regs, int ccadj_)
3727 {
3728   int j, found = 0, c = 0;
3729   if (HACK_ENABLED(NDHACK_NO_STALLS))
3730     return;
3731   if (get_reg(i_regs->regmap, CCREG) != HOST_CCREG) {
3732     // happens occasionally... cc evicted? Don't bother then
3733     return;
3734   }
3735   for (j = i + 1; j < slen; j++) {
3736     if (dops[j].bt)
3737       break;
3738     if ((found = is_mflohi(j)))
3739       break;
3740     if (dops[j].is_jump) {
3741       // check ds
3742       if (j + 1 < slen && (found = is_mflohi(j + 1)))
3743         j++;
3744       break;
3745     }
3746   }
3747   if (found)
3748     // handle all in multdiv_do_stall()
3749     return;
3750   check_multdiv(i, &c);
3751   assert(c > 0);
3752   assem_debug("; muldiv prepare stall %d\n", c);
3753   host_tempreg_acquire();
3754   emit_addimm(HOST_CCREG, ccadj_ + c, HOST_TEMPREG);
3755   emit_writeword(HOST_TEMPREG, &psxRegs.muldivBusyCycle);
3756   host_tempreg_release();
3757 }
3758
3759 static void multdiv_do_stall(int i, const struct regstat *i_regs)
3760 {
3761   int j, known_cycles = 0;
3762   u_int reglist = get_host_reglist(i_regs->regmap);
3763   int rtmp = get_reg_temp(i_regs->regmap);
3764   if (rtmp < 0)
3765     rtmp = reglist_find_free(reglist);
3766   if (HACK_ENABLED(NDHACK_NO_STALLS))
3767     return;
3768   if (get_reg(i_regs->regmap, CCREG) != HOST_CCREG || rtmp < 0) {
3769     // happens occasionally... cc evicted? Don't bother then
3770     //printf("no cc/rtmp %08x\n", start + i*4);
3771     return;
3772   }
3773   if (!dops[i].bt) {
3774     for (j = i - 1; j >= 0; j--) {
3775       if (dops[j].is_ds) break;
3776       if (check_multdiv(j, &known_cycles))
3777         break;
3778       if (is_mflohi(j))
3779         // already handled by this op
3780         return;
3781       if (dops[j].bt || (j > 0 && cinfo[j - 1].ccadj > cinfo[j].ccadj))
3782         break;
3783     }
3784     j = max(j, 0);
3785   }
3786   if (known_cycles > 0) {
3787     known_cycles -= cinfo[i].ccadj - cinfo[j].ccadj;
3788     assem_debug("; muldiv stall resolved %d\n", known_cycles);
3789     if (known_cycles > 0)
3790       emit_addimm(HOST_CCREG, known_cycles, HOST_CCREG);
3791     return;
3792   }
3793   assem_debug("; muldiv stall unresolved\n");
3794   host_tempreg_acquire();
3795   emit_readword(&psxRegs.muldivBusyCycle, rtmp);
3796   emit_addimm(rtmp, -cinfo[i].ccadj, rtmp);
3797   emit_sub(rtmp, HOST_CCREG, HOST_TEMPREG);
3798   emit_cmpimm(HOST_TEMPREG, 37);
3799   emit_cmovb_reg(rtmp, HOST_CCREG);
3800   //emit_log_gte_stall(i, 0, reglist);
3801   host_tempreg_release();
3802 }
3803
3804 static void cop2_get_dreg(u_int copr,signed char tl,signed char temp)
3805 {
3806   switch (copr) {
3807     case 1:
3808     case 3:
3809     case 5:
3810     case 8:
3811     case 9:
3812     case 10:
3813     case 11:
3814       emit_readword(&reg_cop2d[copr],tl);
3815       emit_signextend16(tl,tl);
3816       emit_writeword(tl,&reg_cop2d[copr]); // hmh
3817       break;
3818     case 7:
3819     case 16:
3820     case 17:
3821     case 18:
3822     case 19:
3823       emit_readword(&reg_cop2d[copr],tl);
3824       emit_andimm(tl,0xffff,tl);
3825       emit_writeword(tl,&reg_cop2d[copr]);
3826       break;
3827     case 15:
3828       emit_readword(&reg_cop2d[14],tl); // SXY2
3829       emit_writeword(tl,&reg_cop2d[copr]);
3830       break;
3831     case 28:
3832     case 29:
3833       c2op_mfc2_29_assemble(tl,temp);
3834       break;
3835     default:
3836       emit_readword(&reg_cop2d[copr],tl);
3837       break;
3838   }
3839 }
3840
3841 static void cop2_put_dreg(u_int copr,signed char sl,signed char temp)
3842 {
3843   switch (copr) {
3844     case 15:
3845       emit_readword(&reg_cop2d[13],temp);  // SXY1
3846       emit_writeword(sl,&reg_cop2d[copr]);
3847       emit_writeword(temp,&reg_cop2d[12]); // SXY0
3848       emit_readword(&reg_cop2d[14],temp);  // SXY2
3849       emit_writeword(sl,&reg_cop2d[14]);
3850       emit_writeword(temp,&reg_cop2d[13]); // SXY1
3851       break;
3852     case 28:
3853       emit_andimm(sl,0x001f,temp);
3854       emit_shlimm(temp,7,temp);
3855       emit_writeword(temp,&reg_cop2d[9]);
3856       emit_andimm(sl,0x03e0,temp);
3857       emit_shlimm(temp,2,temp);
3858       emit_writeword(temp,&reg_cop2d[10]);
3859       emit_andimm(sl,0x7c00,temp);
3860       emit_shrimm(temp,3,temp);
3861       emit_writeword(temp,&reg_cop2d[11]);
3862       emit_writeword(sl,&reg_cop2d[28]);
3863       break;
3864     case 30:
3865       emit_xorsar_imm(sl,sl,31,temp);
3866 #if defined(HAVE_ARMV5) || defined(__aarch64__)
3867       emit_clz(temp,temp);
3868 #else
3869       emit_movs(temp,HOST_TEMPREG);
3870       emit_movimm(0,temp);
3871       emit_jeq((int)out+4*4);
3872       emit_addpl_imm(temp,1,temp);
3873       emit_lslpls_imm(HOST_TEMPREG,1,HOST_TEMPREG);
3874       emit_jns((int)out-2*4);
3875 #endif
3876       emit_writeword(sl,&reg_cop2d[30]);
3877       emit_writeword(temp,&reg_cop2d[31]);
3878       break;
3879     case 31:
3880       break;
3881     default:
3882       emit_writeword(sl,&reg_cop2d[copr]);
3883       break;
3884   }
3885 }
3886
3887 static void c2ls_assemble(int i, const struct regstat *i_regs, int ccadj_)
3888 {
3889   int s,tl;
3890   int ar;
3891   int offset;
3892   int memtarget=0,c=0;
3893   void *jaddr2=NULL;
3894   enum stub_type type;
3895   int offset_reg = -1;
3896   int fastio_reg_override = -1;
3897   u_int addr_const = ~0;
3898   u_int reglist=get_host_reglist(i_regs->regmap);
3899   u_int copr=(source[i]>>16)&0x1f;
3900   s=get_reg(i_regs->regmap,dops[i].rs1);
3901   tl=get_reg(i_regs->regmap,FTEMP);
3902   offset=cinfo[i].imm;
3903   assert(tl>=0);
3904
3905   if(i_regs->regmap[HOST_CCREG]==CCREG)
3906     reglist&=~(1<<HOST_CCREG);
3907
3908   // get the address
3909   ar = cinfo[i].addr;
3910   assert(ar >= 0);
3911   if (dops[i].opcode==0x3a) { // SWC2
3912     reglist |= 1<<ar;
3913   }
3914   if (s >= 0) {
3915     c = (i_regs->isconst >> s) & 1;
3916     if (c) {
3917       addr_const = constmap[i][s] + offset;
3918       memtarget = ((signed int)addr_const) < (signed int)(0x80000000 + RAM_SIZE);
3919     }
3920   }
3921
3922   cop2_do_stall_check(0, i, i_regs, reglist);
3923
3924   if (dops[i].opcode==0x3a) { // SWC2
3925     cop2_get_dreg(copr,tl,-1);
3926     type=STOREW_STUB;
3927   }
3928   else
3929     type=LOADW_STUB;
3930
3931   if(c&&!memtarget) {
3932     jaddr2=out;
3933     emit_jmp(0); // inline_readstub/inline_writestub?
3934   }
3935   else {
3936     if(!c) {
3937       jaddr2 = emit_fastpath_cmp_jump(i, i_regs, ar,
3938                 &offset_reg, &fastio_reg_override, ccadj_);
3939     }
3940     else if (ram_offset && memtarget) {
3941       offset_reg = get_ro_reg(i_regs, 0);
3942     }
3943     switch (dops[i].opcode) {
3944     case 0x32: { // LWC2
3945       int a = ar;
3946       if (fastio_reg_override >= 0)
3947         a = fastio_reg_override;
3948       do_load_word(a, tl, offset_reg);
3949       break;
3950     }
3951     case 0x3a: { // SWC2
3952       #ifdef DESTRUCTIVE_SHIFT
3953       if(!offset&&!c&&s>=0) emit_mov(s,ar);
3954       #endif
3955       int a = ar;
3956       if (fastio_reg_override >= 0)
3957         a = fastio_reg_override;
3958       do_store_word(a, 0, tl, offset_reg, 1);
3959       break;
3960     }
3961     default:
3962       assert(0);
3963     }
3964   }
3965   if (fastio_reg_override == HOST_TEMPREG || offset_reg == HOST_TEMPREG)
3966     host_tempreg_release();
3967   if(jaddr2)
3968     add_stub_r(type,jaddr2,out,i,ar,i_regs,ccadj_,reglist);
3969   if (dops[i].opcode == 0x3a && (!c || is_ram_addr(addr_const))) // SWC2
3970     do_store_smc_check(i, i_regs, reglist, ar);
3971   if (dops[i].opcode == 0x32) { // LWC2
3972     host_tempreg_acquire();
3973     cop2_put_dreg(copr,tl,HOST_TEMPREG);
3974     host_tempreg_release();
3975   }
3976 }
3977
3978 static void cop2_assemble(int i, const struct regstat *i_regs)
3979 {
3980   u_int copr = (source[i]>>11) & 0x1f;
3981   signed char temp = get_reg_temp(i_regs->regmap);
3982
3983   if (!HACK_ENABLED(NDHACK_NO_STALLS)) {
3984     u_int reglist = reglist_exclude(get_host_reglist(i_regs->regmap), temp, -1);
3985     if (dops[i].opcode2 == 0 || dops[i].opcode2 == 2) { // MFC2/CFC2
3986       signed char tl = get_reg(i_regs->regmap, dops[i].rt1);
3987       reglist = reglist_exclude(reglist, tl, -1);
3988     }
3989     cop2_do_stall_check(0, i, i_regs, reglist);
3990   }
3991   if (dops[i].opcode2==0) { // MFC2
3992     signed char tl=get_reg_w(i_regs->regmap, dops[i].rt1);
3993     if(tl>=0&&dops[i].rt1!=0)
3994       cop2_get_dreg(copr,tl,temp);
3995   }
3996   else if (dops[i].opcode2==4) { // MTC2
3997     signed char sl=get_reg(i_regs->regmap,dops[i].rs1);
3998     cop2_put_dreg(copr,sl,temp);
3999   }
4000   else if (dops[i].opcode2==2) // CFC2
4001   {
4002     signed char tl=get_reg_w(i_regs->regmap, dops[i].rt1);
4003     if(tl>=0&&dops[i].rt1!=0)
4004       emit_readword(&reg_cop2c[copr],tl);
4005   }
4006   else if (dops[i].opcode2==6) // CTC2
4007   {
4008     signed char sl=get_reg(i_regs->regmap,dops[i].rs1);
4009     switch(copr) {
4010       case 4:
4011       case 12:
4012       case 20:
4013       case 26:
4014       case 27:
4015       case 29:
4016       case 30:
4017         emit_signextend16(sl,temp);
4018         break;
4019       case 31:
4020         c2op_ctc2_31_assemble(sl,temp);
4021         break;
4022       default:
4023         temp=sl;
4024         break;
4025     }
4026     emit_writeword(temp,&reg_cop2c[copr]);
4027     assert(sl>=0);
4028   }
4029 }
4030
4031 static void do_unalignedwritestub(int n)
4032 {
4033   assem_debug("do_unalignedwritestub %x\n",start+stubs[n].a*4);
4034   literal_pool(256);
4035   set_jump_target(stubs[n].addr, out);
4036
4037   int i=stubs[n].a;
4038   struct regstat *i_regs=(struct regstat *)stubs[n].c;
4039   int addr=stubs[n].b;
4040   u_int reglist=stubs[n].e;
4041   signed char *i_regmap=i_regs->regmap;
4042   int temp2=get_reg(i_regmap,FTEMP);
4043   int rt;
4044   rt=get_reg(i_regmap,dops[i].rs2);
4045   assert(rt>=0);
4046   assert(addr>=0);
4047   assert(dops[i].opcode==0x2a||dops[i].opcode==0x2e); // SWL/SWR only implemented
4048   reglist|=(1<<addr);
4049   reglist&=~(1<<temp2);
4050
4051   // don't bother with it and call write handler
4052   save_regs(reglist);
4053   pass_args(addr,rt);
4054   int cc=get_reg(i_regmap,CCREG);
4055   if(cc<0)
4056     emit_loadreg(CCREG,2);
4057   emit_addimm(cc<0?2:cc,(int)stubs[n].d+1,2);
4058   emit_movimm(start + i*4,3);
4059   emit_writeword(3,&psxRegs.pc);
4060   emit_far_call((dops[i].opcode==0x2a?jump_handle_swl:jump_handle_swr));
4061   emit_addimm(0,-((int)stubs[n].d+1),cc<0?2:cc);
4062   if(cc<0)
4063     emit_storereg(CCREG,2);
4064   restore_regs(reglist);
4065   emit_jmp(stubs[n].retaddr); // return address
4066 }
4067
4068 static void do_overflowstub(int n)
4069 {
4070   assem_debug("do_overflowstub %x\n", start + (u_int)stubs[n].a * 4);
4071   literal_pool(24);
4072   int i = stubs[n].a;
4073   struct regstat *i_regs = (struct regstat *)stubs[n].c;
4074   int ccadj = stubs[n].d;
4075   set_jump_target(stubs[n].addr, out);
4076   wb_dirtys(regs[i].regmap, regs[i].dirty);
4077   exception_assemble(i, i_regs, ccadj);
4078 }
4079
4080 static void do_alignmentstub(int n)
4081 {
4082   assem_debug("do_alignmentstub %x\n", start + (u_int)stubs[n].a * 4);
4083   literal_pool(24);
4084   int i = stubs[n].a;
4085   struct regstat *i_regs = (struct regstat *)stubs[n].c;
4086   int ccadj = stubs[n].d;
4087   int is_store = dops[i].itype == STORE || dops[i].opcode == 0x3A; // SWC2
4088   int cause = (dops[i].opcode & 3) << 28;
4089   cause |= is_store ? (R3000E_AdES << 2) : (R3000E_AdEL << 2);
4090   set_jump_target(stubs[n].addr, out);
4091   wb_dirtys(regs[i].regmap, regs[i].dirty);
4092   if (stubs[n].b != 1)
4093     emit_mov(stubs[n].b, 1); // faulting address
4094   emit_movimm(cause, 0);
4095   exception_assemble(i, i_regs, ccadj);
4096 }
4097
4098 #ifndef multdiv_assemble
4099 void multdiv_assemble(int i,struct regstat *i_regs)
4100 {
4101   printf("Need multdiv_assemble for this architecture.\n");
4102   abort();
4103 }
4104 #endif
4105
4106 static void mov_assemble(int i, const struct regstat *i_regs)
4107 {
4108   //if(dops[i].opcode2==0x10||dops[i].opcode2==0x12) { // MFHI/MFLO
4109   //if(dops[i].opcode2==0x11||dops[i].opcode2==0x13) { // MTHI/MTLO
4110   if(dops[i].rt1) {
4111     signed char sl,tl;
4112     tl=get_reg_w(i_regs->regmap, dops[i].rt1);
4113     //assert(tl>=0);
4114     if(tl>=0) {
4115       sl=get_reg(i_regs->regmap,dops[i].rs1);
4116       if(sl>=0) emit_mov(sl,tl);
4117       else emit_loadreg(dops[i].rs1,tl);
4118     }
4119   }
4120   if (dops[i].rs1 == HIREG || dops[i].rs1 == LOREG) // MFHI/MFLO
4121     multdiv_do_stall(i, i_regs);
4122 }
4123
4124 // call interpreter, exception handler, things that change pc/regs/cycles ...
4125 static void call_c_cpu_handler(int i, const struct regstat *i_regs, int ccadj_, u_int pc, void *func)
4126 {
4127   signed char ccreg=get_reg(i_regs->regmap,CCREG);
4128   assert(ccreg==HOST_CCREG);
4129   assert(!is_delayslot);
4130   (void)ccreg;
4131
4132   emit_movimm(pc,3); // Get PC
4133   emit_readword(&last_count,2);
4134   emit_writeword(3,&psxRegs.pc);
4135   emit_addimm(HOST_CCREG,ccadj_,HOST_CCREG);
4136   emit_add(2,HOST_CCREG,2);
4137   emit_writeword(2,&psxRegs.cycle);
4138   emit_addimm_ptr(FP,(u_char *)&psxRegs - (u_char *)&dynarec_local,0);
4139   emit_far_call(func);
4140   emit_far_jump(jump_to_new_pc);
4141 }
4142
4143 static void exception_assemble(int i, const struct regstat *i_regs, int ccadj_)
4144 {
4145   // 'break' tends to be littered around to catch things like
4146   // division by 0 and is almost never executed, so don't emit much code here
4147   void *func;
4148   if (dops[i].itype == ALU || dops[i].itype == IMM16)
4149     func = is_delayslot ? jump_overflow_ds : jump_overflow;
4150   else if (dops[i].itype == LOAD || dops[i].itype == STORE)
4151     func = is_delayslot ? jump_addrerror_ds : jump_addrerror;
4152   else if (dops[i].opcode2 == 0x0C)
4153     func = is_delayslot ? jump_syscall_ds : jump_syscall;
4154   else
4155     func = is_delayslot ? jump_break_ds : jump_break;
4156   if (get_reg(i_regs->regmap, CCREG) != HOST_CCREG) // evicted
4157     emit_loadreg(CCREG, HOST_CCREG);
4158   emit_movimm(start + i*4, 2); // pc
4159   emit_addimm(HOST_CCREG, ccadj_ + CLOCK_ADJUST(1), HOST_CCREG);
4160   emit_far_jump(func);
4161 }
4162
4163 static void hlecall_bad()
4164 {
4165   assert(0);
4166 }
4167
4168 static void hlecall_assemble(int i, const struct regstat *i_regs, int ccadj_)
4169 {
4170   void *hlefunc = hlecall_bad;
4171   uint32_t hleCode = source[i] & 0x03ffffff;
4172   if (hleCode < ARRAY_SIZE(psxHLEt))
4173     hlefunc = psxHLEt[hleCode];
4174
4175   call_c_cpu_handler(i, i_regs, ccadj_, start + i*4+4, hlefunc);
4176 }
4177
4178 static void intcall_assemble(int i, const struct regstat *i_regs, int ccadj_)
4179 {
4180   call_c_cpu_handler(i, i_regs, ccadj_, start + i*4, execI);
4181 }
4182
4183 static void speculate_mov(int rs,int rt)
4184 {
4185   if(rt!=0) {
4186     smrv_strong_next|=1<<rt;
4187     smrv[rt]=smrv[rs];
4188   }
4189 }
4190
4191 static void speculate_mov_weak(int rs,int rt)
4192 {
4193   if(rt!=0) {
4194     smrv_weak_next|=1<<rt;
4195     smrv[rt]=smrv[rs];
4196   }
4197 }
4198
4199 static void speculate_register_values(int i)
4200 {
4201   if(i==0) {
4202     memcpy(smrv,psxRegs.GPR.r,sizeof(smrv));
4203     // gp,sp are likely to stay the same throughout the block
4204     smrv_strong_next=(1<<28)|(1<<29)|(1<<30);
4205     smrv_weak_next=~smrv_strong_next;
4206     //printf(" llr %08x\n", smrv[4]);
4207   }
4208   smrv_strong=smrv_strong_next;
4209   smrv_weak=smrv_weak_next;
4210   switch(dops[i].itype) {
4211     case ALU:
4212       if     ((smrv_strong>>dops[i].rs1)&1) speculate_mov(dops[i].rs1,dops[i].rt1);
4213       else if((smrv_strong>>dops[i].rs2)&1) speculate_mov(dops[i].rs2,dops[i].rt1);
4214       else if((smrv_weak>>dops[i].rs1)&1) speculate_mov_weak(dops[i].rs1,dops[i].rt1);
4215       else if((smrv_weak>>dops[i].rs2)&1) speculate_mov_weak(dops[i].rs2,dops[i].rt1);
4216       else {
4217         smrv_strong_next&=~(1<<dops[i].rt1);
4218         smrv_weak_next&=~(1<<dops[i].rt1);
4219       }
4220       break;
4221     case SHIFTIMM:
4222       smrv_strong_next&=~(1<<dops[i].rt1);
4223       smrv_weak_next&=~(1<<dops[i].rt1);
4224       // fallthrough
4225     case IMM16:
4226       if(dops[i].rt1&&is_const(&regs[i],dops[i].rt1)) {
4227         int hr = get_reg_w(regs[i].regmap, dops[i].rt1);
4228         u_int value;
4229         if(hr>=0) {
4230           if(get_final_value(hr,i,&value))
4231                smrv[dops[i].rt1]=value;
4232           else smrv[dops[i].rt1]=constmap[i][hr];
4233           smrv_strong_next|=1<<dops[i].rt1;
4234         }
4235       }
4236       else {
4237         if     ((smrv_strong>>dops[i].rs1)&1) speculate_mov(dops[i].rs1,dops[i].rt1);
4238         else if((smrv_weak>>dops[i].rs1)&1) speculate_mov_weak(dops[i].rs1,dops[i].rt1);
4239       }
4240       break;
4241     case LOAD:
4242       if(start<0x2000&&(dops[i].rt1==26||(smrv[dops[i].rt1]>>24)==0xa0)) {
4243         // special case for BIOS
4244         smrv[dops[i].rt1]=0xa0000000;
4245         smrv_strong_next|=1<<dops[i].rt1;
4246         break;
4247       }
4248       // fallthrough
4249     case SHIFT:
4250     case LOADLR:
4251     case MOV:
4252       smrv_strong_next&=~(1<<dops[i].rt1);
4253       smrv_weak_next&=~(1<<dops[i].rt1);
4254       break;
4255     case COP0:
4256     case COP2:
4257       if(dops[i].opcode2==0||dops[i].opcode2==2) { // MFC/CFC
4258         smrv_strong_next&=~(1<<dops[i].rt1);
4259         smrv_weak_next&=~(1<<dops[i].rt1);
4260       }
4261       break;
4262     case C2LS:
4263       if (dops[i].opcode==0x32) { // LWC2
4264         smrv_strong_next&=~(1<<dops[i].rt1);
4265         smrv_weak_next&=~(1<<dops[i].rt1);
4266       }
4267       break;
4268   }
4269 #if 0
4270   int r=4;
4271   printf("x %08x %08x %d %d c %08x %08x\n",smrv[r],start+i*4,
4272     ((smrv_strong>>r)&1),(smrv_weak>>r)&1,regs[i].isconst,regs[i].wasconst);
4273 #endif
4274 }
4275
4276 static void ujump_assemble(int i, const struct regstat *i_regs);
4277 static void rjump_assemble(int i, const struct regstat *i_regs);
4278 static void cjump_assemble(int i, const struct regstat *i_regs);
4279 static void sjump_assemble(int i, const struct regstat *i_regs);
4280
4281 static int assemble(int i, const struct regstat *i_regs, int ccadj_)
4282 {
4283   int ds = 0;
4284   switch (dops[i].itype) {
4285     case ALU:
4286       alu_assemble(i, i_regs, ccadj_);
4287       break;
4288     case IMM16:
4289       imm16_assemble(i, i_regs, ccadj_);
4290       break;
4291     case SHIFT:
4292       shift_assemble(i, i_regs);
4293       break;
4294     case SHIFTIMM:
4295       shiftimm_assemble(i, i_regs);
4296       break;
4297     case LOAD:
4298       load_assemble(i, i_regs, ccadj_);
4299       break;
4300     case LOADLR:
4301       loadlr_assemble(i, i_regs, ccadj_);
4302       break;
4303     case STORE:
4304       store_assemble(i, i_regs, ccadj_);
4305       break;
4306     case STORELR:
4307       storelr_assemble(i, i_regs, ccadj_);
4308       break;
4309     case COP0:
4310       cop0_assemble(i, i_regs, ccadj_);
4311       break;
4312     case RFE:
4313       rfe_assemble(i, i_regs);
4314       break;
4315     case COP2:
4316       cop2_assemble(i, i_regs);
4317       break;
4318     case C2LS:
4319       c2ls_assemble(i, i_regs, ccadj_);
4320       break;
4321     case C2OP:
4322       c2op_assemble(i, i_regs);
4323       break;
4324     case MULTDIV:
4325       multdiv_assemble(i, i_regs);
4326       multdiv_prepare_stall(i, i_regs, ccadj_);
4327       break;
4328     case MOV:
4329       mov_assemble(i, i_regs);
4330       break;
4331     case SYSCALL:
4332       exception_assemble(i, i_regs, ccadj_);
4333       break;
4334     case HLECALL:
4335       hlecall_assemble(i, i_regs, ccadj_);
4336       break;
4337     case INTCALL:
4338       intcall_assemble(i, i_regs, ccadj_);
4339       break;
4340     case UJUMP:
4341       ujump_assemble(i, i_regs);
4342       ds = 1;
4343       break;
4344     case RJUMP:
4345       rjump_assemble(i, i_regs);
4346       ds = 1;
4347       break;
4348     case CJUMP:
4349       cjump_assemble(i, i_regs);
4350       ds = 1;
4351       break;
4352     case SJUMP:
4353       sjump_assemble(i, i_regs);
4354       ds = 1;
4355       break;
4356     case NOP:
4357     case OTHER:
4358       // not handled, just skip
4359       break;
4360     default:
4361       assert(0);
4362   }
4363   return ds;
4364 }
4365
4366 static void ds_assemble(int i, const struct regstat *i_regs)
4367 {
4368   speculate_register_values(i);
4369   is_delayslot = 1;
4370   switch (dops[i].itype) {
4371     case SYSCALL:
4372     case HLECALL:
4373     case INTCALL:
4374     case UJUMP:
4375     case RJUMP:
4376     case CJUMP:
4377     case SJUMP:
4378       SysPrintf("Jump in the delay slot.  This is probably a bug.\n");
4379       break;
4380     default:
4381       assemble(i, i_regs, cinfo[i].ccadj);
4382   }
4383   is_delayslot = 0;
4384 }
4385
4386 // Is the branch target a valid internal jump?
4387 static int internal_branch(int addr)
4388 {
4389   if(addr&1) return 0; // Indirect (register) jump
4390   if(addr>=start && addr<start+slen*4-4)
4391   {
4392     return 1;
4393   }
4394   return 0;
4395 }
4396
4397 static void wb_invalidate(signed char pre[],signed char entry[],uint64_t dirty,uint64_t u)
4398 {
4399   int hr;
4400   for(hr=0;hr<HOST_REGS;hr++) {
4401     if(hr!=EXCLUDE_REG) {
4402       if(pre[hr]!=entry[hr]) {
4403         if(pre[hr]>=0) {
4404           if((dirty>>hr)&1) {
4405             if(get_reg(entry,pre[hr])<0) {
4406               assert(pre[hr]<64);
4407               if(!((u>>pre[hr])&1))
4408                 emit_storereg(pre[hr],hr);
4409             }
4410           }
4411         }
4412       }
4413     }
4414   }
4415   // Move from one register to another (no writeback)
4416   for(hr=0;hr<HOST_REGS;hr++) {
4417     if(hr!=EXCLUDE_REG) {
4418       if(pre[hr]!=entry[hr]) {
4419         if(pre[hr]>=0&&pre[hr]<TEMPREG) {
4420           int nr;
4421           if((nr=get_reg(entry,pre[hr]))>=0) {
4422             emit_mov(hr,nr);
4423           }
4424         }
4425       }
4426     }
4427   }
4428 }
4429
4430 // Load the specified registers
4431 // This only loads the registers given as arguments because
4432 // we don't want to load things that will be overwritten
4433 static inline void load_reg(signed char entry[], signed char regmap[], int rs)
4434 {
4435   int hr = get_reg(regmap, rs);
4436   if (hr >= 0 && entry[hr] != regmap[hr])
4437     emit_loadreg(regmap[hr], hr);
4438 }
4439
4440 static void load_regs(signed char entry[], signed char regmap[], int rs1, int rs2)
4441 {
4442   load_reg(entry, regmap, rs1);
4443   if (rs1 != rs2)
4444     load_reg(entry, regmap, rs2);
4445 }
4446
4447 // Load registers prior to the start of a loop
4448 // so that they are not loaded within the loop
4449 static void loop_preload(signed char pre[],signed char entry[])
4450 {
4451   int hr;
4452   for (hr = 0; hr < HOST_REGS; hr++) {
4453     int r = entry[hr];
4454     if (r >= 0 && pre[hr] != r && get_reg(pre, r) < 0) {
4455       assem_debug("loop preload:\n");
4456       if (r < TEMPREG)
4457         emit_loadreg(r, hr);
4458     }
4459   }
4460 }
4461
4462 // Generate address for load/store instruction
4463 // goes to AGEN (or temp) for writes, FTEMP for LOADLR and cop1/2 loads
4464 // AGEN is assigned by pass5b_preallocate2
4465 static void address_generation(int i, const struct regstat *i_regs, signed char entry[])
4466 {
4467   if (dops[i].is_load || dops[i].is_store) {
4468     int ra = -1;
4469     int agr = AGEN1 + (i&1);
4470     if(dops[i].itype==LOAD) {
4471       if (!dops[i].may_except)
4472         ra = get_reg_w(i_regs->regmap, dops[i].rt1); // reuse dest for agen
4473       if (ra < 0)
4474         ra = get_reg_temp(i_regs->regmap);
4475     }
4476     if(dops[i].itype==LOADLR) {
4477       ra=get_reg(i_regs->regmap,FTEMP);
4478     }
4479     if(dops[i].itype==STORE||dops[i].itype==STORELR) {
4480       ra=get_reg(i_regs->regmap,agr);
4481       if(ra<0) ra=get_reg_temp(i_regs->regmap);
4482     }
4483     if(dops[i].itype==C2LS) {
4484       if (dops[i].opcode == 0x32) // LWC2
4485         ra=get_reg(i_regs->regmap,FTEMP);
4486       else { // SWC2
4487         ra=get_reg(i_regs->regmap,agr);
4488         if(ra<0) ra=get_reg_temp(i_regs->regmap);
4489       }
4490     }
4491     int rs = get_reg(i_regs->regmap, dops[i].rs1);
4492     //if(ra>=0)
4493     {
4494       int offset = cinfo[i].imm;
4495       int add_offset = offset != 0;
4496       int c = rs >= 0 && ((i_regs->wasconst >> rs) & 1);
4497       if(dops[i].rs1==0) {
4498         // Using r0 as a base address
4499         assert(ra >= 0);
4500         if(!entry||entry[ra]!=agr) {
4501           if (dops[i].opcode==0x22||dops[i].opcode==0x26) {
4502             emit_movimm(offset&0xFFFFFFFC,ra); // LWL/LWR
4503           }else{
4504             emit_movimm(offset,ra);
4505           }
4506         } // else did it in the previous cycle
4507         cinfo[i].addr = ra;
4508         add_offset = 0;
4509       }
4510       else if (rs < 0) {
4511         assert(ra >= 0);
4512         if (!entry || entry[ra] != dops[i].rs1)
4513           emit_loadreg(dops[i].rs1, ra);
4514         cinfo[i].addr = ra;
4515         //if(!entry||entry[ra]!=dops[i].rs1)
4516         //  printf("poor load scheduling!\n");
4517       }
4518       else if(c) {
4519         if(dops[i].rs1!=dops[i].rt1||dops[i].itype!=LOAD) {
4520           assert(ra >= 0);
4521           if(!entry||entry[ra]!=agr) {
4522             if (dops[i].opcode==0x22||dops[i].opcode==0x26) {
4523               emit_movimm((constmap[i][rs]+offset)&0xFFFFFFFC,ra); // LWL/LWR
4524             }else{
4525               emit_movimm(constmap[i][rs]+offset,ra);
4526               regs[i].loadedconst|=1<<ra;
4527             }
4528           } // else did it in the previous cycle
4529           cinfo[i].addr = ra;
4530         }
4531         else // else load_consts already did it
4532           cinfo[i].addr = rs;
4533         add_offset = 0;
4534       }
4535       else
4536         cinfo[i].addr = rs;
4537       if (add_offset) {
4538         assert(ra >= 0);
4539         if(rs>=0) {
4540           emit_addimm(rs,offset,ra);
4541         }else{
4542           emit_addimm(ra,offset,ra);
4543         }
4544         cinfo[i].addr = ra;
4545       }
4546     }
4547     assert(cinfo[i].addr >= 0);
4548   }
4549   // Preload constants for next instruction
4550   if (dops[i+1].is_load || dops[i+1].is_store) {
4551     int agr,ra;
4552     // Actual address
4553     agr=AGEN1+((i+1)&1);
4554     ra=get_reg(i_regs->regmap,agr);
4555     if(ra>=0) {
4556       int rs=get_reg(regs[i+1].regmap,dops[i+1].rs1);
4557       int offset=cinfo[i+1].imm;
4558       int c=(regs[i+1].wasconst>>rs)&1;
4559       if(c&&(dops[i+1].rs1!=dops[i+1].rt1||dops[i+1].itype!=LOAD)) {
4560         if (dops[i+1].opcode==0x22||dops[i+1].opcode==0x26) {
4561           emit_movimm((constmap[i+1][rs]+offset)&0xFFFFFFFC,ra); // LWL/LWR
4562         }else if (dops[i+1].opcode==0x1a||dops[i+1].opcode==0x1b) {
4563           emit_movimm((constmap[i+1][rs]+offset)&0xFFFFFFF8,ra); // LDL/LDR
4564         }else{
4565           emit_movimm(constmap[i+1][rs]+offset,ra);
4566           regs[i+1].loadedconst|=1<<ra;
4567         }
4568       }
4569       else if(dops[i+1].rs1==0) {
4570         // Using r0 as a base address
4571         if (dops[i+1].opcode==0x22||dops[i+1].opcode==0x26) {
4572           emit_movimm(offset&0xFFFFFFFC,ra); // LWL/LWR
4573         }else if (dops[i+1].opcode==0x1a||dops[i+1].opcode==0x1b) {
4574           emit_movimm(offset&0xFFFFFFF8,ra); // LDL/LDR
4575         }else{
4576           emit_movimm(offset,ra);
4577         }
4578       }
4579     }
4580   }
4581 }
4582
4583 static int get_final_value(int hr, int i, u_int *value)
4584 {
4585   int reg=regs[i].regmap[hr];
4586   while(i<slen-1) {
4587     if(regs[i+1].regmap[hr]!=reg) break;
4588     if(!((regs[i+1].isconst>>hr)&1)) break;
4589     if(dops[i+1].bt) break;
4590     i++;
4591   }
4592   if(i<slen-1) {
4593     if (dops[i].is_jump) {
4594       *value=constmap[i][hr];
4595       return 1;
4596     }
4597     if(!dops[i+1].bt) {
4598       if (dops[i+1].is_jump) {
4599         // Load in delay slot, out-of-order execution
4600         if(dops[i+2].itype==LOAD&&dops[i+2].rs1==reg&&dops[i+2].rt1==reg&&((regs[i+1].wasconst>>hr)&1))
4601         {
4602           // Precompute load address
4603           *value=constmap[i][hr]+cinfo[i+2].imm;
4604           return 1;
4605         }
4606       }
4607       if(dops[i+1].itype==LOAD&&dops[i+1].rs1==reg&&dops[i+1].rt1==reg)
4608       {
4609         // Precompute load address
4610         *value=constmap[i][hr]+cinfo[i+1].imm;
4611         //printf("c=%x imm=%lx\n",(long)constmap[i][hr],cinfo[i+1].imm);
4612         return 1;
4613       }
4614     }
4615   }
4616   *value=constmap[i][hr];
4617   //printf("c=%lx\n",(long)constmap[i][hr]);
4618   if(i==slen-1) return 1;
4619   assert(reg < 64);
4620   return !((unneeded_reg[i+1]>>reg)&1);
4621 }
4622
4623 // Load registers with known constants
4624 static void load_consts(signed char pre[],signed char regmap[],int i)
4625 {
4626   int hr,hr2;
4627   // propagate loaded constant flags
4628   if(i==0||dops[i].bt)
4629     regs[i].loadedconst=0;
4630   else {
4631     for (hr = 0; hr < HOST_REGS; hr++) {
4632       if (hr == EXCLUDE_REG || regmap[hr] < 0 || pre[hr] != regmap[hr])
4633         continue;
4634       if ((((regs[i-1].isconst & regs[i-1].loadedconst) >> hr) & 1)
4635           && regmap[hr] == regs[i-1].regmap[hr])
4636       {
4637         regs[i].loadedconst |= 1u << hr;
4638       }
4639     }
4640   }
4641   // Load 32-bit regs
4642   for(hr=0;hr<HOST_REGS;hr++) {
4643     if(hr!=EXCLUDE_REG&&regmap[hr]>=0) {
4644       //if(entry[hr]!=regmap[hr]) {
4645       if(!((regs[i].loadedconst>>hr)&1)) {
4646         assert(regmap[hr]<64);
4647         if(((regs[i].isconst>>hr)&1)&&regmap[hr]>0) {
4648           u_int value, similar=0;
4649           if(get_final_value(hr,i,&value)) {
4650             // see if some other register has similar value
4651             for(hr2=0;hr2<HOST_REGS;hr2++) {
4652               if(hr2!=EXCLUDE_REG&&((regs[i].loadedconst>>hr2)&1)) {
4653                 if(is_similar_value(value,constmap[i][hr2])) {
4654                   similar=1;
4655                   break;
4656                 }
4657               }
4658             }
4659             if(similar) {
4660               u_int value2;
4661               if(get_final_value(hr2,i,&value2)) // is this needed?
4662                 emit_movimm_from(value2,hr2,value,hr);
4663               else
4664                 emit_movimm(value,hr);
4665             }
4666             else if(value==0) {
4667               emit_zeroreg(hr);
4668             }
4669             else {
4670               emit_movimm(value,hr);
4671             }
4672           }
4673           regs[i].loadedconst|=1<<hr;
4674         }
4675       }
4676     }
4677   }
4678 }
4679
4680 static void load_all_consts(const signed char regmap[], u_int dirty, int i)
4681 {
4682   int hr;
4683   // Load 32-bit regs
4684   for(hr=0;hr<HOST_REGS;hr++) {
4685     if(hr!=EXCLUDE_REG&&regmap[hr]>=0&&((dirty>>hr)&1)) {
4686       assert(regmap[hr] < 64);
4687       if(((regs[i].isconst>>hr)&1)&&regmap[hr]>0) {
4688         int value=constmap[i][hr];
4689         if(value==0) {
4690           emit_zeroreg(hr);
4691         }
4692         else {
4693           emit_movimm(value,hr);
4694         }
4695       }
4696     }
4697   }
4698 }
4699
4700 // Write out all dirty registers (except cycle count)
4701 #ifndef wb_dirtys
4702 static void wb_dirtys(const signed char i_regmap[], u_int i_dirty)
4703 {
4704   int hr;
4705   for(hr=0;hr<HOST_REGS;hr++) {
4706     if(hr!=EXCLUDE_REG) {
4707       if(i_regmap[hr]>0) {
4708         if(i_regmap[hr]!=CCREG) {
4709           if((i_dirty>>hr)&1) {
4710             assert(i_regmap[hr]<64);
4711             emit_storereg(i_regmap[hr],hr);
4712           }
4713         }
4714       }
4715     }
4716   }
4717 }
4718 #endif
4719
4720 // Write out dirty registers that we need to reload (pair with load_needed_regs)
4721 // This writes the registers not written by store_regs_bt
4722 static void wb_needed_dirtys(const signed char i_regmap[], u_int i_dirty, int addr)
4723 {
4724   int hr;
4725   int t=(addr-start)>>2;
4726   for(hr=0;hr<HOST_REGS;hr++) {
4727     if(hr!=EXCLUDE_REG) {
4728       if(i_regmap[hr]>0) {
4729         if(i_regmap[hr]!=CCREG) {
4730           if(i_regmap[hr]==regs[t].regmap_entry[hr] && ((regs[t].dirty>>hr)&1)) {
4731             if((i_dirty>>hr)&1) {
4732               assert(i_regmap[hr]<64);
4733               emit_storereg(i_regmap[hr],hr);
4734             }
4735           }
4736         }
4737       }
4738     }
4739   }
4740 }
4741
4742 // Load all registers (except cycle count)
4743 #ifndef load_all_regs
4744 static void load_all_regs(const signed char i_regmap[])
4745 {
4746   int hr;
4747   for(hr=0;hr<HOST_REGS;hr++) {
4748     if(hr!=EXCLUDE_REG) {
4749       if(i_regmap[hr]==0) {
4750         emit_zeroreg(hr);
4751       }
4752       else
4753       if(i_regmap[hr]>0 && i_regmap[hr]<TEMPREG && i_regmap[hr]!=CCREG)
4754       {
4755         emit_loadreg(i_regmap[hr],hr);
4756       }
4757     }
4758   }
4759 }
4760 #endif
4761
4762 // Load all current registers also needed by next instruction
4763 static void load_needed_regs(const signed char i_regmap[], const signed char next_regmap[])
4764 {
4765   signed char regmap_sel[HOST_REGS];
4766   int hr;
4767   for (hr = 0; hr < HOST_REGS; hr++) {
4768     regmap_sel[hr] = -1;
4769     if (hr != EXCLUDE_REG)
4770       if (next_regmap[hr] == i_regmap[hr] || get_reg(next_regmap, i_regmap[hr]) >= 0)
4771         regmap_sel[hr] = i_regmap[hr];
4772   }
4773   load_all_regs(regmap_sel);
4774 }
4775
4776 // Load all regs, storing cycle count if necessary
4777 static void load_regs_entry(int t)
4778 {
4779   if(dops[t].is_ds) emit_addimm(HOST_CCREG,CLOCK_ADJUST(1),HOST_CCREG);
4780   else if(cinfo[t].ccadj) emit_addimm(HOST_CCREG,-cinfo[t].ccadj,HOST_CCREG);
4781   if(regs[t].regmap_entry[HOST_CCREG]!=CCREG) {
4782     emit_storereg(CCREG,HOST_CCREG);
4783   }
4784   load_all_regs(regs[t].regmap_entry);
4785 }
4786
4787 // Store dirty registers prior to branch
4788 static void store_regs_bt(signed char i_regmap[],uint64_t i_dirty,int addr)
4789 {
4790   if(internal_branch(addr))
4791   {
4792     int t=(addr-start)>>2;
4793     int hr;
4794     for(hr=0;hr<HOST_REGS;hr++) {
4795       if(hr!=EXCLUDE_REG) {
4796         if(i_regmap[hr]>0 && i_regmap[hr]!=CCREG) {
4797           if(i_regmap[hr]!=regs[t].regmap_entry[hr] || !((regs[t].dirty>>hr)&1)) {
4798             if((i_dirty>>hr)&1) {
4799               assert(i_regmap[hr]<64);
4800               if(!((unneeded_reg[t]>>i_regmap[hr])&1))
4801                 emit_storereg(i_regmap[hr],hr);
4802             }
4803           }
4804         }
4805       }
4806     }
4807   }
4808   else
4809   {
4810     // Branch out of this block, write out all dirty regs
4811     wb_dirtys(i_regmap,i_dirty);
4812   }
4813 }
4814
4815 // Load all needed registers for branch target
4816 static void load_regs_bt(signed char i_regmap[],uint64_t i_dirty,int addr)
4817 {
4818   //if(addr>=start && addr<(start+slen*4))
4819   if(internal_branch(addr))
4820   {
4821     int t=(addr-start)>>2;
4822     int hr;
4823     // Store the cycle count before loading something else
4824     if(i_regmap[HOST_CCREG]!=CCREG) {
4825       assert(i_regmap[HOST_CCREG]==-1);
4826     }
4827     if(regs[t].regmap_entry[HOST_CCREG]!=CCREG) {
4828       emit_storereg(CCREG,HOST_CCREG);
4829     }
4830     // Load 32-bit regs
4831     for(hr=0;hr<HOST_REGS;hr++) {
4832       if(hr!=EXCLUDE_REG&&regs[t].regmap_entry[hr]>=0&&regs[t].regmap_entry[hr]<TEMPREG) {
4833         if(i_regmap[hr]!=regs[t].regmap_entry[hr]) {
4834           if(regs[t].regmap_entry[hr]==0) {
4835             emit_zeroreg(hr);
4836           }
4837           else if(regs[t].regmap_entry[hr]!=CCREG)
4838           {
4839             emit_loadreg(regs[t].regmap_entry[hr],hr);
4840           }
4841         }
4842       }
4843     }
4844   }
4845 }
4846
4847 static int match_bt(signed char i_regmap[],uint64_t i_dirty,int addr)
4848 {
4849   if(addr>=start && addr<start+slen*4-4)
4850   {
4851     int t=(addr-start)>>2;
4852     int hr;
4853     if(regs[t].regmap_entry[HOST_CCREG]!=CCREG) return 0;
4854     for(hr=0;hr<HOST_REGS;hr++)
4855     {
4856       if(hr!=EXCLUDE_REG)
4857       {
4858         if(i_regmap[hr]!=regs[t].regmap_entry[hr])
4859         {
4860           if(regs[t].regmap_entry[hr]>=0&&(regs[t].regmap_entry[hr]|64)<TEMPREG+64)
4861           {
4862             return 0;
4863           }
4864           else
4865           if((i_dirty>>hr)&1)
4866           {
4867             if(i_regmap[hr]<TEMPREG)
4868             {
4869               if(!((unneeded_reg[t]>>i_regmap[hr])&1))
4870                 return 0;
4871             }
4872             else if(i_regmap[hr]>=64&&i_regmap[hr]<TEMPREG+64)
4873             {
4874               assert(0);
4875             }
4876           }
4877         }
4878         else // Same register but is it 32-bit or dirty?
4879         if(i_regmap[hr]>=0)
4880         {
4881           if(!((regs[t].dirty>>hr)&1))
4882           {
4883             if((i_dirty>>hr)&1)
4884             {
4885               if(!((unneeded_reg[t]>>i_regmap[hr])&1))
4886               {
4887                 //printf("%x: dirty no match\n",addr);
4888                 return 0;
4889               }
4890             }
4891           }
4892         }
4893       }
4894     }
4895     // Delay slots are not valid branch targets
4896     //if(t>0&&(dops[t-1].is_jump) return 0;
4897     // Delay slots require additional processing, so do not match
4898     if(dops[t].is_ds) return 0;
4899   }
4900   else
4901   {
4902     int hr;
4903     for(hr=0;hr<HOST_REGS;hr++)
4904     {
4905       if(hr!=EXCLUDE_REG)
4906       {
4907         if(i_regmap[hr]>=0)
4908         {
4909           if(hr!=HOST_CCREG||i_regmap[hr]!=CCREG)
4910           {
4911             if((i_dirty>>hr)&1)
4912             {
4913               return 0;
4914             }
4915           }
4916         }
4917       }
4918     }
4919   }
4920   return 1;
4921 }
4922
4923 #ifdef DRC_DBG
4924 static void drc_dbg_emit_do_cmp(int i, int ccadj_)
4925 {
4926   extern void do_insn_cmp();
4927   //extern int cycle;
4928   u_int hr, reglist = get_host_reglist(regs[i].regmap);
4929   reglist |= get_host_reglist(regs[i].regmap_entry);
4930   reglist &= DRC_DBG_REGMASK;
4931
4932   assem_debug("//do_insn_cmp %08x\n", start+i*4);
4933   save_regs(reglist);
4934   // write out changed consts to match the interpreter
4935   if (i > 0 && !dops[i].bt) {
4936     for (hr = 0; hr < HOST_REGS; hr++) {
4937       int reg = regs[i].regmap_entry[hr]; // regs[i-1].regmap[hr];
4938       if (hr == EXCLUDE_REG || reg <= 0)
4939         continue;
4940       if (!((regs[i-1].isconst >> hr) & 1))
4941         continue;
4942       if (i > 1 && reg == regs[i-2].regmap[hr] && constmap[i-1][hr] == constmap[i-2][hr])
4943         continue;
4944       emit_movimm(constmap[i-1][hr],0);
4945       emit_storereg(reg, 0);
4946     }
4947   }
4948   if (dops[i].opcode == 0x0f) { // LUI
4949     emit_movimm(cinfo[i].imm << 16, 0);
4950     emit_storereg(dops[i].rt1, 0);
4951   }
4952   emit_movimm(start+i*4,0);
4953   emit_writeword(0,&pcaddr);
4954   int cc = get_reg(regs[i].regmap_entry, CCREG);
4955   if (cc < 0)
4956     emit_loadreg(CCREG, cc = 0);
4957   emit_addimm(cc, ccadj_, 0);
4958   emit_writeword(0, &psxRegs.cycle);
4959   emit_far_call(do_insn_cmp);
4960   //emit_readword(&cycle,0);
4961   //emit_addimm(0,2,0);
4962   //emit_writeword(0,&cycle);
4963   (void)get_reg2;
4964   restore_regs(reglist);
4965   assem_debug("\\\\do_insn_cmp\n");
4966 }
4967 static void drc_dbg_emit_wb_dirtys(int i, const struct regstat *i_regs)
4968 {
4969   // write-out non-consts, consts are likely different because of get_final_value()
4970   if (i_regs->dirty & ~i_regs->loadedconst) {
4971     assem_debug("/ drc_dbg_wb\n");
4972     wb_dirtys(i_regs->regmap, i_regs->dirty & ~i_regs->loadedconst);
4973     assem_debug("\\ drc_dbg_wb\n");
4974   }
4975 }
4976 #else
4977 #define drc_dbg_emit_do_cmp(x,y)
4978 #define drc_dbg_emit_wb_dirtys(x,y)
4979 #endif
4980
4981 // Used when a branch jumps into the delay slot of another branch
4982 static void ds_assemble_entry(int i)
4983 {
4984   int t = (cinfo[i].ba - start) >> 2;
4985   int ccadj_ = -CLOCK_ADJUST(1);
4986   if (!instr_addr[t])
4987     instr_addr[t] = out;
4988   assem_debug("Assemble delay slot at %x\n",cinfo[i].ba);
4989   assem_debug("<->\n");
4990   drc_dbg_emit_do_cmp(t, ccadj_);
4991   if(regs[t].regmap_entry[HOST_CCREG]==CCREG&&regs[t].regmap[HOST_CCREG]!=CCREG)
4992     wb_register(CCREG,regs[t].regmap_entry,regs[t].wasdirty);
4993   load_regs(regs[t].regmap_entry,regs[t].regmap,dops[t].rs1,dops[t].rs2);
4994   address_generation(t,&regs[t],regs[t].regmap_entry);
4995   if (ram_offset && (dops[t].is_load || dops[t].is_store))
4996     load_reg(regs[t].regmap_entry,regs[t].regmap,ROREG);
4997   if (dops[t].is_store)
4998     load_reg(regs[t].regmap_entry,regs[t].regmap,INVCP);
4999   is_delayslot=0;
5000   switch (dops[t].itype) {
5001     case SYSCALL:
5002     case HLECALL:
5003     case INTCALL:
5004     case UJUMP:
5005     case RJUMP:
5006     case CJUMP:
5007     case SJUMP:
5008       SysPrintf("Jump in the delay slot.  This is probably a bug.\n");
5009       break;
5010     default:
5011       assemble(t, &regs[t], ccadj_);
5012   }
5013   store_regs_bt(regs[t].regmap,regs[t].dirty,cinfo[i].ba+4);
5014   load_regs_bt(regs[t].regmap,regs[t].dirty,cinfo[i].ba+4);
5015   if(internal_branch(cinfo[i].ba+4))
5016     assem_debug("branch: internal\n");
5017   else
5018     assem_debug("branch: external\n");
5019   assert(internal_branch(cinfo[i].ba+4));
5020   add_to_linker(out,cinfo[i].ba+4,internal_branch(cinfo[i].ba+4));
5021   emit_jmp(0);
5022 }
5023
5024 // Load 2 immediates optimizing for small code size
5025 static void emit_mov2imm_compact(int imm1,u_int rt1,int imm2,u_int rt2)
5026 {
5027   emit_movimm(imm1,rt1);
5028   emit_movimm_from(imm1,rt1,imm2,rt2);
5029 }
5030
5031 static void do_cc(int i, const signed char i_regmap[], int *adj,
5032   int addr, int taken, int invert)
5033 {
5034   int count, count_plus2;
5035   void *jaddr;
5036   void *idle=NULL;
5037   int t=0;
5038   if(dops[i].itype==RJUMP)
5039   {
5040     *adj=0;
5041   }
5042   //if(cinfo[i].ba>=start && cinfo[i].ba<(start+slen*4))
5043   if(internal_branch(cinfo[i].ba))
5044   {
5045     t=(cinfo[i].ba-start)>>2;
5046     if(dops[t].is_ds) *adj=-CLOCK_ADJUST(1); // Branch into delay slot adds an extra cycle
5047     else *adj=cinfo[t].ccadj;
5048   }
5049   else
5050   {
5051     *adj=0;
5052   }
5053   count = cinfo[i].ccadj;
5054   count_plus2 = count + CLOCK_ADJUST(2);
5055   if(taken==TAKEN && i==(cinfo[i].ba-start)>>2 && source[i+1]==0) {
5056     // Idle loop
5057     if(count&1) emit_addimm_and_set_flags(2*(count+2),HOST_CCREG);
5058     idle=out;
5059     //emit_subfrommem(&idlecount,HOST_CCREG); // Count idle cycles
5060     emit_andimm(HOST_CCREG,3,HOST_CCREG);
5061     jaddr=out;
5062     emit_jmp(0);
5063   }
5064   else if(*adj==0||invert) {
5065     int cycles = count_plus2;
5066     // faster loop HACK
5067 #if 0
5068     if (t&&*adj) {
5069       int rel=t-i;
5070       if(-NO_CYCLE_PENALTY_THR<rel&&rel<0)
5071         cycles=*adj+count+2-*adj;
5072     }
5073 #endif
5074     emit_addimm_and_set_flags(cycles, HOST_CCREG);
5075     jaddr = out;
5076     emit_jns(0);
5077   }
5078   else
5079   {
5080     emit_cmpimm(HOST_CCREG, -count_plus2);
5081     jaddr = out;
5082     emit_jns(0);
5083   }
5084   add_stub(CC_STUB,jaddr,idle?idle:out,(*adj==0||invert||idle)?0:count_plus2,i,addr,taken,0);
5085 }
5086
5087 static void do_ccstub(int n)
5088 {
5089   literal_pool(256);
5090   assem_debug("do_ccstub %x\n",start+(u_int)stubs[n].b*4);
5091   set_jump_target(stubs[n].addr, out);
5092   int i=stubs[n].b;
5093   if (stubs[n].d != TAKEN) {
5094     wb_dirtys(branch_regs[i].regmap,branch_regs[i].dirty);
5095   }
5096   else {
5097     if(internal_branch(cinfo[i].ba))
5098       wb_needed_dirtys(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5099   }
5100   if(stubs[n].c!=-1)
5101   {
5102     // Save PC as return address
5103     emit_movimm(stubs[n].c,0);
5104     emit_writeword(0,&pcaddr);
5105   }
5106   else
5107   {
5108     // Return address depends on which way the branch goes
5109     if(dops[i].itype==CJUMP||dops[i].itype==SJUMP)
5110     {
5111       int s1l=get_reg(branch_regs[i].regmap,dops[i].rs1);
5112       int s2l=get_reg(branch_regs[i].regmap,dops[i].rs2);
5113       if(dops[i].rs1==0)
5114       {
5115         s1l=s2l;
5116         s2l=-1;
5117       }
5118       else if(dops[i].rs2==0)
5119       {
5120         s2l=-1;
5121       }
5122       assert(s1l>=0);
5123       #ifdef DESTRUCTIVE_WRITEBACK
5124       if(dops[i].rs1) {
5125         if((branch_regs[i].dirty>>s1l)&&1)
5126           emit_loadreg(dops[i].rs1,s1l);
5127       }
5128       else {
5129         if((branch_regs[i].dirty>>s1l)&1)
5130           emit_loadreg(dops[i].rs2,s1l);
5131       }
5132       if(s2l>=0)
5133         if((branch_regs[i].dirty>>s2l)&1)
5134           emit_loadreg(dops[i].rs2,s2l);
5135       #endif
5136       int hr=0;
5137       int addr=-1,alt=-1,ntaddr=-1;
5138       while(hr<HOST_REGS)
5139       {
5140         if(hr!=EXCLUDE_REG && hr!=HOST_CCREG &&
5141            branch_regs[i].regmap[hr]!=dops[i].rs1 &&
5142            branch_regs[i].regmap[hr]!=dops[i].rs2 )
5143         {
5144           addr=hr++;break;
5145         }
5146         hr++;
5147       }
5148       while(hr<HOST_REGS)
5149       {
5150         if(hr!=EXCLUDE_REG && hr!=HOST_CCREG &&
5151            branch_regs[i].regmap[hr]!=dops[i].rs1 &&
5152            branch_regs[i].regmap[hr]!=dops[i].rs2 )
5153         {
5154           alt=hr++;break;
5155         }
5156         hr++;
5157       }
5158       if ((dops[i].opcode & 0x3e) == 6) // BLEZ/BGTZ needs another register
5159       {
5160         while(hr<HOST_REGS)
5161         {
5162           if(hr!=EXCLUDE_REG && hr!=HOST_CCREG &&
5163              branch_regs[i].regmap[hr]!=dops[i].rs1 &&
5164              branch_regs[i].regmap[hr]!=dops[i].rs2 )
5165           {
5166             ntaddr=hr;break;
5167           }
5168           hr++;
5169         }
5170         assert(hr<HOST_REGS);
5171       }
5172       if (dops[i].opcode == 4) // BEQ
5173       {
5174         #ifdef HAVE_CMOV_IMM
5175         if(s2l>=0) emit_cmp(s1l,s2l);
5176         else emit_test(s1l,s1l);
5177         emit_cmov2imm_e_ne_compact(cinfo[i].ba,start+i*4+8,addr);
5178         #else
5179         emit_mov2imm_compact(cinfo[i].ba,addr,start+i*4+8,alt);
5180         if(s2l>=0) emit_cmp(s1l,s2l);
5181         else emit_test(s1l,s1l);
5182         emit_cmovne_reg(alt,addr);
5183         #endif
5184       }
5185       else if (dops[i].opcode == 5) // BNE
5186       {
5187         #ifdef HAVE_CMOV_IMM
5188         if(s2l>=0) emit_cmp(s1l,s2l);
5189         else emit_test(s1l,s1l);
5190         emit_cmov2imm_e_ne_compact(start+i*4+8,cinfo[i].ba,addr);
5191         #else
5192         emit_mov2imm_compact(start+i*4+8,addr,cinfo[i].ba,alt);
5193         if(s2l>=0) emit_cmp(s1l,s2l);
5194         else emit_test(s1l,s1l);
5195         emit_cmovne_reg(alt,addr);
5196         #endif
5197       }
5198       else if (dops[i].opcode == 6) // BLEZ
5199       {
5200         //emit_movimm(cinfo[i].ba,alt);
5201         //emit_movimm(start+i*4+8,addr);
5202         emit_mov2imm_compact(cinfo[i].ba,alt,start+i*4+8,addr);
5203         emit_cmpimm(s1l,1);
5204         emit_cmovl_reg(alt,addr);
5205       }
5206       else if (dops[i].opcode == 7) // BGTZ
5207       {
5208         //emit_movimm(cinfo[i].ba,addr);
5209         //emit_movimm(start+i*4+8,ntaddr);
5210         emit_mov2imm_compact(cinfo[i].ba,addr,start+i*4+8,ntaddr);
5211         emit_cmpimm(s1l,1);
5212         emit_cmovl_reg(ntaddr,addr);
5213       }
5214       else if (dops[i].itype == SJUMP) // BLTZ/BGEZ
5215       {
5216         //emit_movimm(cinfo[i].ba,alt);
5217         //emit_movimm(start+i*4+8,addr);
5218         if (dops[i].rs1) {
5219           emit_mov2imm_compact(cinfo[i].ba,
5220             (dops[i].opcode2 & 1) ? addr : alt, start + i*4 + 8,
5221             (dops[i].opcode2 & 1) ? alt : addr);
5222           emit_test(s1l,s1l);
5223           emit_cmovs_reg(alt,addr);
5224         }
5225         else
5226           emit_movimm((dops[i].opcode2 & 1) ? cinfo[i].ba : start + i*4 + 8, addr);
5227       }
5228       emit_writeword(addr, &pcaddr);
5229     }
5230     else
5231     if(dops[i].itype==RJUMP)
5232     {
5233       int r=get_reg(branch_regs[i].regmap,dops[i].rs1);
5234       if (ds_writes_rjump_rs(i)) {
5235         r=get_reg(branch_regs[i].regmap,RTEMP);
5236       }
5237       emit_writeword(r,&pcaddr);
5238     }
5239     else {SysPrintf("Unknown branch type in do_ccstub\n");abort();}
5240   }
5241   // Update cycle count
5242   assert(branch_regs[i].regmap[HOST_CCREG]==CCREG||branch_regs[i].regmap[HOST_CCREG]==-1);
5243   if(stubs[n].a) emit_addimm(HOST_CCREG,(int)stubs[n].a,HOST_CCREG);
5244   emit_far_call(cc_interrupt);
5245   if(stubs[n].a) emit_addimm(HOST_CCREG,-(int)stubs[n].a,HOST_CCREG);
5246   if(stubs[n].d==TAKEN) {
5247     if(internal_branch(cinfo[i].ba))
5248       load_needed_regs(branch_regs[i].regmap,regs[(cinfo[i].ba-start)>>2].regmap_entry);
5249     else if(dops[i].itype==RJUMP) {
5250       if(get_reg(branch_regs[i].regmap,RTEMP)>=0)
5251         emit_readword(&pcaddr,get_reg(branch_regs[i].regmap,RTEMP));
5252       else
5253         emit_loadreg(dops[i].rs1,get_reg(branch_regs[i].regmap,dops[i].rs1));
5254     }
5255   }else if(stubs[n].d==NOTTAKEN) {
5256     if(i<slen-2) load_needed_regs(branch_regs[i].regmap,regmap_pre[i+2]);
5257     else load_all_regs(branch_regs[i].regmap);
5258   }else{
5259     load_all_regs(branch_regs[i].regmap);
5260   }
5261   if (stubs[n].retaddr)
5262     emit_jmp(stubs[n].retaddr);
5263   else
5264     do_jump_vaddr(stubs[n].e);
5265 }
5266
5267 static void add_to_linker(void *addr, u_int target, int is_internal)
5268 {
5269   assert(linkcount < ARRAY_SIZE(link_addr));
5270   link_addr[linkcount].addr = addr;
5271   link_addr[linkcount].target = target;
5272   link_addr[linkcount].internal = is_internal;
5273   linkcount++;
5274 }
5275
5276 static void ujump_assemble_write_ra(int i)
5277 {
5278   int rt;
5279   unsigned int return_address;
5280   rt=get_reg(branch_regs[i].regmap,31);
5281   //assem_debug("branch(%d): eax=%d ecx=%d edx=%d ebx=%d ebp=%d esi=%d edi=%d\n",i,branch_regs[i].regmap[0],branch_regs[i].regmap[1],branch_regs[i].regmap[2],branch_regs[i].regmap[3],branch_regs[i].regmap[5],branch_regs[i].regmap[6],branch_regs[i].regmap[7]);
5282   //assert(rt>=0);
5283   return_address=start+i*4+8;
5284   if(rt>=0) {
5285     #ifdef USE_MINI_HT
5286     if(internal_branch(return_address)&&dops[i+1].rt1!=31) {
5287       int temp=-1; // note: must be ds-safe
5288       #ifdef HOST_TEMPREG
5289       temp=HOST_TEMPREG;
5290       #endif
5291       if(temp>=0) do_miniht_insert(return_address,rt,temp);
5292       else emit_movimm(return_address,rt);
5293     }
5294     else
5295     #endif
5296     {
5297       #ifdef REG_PREFETCH
5298       if(temp>=0)
5299       {
5300         if(i_regmap[temp]!=PTEMP) emit_movimm((uintptr_t)hash_table_get(return_address),temp);
5301       }
5302       #endif
5303       if (!((regs[i].loadedconst >> rt) & 1))
5304         emit_movimm(return_address, rt); // PC into link register
5305       #ifdef IMM_PREFETCH
5306       emit_prefetch(hash_table_get(return_address));
5307       #endif
5308     }
5309   }
5310 }
5311
5312 static void ujump_assemble(int i, const struct regstat *i_regs)
5313 {
5314   if(i==(cinfo[i].ba-start)>>2) assem_debug("idle loop\n");
5315   address_generation(i+1,i_regs,regs[i].regmap_entry);
5316   #ifdef REG_PREFETCH
5317   int temp=get_reg(branch_regs[i].regmap,PTEMP);
5318   if(dops[i].rt1==31&&temp>=0)
5319   {
5320     signed char *i_regmap=i_regs->regmap;
5321     int return_address=start+i*4+8;
5322     if(get_reg(branch_regs[i].regmap,31)>0)
5323     if(i_regmap[temp]==PTEMP) emit_movimm((uintptr_t)hash_table_get(return_address),temp);
5324   }
5325   #endif
5326   if (dops[i].rt1 == 31)
5327     ujump_assemble_write_ra(i); // writeback ra for DS
5328   ds_assemble(i+1,i_regs);
5329   uint64_t bc_unneeded=branch_regs[i].u;
5330   bc_unneeded|=1|(1LL<<dops[i].rt1);
5331   wb_invalidate(regs[i].regmap,branch_regs[i].regmap,regs[i].dirty,bc_unneeded);
5332   load_reg(regs[i].regmap,branch_regs[i].regmap,CCREG);
5333   int cc,adj;
5334   cc=get_reg(branch_regs[i].regmap,CCREG);
5335   assert(cc==HOST_CCREG);
5336   store_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5337   #ifdef REG_PREFETCH
5338   if(dops[i].rt1==31&&temp>=0) emit_prefetchreg(temp);
5339   #endif
5340   do_cc(i,branch_regs[i].regmap,&adj,cinfo[i].ba,TAKEN,0);
5341   if(adj) emit_addimm(cc, cinfo[i].ccadj + CLOCK_ADJUST(2) - adj, cc);
5342   load_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5343   if(internal_branch(cinfo[i].ba))
5344     assem_debug("branch: internal\n");
5345   else
5346     assem_debug("branch: external\n");
5347   if (internal_branch(cinfo[i].ba) && dops[(cinfo[i].ba-start)>>2].is_ds) {
5348     ds_assemble_entry(i);
5349   }
5350   else {
5351     add_to_linker(out,cinfo[i].ba,internal_branch(cinfo[i].ba));
5352     emit_jmp(0);
5353   }
5354 }
5355
5356 static void rjump_assemble_write_ra(int i)
5357 {
5358   int rt,return_address;
5359   rt=get_reg_w(branch_regs[i].regmap, dops[i].rt1);
5360   //assem_debug("branch(%d): eax=%d ecx=%d edx=%d ebx=%d ebp=%d esi=%d edi=%d\n",i,branch_regs[i].regmap[0],branch_regs[i].regmap[1],branch_regs[i].regmap[2],branch_regs[i].regmap[3],branch_regs[i].regmap[5],branch_regs[i].regmap[6],branch_regs[i].regmap[7]);
5361   assert(rt>=0);
5362   return_address=start+i*4+8;
5363   #ifdef REG_PREFETCH
5364   if(temp>=0)
5365   {
5366     if(i_regmap[temp]!=PTEMP) emit_movimm((uintptr_t)hash_table_get(return_address),temp);
5367   }
5368   #endif
5369   if (!((regs[i].loadedconst >> rt) & 1))
5370     emit_movimm(return_address, rt); // PC into link register
5371   #ifdef IMM_PREFETCH
5372   emit_prefetch(hash_table_get(return_address));
5373   #endif
5374 }
5375
5376 static void rjump_assemble(int i, const struct regstat *i_regs)
5377 {
5378   int temp;
5379   int rs,cc;
5380   rs=get_reg(branch_regs[i].regmap,dops[i].rs1);
5381   assert(rs>=0);
5382   if (ds_writes_rjump_rs(i)) {
5383     // Delay slot abuse, make a copy of the branch address register
5384     temp=get_reg(branch_regs[i].regmap,RTEMP);
5385     assert(temp>=0);
5386     assert(regs[i].regmap[temp]==RTEMP);
5387     emit_mov(rs,temp);
5388     rs=temp;
5389   }
5390   address_generation(i+1,i_regs,regs[i].regmap_entry);
5391   #ifdef REG_PREFETCH
5392   if(dops[i].rt1==31)
5393   {
5394     if((temp=get_reg(branch_regs[i].regmap,PTEMP))>=0) {
5395       signed char *i_regmap=i_regs->regmap;
5396       int return_address=start+i*4+8;
5397       if(i_regmap[temp]==PTEMP) emit_movimm((uintptr_t)hash_table_get(return_address),temp);
5398     }
5399   }
5400   #endif
5401   #ifdef USE_MINI_HT
5402   if(dops[i].rs1==31) {
5403     int rh=get_reg(regs[i].regmap,RHASH);
5404     if(rh>=0) do_preload_rhash(rh);
5405   }
5406   #endif
5407   if (dops[i].rt1 != 0)
5408     rjump_assemble_write_ra(i);
5409   ds_assemble(i+1,i_regs);
5410   uint64_t bc_unneeded=branch_regs[i].u;
5411   bc_unneeded|=1|(1LL<<dops[i].rt1);
5412   bc_unneeded&=~(1LL<<dops[i].rs1);
5413   wb_invalidate(regs[i].regmap,branch_regs[i].regmap,regs[i].dirty,bc_unneeded);
5414   load_regs(regs[i].regmap,branch_regs[i].regmap,dops[i].rs1,CCREG);
5415   cc=get_reg(branch_regs[i].regmap,CCREG);
5416   assert(cc==HOST_CCREG);
5417   (void)cc;
5418   #ifdef USE_MINI_HT
5419   int rh=get_reg(branch_regs[i].regmap,RHASH);
5420   int ht=get_reg(branch_regs[i].regmap,RHTBL);
5421   if(dops[i].rs1==31) {
5422     if(regs[i].regmap[rh]!=RHASH) do_preload_rhash(rh);
5423     do_preload_rhtbl(ht);
5424     do_rhash(rs,rh);
5425   }
5426   #endif
5427   store_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,-1);
5428   #ifdef DESTRUCTIVE_WRITEBACK
5429   if((branch_regs[i].dirty>>rs)&1) {
5430     if(dops[i].rs1!=dops[i+1].rt1&&dops[i].rs1!=dops[i+1].rt2) {
5431       emit_loadreg(dops[i].rs1,rs);
5432     }
5433   }
5434   #endif
5435   #ifdef REG_PREFETCH
5436   if(dops[i].rt1==31&&temp>=0) emit_prefetchreg(temp);
5437   #endif
5438   #ifdef USE_MINI_HT
5439   if(dops[i].rs1==31) {
5440     do_miniht_load(ht,rh);
5441   }
5442   #endif
5443   //do_cc(i,branch_regs[i].regmap,&adj,-1,TAKEN);
5444   //if(adj) emit_addimm(cc,2*(cinfo[i].ccadj+2-adj),cc); // ??? - Shouldn't happen
5445   //assert(adj==0);
5446   emit_addimm_and_set_flags(cinfo[i].ccadj + CLOCK_ADJUST(2), HOST_CCREG);
5447   add_stub(CC_STUB,out,NULL,0,i,-1,TAKEN,rs);
5448   if (dops[i+1].itype == RFE)
5449     // special case for RFE
5450     emit_jmp(0);
5451   else
5452     emit_jns(0);
5453   //load_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,-1);
5454   #ifdef USE_MINI_HT
5455   if(dops[i].rs1==31) {
5456     do_miniht_jump(rs,rh,ht);
5457   }
5458   else
5459   #endif
5460   {
5461     do_jump_vaddr(rs);
5462   }
5463   #ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
5464   if(dops[i].rt1!=31&&i<slen-2&&(((u_int)out)&7)) emit_mov(13,13);
5465   #endif
5466 }
5467
5468 static void cjump_assemble(int i, const struct regstat *i_regs)
5469 {
5470   const signed char *i_regmap = i_regs->regmap;
5471   int cc;
5472   int match;
5473   match=match_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5474   assem_debug("match=%d\n",match);
5475   int s1l,s2l;
5476   int unconditional=0,nop=0;
5477   int invert=0;
5478   int internal=internal_branch(cinfo[i].ba);
5479   if(i==(cinfo[i].ba-start)>>2) assem_debug("idle loop\n");
5480   if(!match) invert=1;
5481   #ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
5482   if(i>(cinfo[i].ba-start)>>2) invert=1;
5483   #endif
5484   #ifdef __aarch64__
5485   invert=1; // because of near cond. branches
5486   #endif
5487
5488   if(dops[i].ooo) {
5489     s1l=get_reg(branch_regs[i].regmap,dops[i].rs1);
5490     s2l=get_reg(branch_regs[i].regmap,dops[i].rs2);
5491   }
5492   else {
5493     s1l=get_reg(i_regmap,dops[i].rs1);
5494     s2l=get_reg(i_regmap,dops[i].rs2);
5495   }
5496   if(dops[i].rs1==0&&dops[i].rs2==0)
5497   {
5498     if(dops[i].opcode&1) nop=1;
5499     else unconditional=1;
5500     //assert(dops[i].opcode!=5);
5501     //assert(dops[i].opcode!=7);
5502     //assert(dops[i].opcode!=0x15);
5503     //assert(dops[i].opcode!=0x17);
5504   }
5505   else if(dops[i].rs1==0)
5506   {
5507     s1l=s2l;
5508     s2l=-1;
5509   }
5510   else if(dops[i].rs2==0)
5511   {
5512     s2l=-1;
5513   }
5514
5515   if(dops[i].ooo) {
5516     // Out of order execution (delay slot first)
5517     //printf("OOOE\n");
5518     address_generation(i+1,i_regs,regs[i].regmap_entry);
5519     ds_assemble(i+1,i_regs);
5520     int adj;
5521     uint64_t bc_unneeded=branch_regs[i].u;
5522     bc_unneeded&=~((1LL<<dops[i].rs1)|(1LL<<dops[i].rs2));
5523     bc_unneeded|=1;
5524     wb_invalidate(regs[i].regmap,branch_regs[i].regmap,regs[i].dirty,bc_unneeded);
5525     load_regs(regs[i].regmap,branch_regs[i].regmap,dops[i].rs1,dops[i].rs2);
5526     load_reg(regs[i].regmap,branch_regs[i].regmap,CCREG);
5527     cc=get_reg(branch_regs[i].regmap,CCREG);
5528     assert(cc==HOST_CCREG);
5529     if(unconditional)
5530       store_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5531     //do_cc(i,branch_regs[i].regmap,&adj,unconditional?cinfo[i].ba:-1,unconditional);
5532     //assem_debug("cycle count (adj)\n");
5533     if(unconditional) {
5534       do_cc(i,branch_regs[i].regmap,&adj,cinfo[i].ba,TAKEN,0);
5535       if(i!=(cinfo[i].ba-start)>>2 || source[i+1]!=0) {
5536         if(adj) emit_addimm(cc, cinfo[i].ccadj + CLOCK_ADJUST(2) - adj, cc);
5537         load_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5538         if(internal)
5539           assem_debug("branch: internal\n");
5540         else
5541           assem_debug("branch: external\n");
5542         if (internal && dops[(cinfo[i].ba-start)>>2].is_ds) {
5543           ds_assemble_entry(i);
5544         }
5545         else {
5546           add_to_linker(out,cinfo[i].ba,internal);
5547           emit_jmp(0);
5548         }
5549         #ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
5550         if(((u_int)out)&7) emit_addnop(0);
5551         #endif
5552       }
5553     }
5554     else if(nop) {
5555       emit_addimm_and_set_flags(cinfo[i].ccadj + CLOCK_ADJUST(2), cc);
5556       void *jaddr=out;
5557       emit_jns(0);
5558       add_stub(CC_STUB,jaddr,out,0,i,start+i*4+8,NOTTAKEN,0);
5559     }
5560     else {
5561       void *taken = NULL, *nottaken = NULL, *nottaken1 = NULL;
5562       do_cc(i,branch_regs[i].regmap,&adj,-1,0,invert);
5563       if(adj&&!invert) emit_addimm(cc, cinfo[i].ccadj + CLOCK_ADJUST(2) - adj, cc);
5564
5565       //printf("branch(%d): eax=%d ecx=%d edx=%d ebx=%d ebp=%d esi=%d edi=%d\n",i,branch_regs[i].regmap[0],branch_regs[i].regmap[1],branch_regs[i].regmap[2],branch_regs[i].regmap[3],branch_regs[i].regmap[5],branch_regs[i].regmap[6],branch_regs[i].regmap[7]);
5566       assert(s1l>=0);
5567       if(dops[i].opcode==4) // BEQ
5568       {
5569         if(s2l>=0) emit_cmp(s1l,s2l);
5570         else emit_test(s1l,s1l);
5571         if(invert){
5572           nottaken=out;
5573           emit_jne(DJT_1);
5574         }else{
5575           add_to_linker(out,cinfo[i].ba,internal);
5576           emit_jeq(0);
5577         }
5578       }
5579       if(dops[i].opcode==5) // BNE
5580       {
5581         if(s2l>=0) emit_cmp(s1l,s2l);
5582         else emit_test(s1l,s1l);
5583         if(invert){
5584           nottaken=out;
5585           emit_jeq(DJT_1);
5586         }else{
5587           add_to_linker(out,cinfo[i].ba,internal);
5588           emit_jne(0);
5589         }
5590       }
5591       if(dops[i].opcode==6) // BLEZ
5592       {
5593         emit_cmpimm(s1l,1);
5594         if(invert){
5595           nottaken=out;
5596           emit_jge(DJT_1);
5597         }else{
5598           add_to_linker(out,cinfo[i].ba,internal);
5599           emit_jl(0);
5600         }
5601       }
5602       if(dops[i].opcode==7) // BGTZ
5603       {
5604         emit_cmpimm(s1l,1);
5605         if(invert){
5606           nottaken=out;
5607           emit_jl(DJT_1);
5608         }else{
5609           add_to_linker(out,cinfo[i].ba,internal);
5610           emit_jge(0);
5611         }
5612       }
5613       if(invert) {
5614         if(taken) set_jump_target(taken, out);
5615         #ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
5616         if (match && (!internal || !dops[(cinfo[i].ba-start)>>2].is_ds)) {
5617           if(adj) {
5618             emit_addimm(cc,-adj,cc);
5619             add_to_linker(out,cinfo[i].ba,internal);
5620           }else{
5621             emit_addnop(13);
5622             add_to_linker(out,cinfo[i].ba,internal*2);
5623           }
5624           emit_jmp(0);
5625         }else
5626         #endif
5627         {
5628           if(adj) emit_addimm(cc,-adj,cc);
5629           store_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5630           load_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5631           if(internal)
5632             assem_debug("branch: internal\n");
5633           else
5634             assem_debug("branch: external\n");
5635           if (internal && dops[(cinfo[i].ba - start) >> 2].is_ds) {
5636             ds_assemble_entry(i);
5637           }
5638           else {
5639             add_to_linker(out,cinfo[i].ba,internal);
5640             emit_jmp(0);
5641           }
5642         }
5643         set_jump_target(nottaken, out);
5644       }
5645
5646       if(nottaken1) set_jump_target(nottaken1, out);
5647       if(adj) {
5648         if(!invert) emit_addimm(cc,adj,cc);
5649       }
5650     } // (!unconditional)
5651   } // if(ooo)
5652   else
5653   {
5654     // In-order execution (branch first)
5655     void *taken = NULL, *nottaken = NULL, *nottaken1 = NULL;
5656     if(!unconditional&&!nop) {
5657       //printf("branch(%d): eax=%d ecx=%d edx=%d ebx=%d ebp=%d esi=%d edi=%d\n",i,branch_regs[i].regmap[0],branch_regs[i].regmap[1],branch_regs[i].regmap[2],branch_regs[i].regmap[3],branch_regs[i].regmap[5],branch_regs[i].regmap[6],branch_regs[i].regmap[7]);
5658       assert(s1l>=0);
5659       if((dops[i].opcode&0x2f)==4) // BEQ
5660       {
5661         if(s2l>=0) emit_cmp(s1l,s2l);
5662         else emit_test(s1l,s1l);
5663         nottaken=out;
5664         emit_jne(DJT_2);
5665       }
5666       if((dops[i].opcode&0x2f)==5) // BNE
5667       {
5668         if(s2l>=0) emit_cmp(s1l,s2l);
5669         else emit_test(s1l,s1l);
5670         nottaken=out;
5671         emit_jeq(DJT_2);
5672       }
5673       if((dops[i].opcode&0x2f)==6) // BLEZ
5674       {
5675         emit_cmpimm(s1l,1);
5676         nottaken=out;
5677         emit_jge(DJT_2);
5678       }
5679       if((dops[i].opcode&0x2f)==7) // BGTZ
5680       {
5681         emit_cmpimm(s1l,1);
5682         nottaken=out;
5683         emit_jl(DJT_2);
5684       }
5685     } // if(!unconditional)
5686     int adj;
5687     uint64_t ds_unneeded=branch_regs[i].u;
5688     ds_unneeded&=~((1LL<<dops[i+1].rs1)|(1LL<<dops[i+1].rs2));
5689     ds_unneeded|=1;
5690     // branch taken
5691     if(!nop) {
5692       if(taken) set_jump_target(taken, out);
5693       assem_debug("1:\n");
5694       wb_invalidate(regs[i].regmap,branch_regs[i].regmap,regs[i].dirty,ds_unneeded);
5695       // load regs
5696       load_regs(regs[i].regmap,branch_regs[i].regmap,dops[i+1].rs1,dops[i+1].rs2);
5697       address_generation(i+1,&branch_regs[i],0);
5698       if (ram_offset)
5699         load_reg(regs[i].regmap,branch_regs[i].regmap,ROREG);
5700       load_regs(regs[i].regmap,branch_regs[i].regmap,CCREG,INVCP);
5701       ds_assemble(i+1,&branch_regs[i]);
5702       drc_dbg_emit_wb_dirtys(i+1, &branch_regs[i]);
5703       cc=get_reg(branch_regs[i].regmap,CCREG);
5704       if(cc==-1) {
5705         emit_loadreg(CCREG,cc=HOST_CCREG);
5706         // CHECK: Is the following instruction (fall thru) allocated ok?
5707       }
5708       assert(cc==HOST_CCREG);
5709       store_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5710       do_cc(i,i_regmap,&adj,cinfo[i].ba,TAKEN,0);
5711       assem_debug("cycle count (adj)\n");
5712       if(adj) emit_addimm(cc, cinfo[i].ccadj + CLOCK_ADJUST(2) - adj, cc);
5713       load_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5714       if(internal)
5715         assem_debug("branch: internal\n");
5716       else
5717         assem_debug("branch: external\n");
5718       if (internal && dops[(cinfo[i].ba - start) >> 2].is_ds) {
5719         ds_assemble_entry(i);
5720       }
5721       else {
5722         add_to_linker(out,cinfo[i].ba,internal);
5723         emit_jmp(0);
5724       }
5725     }
5726     // branch not taken
5727     if(!unconditional) {
5728       if(nottaken1) set_jump_target(nottaken1, out);
5729       set_jump_target(nottaken, out);
5730       assem_debug("2:\n");
5731       wb_invalidate(regs[i].regmap,branch_regs[i].regmap,regs[i].dirty,ds_unneeded);
5732       // load regs
5733       load_regs(regs[i].regmap,branch_regs[i].regmap,dops[i+1].rs1,dops[i+1].rs2);
5734       address_generation(i+1,&branch_regs[i],0);
5735       if (ram_offset)
5736         load_reg(regs[i].regmap,branch_regs[i].regmap,ROREG);
5737       load_regs(regs[i].regmap,branch_regs[i].regmap,CCREG,INVCP);
5738       ds_assemble(i+1,&branch_regs[i]);
5739       cc=get_reg(branch_regs[i].regmap,CCREG);
5740       if (cc == -1) {
5741         // Cycle count isn't in a register, temporarily load it then write it out
5742         emit_loadreg(CCREG,HOST_CCREG);
5743         emit_addimm_and_set_flags(cinfo[i].ccadj + CLOCK_ADJUST(2), HOST_CCREG);
5744         void *jaddr=out;
5745         emit_jns(0);
5746         add_stub(CC_STUB,jaddr,out,0,i,start+i*4+8,NOTTAKEN,0);
5747         emit_storereg(CCREG,HOST_CCREG);
5748       }
5749       else{
5750         cc=get_reg(i_regmap,CCREG);
5751         assert(cc==HOST_CCREG);
5752         emit_addimm_and_set_flags(cinfo[i].ccadj + CLOCK_ADJUST(2), cc);
5753         void *jaddr=out;
5754         emit_jns(0);
5755         add_stub(CC_STUB,jaddr,out,0,i,start+i*4+8,NOTTAKEN,0);
5756       }
5757     }
5758   }
5759 }
5760
5761 static void sjump_assemble(int i, const struct regstat *i_regs)
5762 {
5763   const signed char *i_regmap = i_regs->regmap;
5764   int cc;
5765   int match;
5766   match=match_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5767   assem_debug("smatch=%d ooo=%d\n", match, dops[i].ooo);
5768   int s1l;
5769   int unconditional=0,nevertaken=0;
5770   int invert=0;
5771   int internal=internal_branch(cinfo[i].ba);
5772   if(i==(cinfo[i].ba-start)>>2) assem_debug("idle loop\n");
5773   if(!match) invert=1;
5774   #ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
5775   if(i>(cinfo[i].ba-start)>>2) invert=1;
5776   #endif
5777   #ifdef __aarch64__
5778   invert=1; // because of near cond. branches
5779   #endif
5780
5781   //if(dops[i].opcode2>=0x10) return; // FIXME (BxxZAL)
5782   //assert(dops[i].opcode2<0x10||dops[i].rs1==0); // FIXME (BxxZAL)
5783
5784   if(dops[i].ooo) {
5785     s1l=get_reg(branch_regs[i].regmap,dops[i].rs1);
5786   }
5787   else {
5788     s1l=get_reg(i_regmap,dops[i].rs1);
5789   }
5790   if(dops[i].rs1==0)
5791   {
5792     if(dops[i].opcode2&1) unconditional=1;
5793     else nevertaken=1;
5794     // These are never taken (r0 is never less than zero)
5795     //assert(dops[i].opcode2!=0);
5796     //assert(dops[i].opcode2!=2);
5797     //assert(dops[i].opcode2!=0x10);
5798     //assert(dops[i].opcode2!=0x12);
5799   }
5800
5801   if(dops[i].ooo) {
5802     // Out of order execution (delay slot first)
5803     //printf("OOOE\n");
5804     address_generation(i+1,i_regs,regs[i].regmap_entry);
5805     ds_assemble(i+1,i_regs);
5806     int adj;
5807     uint64_t bc_unneeded=branch_regs[i].u;
5808     bc_unneeded&=~((1LL<<dops[i].rs1)|(1LL<<dops[i].rs2));
5809     bc_unneeded|=1;
5810     wb_invalidate(regs[i].regmap,branch_regs[i].regmap,regs[i].dirty,bc_unneeded);
5811     load_regs(regs[i].regmap,branch_regs[i].regmap,dops[i].rs1,dops[i].rs1);
5812     load_reg(regs[i].regmap,branch_regs[i].regmap,CCREG);
5813     if(dops[i].rt1==31) {
5814       int rt,return_address;
5815       rt=get_reg(branch_regs[i].regmap,31);
5816       //assem_debug("branch(%d): eax=%d ecx=%d edx=%d ebx=%d ebp=%d esi=%d edi=%d\n",i,branch_regs[i].regmap[0],branch_regs[i].regmap[1],branch_regs[i].regmap[2],branch_regs[i].regmap[3],branch_regs[i].regmap[5],branch_regs[i].regmap[6],branch_regs[i].regmap[7]);
5817       if(rt>=0) {
5818         // Save the PC even if the branch is not taken
5819         return_address=start+i*4+8;
5820         emit_movimm(return_address,rt); // PC into link register
5821         #ifdef IMM_PREFETCH
5822         if(!nevertaken) emit_prefetch(hash_table_get(return_address));
5823         #endif
5824       }
5825     }
5826     cc=get_reg(branch_regs[i].regmap,CCREG);
5827     assert(cc==HOST_CCREG);
5828     if(unconditional)
5829       store_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5830     //do_cc(i,branch_regs[i].regmap,&adj,unconditional?cinfo[i].ba:-1,unconditional);
5831     assem_debug("cycle count (adj)\n");
5832     if(unconditional) {
5833       do_cc(i,branch_regs[i].regmap,&adj,cinfo[i].ba,TAKEN,0);
5834       if(i!=(cinfo[i].ba-start)>>2 || source[i+1]!=0) {
5835         if(adj) emit_addimm(cc, cinfo[i].ccadj + CLOCK_ADJUST(2) - adj, cc);
5836         load_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5837         if(internal)
5838           assem_debug("branch: internal\n");
5839         else
5840           assem_debug("branch: external\n");
5841         if (internal && dops[(cinfo[i].ba - start) >> 2].is_ds) {
5842           ds_assemble_entry(i);
5843         }
5844         else {
5845           add_to_linker(out,cinfo[i].ba,internal);
5846           emit_jmp(0);
5847         }
5848         #ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
5849         if(((u_int)out)&7) emit_addnop(0);
5850         #endif
5851       }
5852     }
5853     else if(nevertaken) {
5854       emit_addimm_and_set_flags(cinfo[i].ccadj + CLOCK_ADJUST(2), cc);
5855       void *jaddr=out;
5856       emit_jns(0);
5857       add_stub(CC_STUB,jaddr,out,0,i,start+i*4+8,NOTTAKEN,0);
5858     }
5859     else {
5860       void *nottaken = NULL;
5861       do_cc(i,branch_regs[i].regmap,&adj,-1,0,invert);
5862       if(adj&&!invert) emit_addimm(cc, cinfo[i].ccadj + CLOCK_ADJUST(2) - adj, cc);
5863       {
5864         assert(s1l>=0);
5865         if ((dops[i].opcode2 & 1) == 0) // BLTZ/BLTZAL
5866         {
5867           emit_test(s1l,s1l);
5868           if(invert){
5869             nottaken=out;
5870             emit_jns(DJT_1);
5871           }else{
5872             add_to_linker(out,cinfo[i].ba,internal);
5873             emit_js(0);
5874           }
5875         }
5876         else // BGEZ/BGEZAL
5877         {
5878           emit_test(s1l,s1l);
5879           if(invert){
5880             nottaken=out;
5881             emit_js(DJT_1);
5882           }else{
5883             add_to_linker(out,cinfo[i].ba,internal);
5884             emit_jns(0);
5885           }
5886         }
5887       }
5888
5889       if(invert) {
5890         #ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
5891         if (match && (!internal || !dops[(cinfo[i].ba - start) >> 2].is_ds)) {
5892           if(adj) {
5893             emit_addimm(cc,-adj,cc);
5894             add_to_linker(out,cinfo[i].ba,internal);
5895           }else{
5896             emit_addnop(13);
5897             add_to_linker(out,cinfo[i].ba,internal*2);
5898           }
5899           emit_jmp(0);
5900         }else
5901         #endif
5902         {
5903           if(adj) emit_addimm(cc,-adj,cc);
5904           store_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5905           load_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5906           if(internal)
5907             assem_debug("branch: internal\n");
5908           else
5909             assem_debug("branch: external\n");
5910           if (internal && dops[(cinfo[i].ba - start) >> 2].is_ds) {
5911             ds_assemble_entry(i);
5912           }
5913           else {
5914             add_to_linker(out,cinfo[i].ba,internal);
5915             emit_jmp(0);
5916           }
5917         }
5918         set_jump_target(nottaken, out);
5919       }
5920
5921       if(adj) {
5922         if(!invert) emit_addimm(cc,adj,cc);
5923       }
5924     } // (!unconditional)
5925   } // if(ooo)
5926   else
5927   {
5928     // In-order execution (branch first)
5929     //printf("IOE\n");
5930     void *nottaken = NULL;
5931     if (!unconditional && !nevertaken) {
5932       assert(s1l >= 0);
5933       emit_test(s1l, s1l);
5934     }
5935     if (dops[i].rt1 == 31) {
5936       int rt, return_address;
5937       rt = get_reg(branch_regs[i].regmap,31);
5938       if(rt >= 0) {
5939         // Save the PC even if the branch is not taken
5940         return_address = start + i*4+8;
5941         emit_movimm(return_address, rt); // PC into link register
5942         #ifdef IMM_PREFETCH
5943         emit_prefetch(hash_table_get(return_address));
5944         #endif
5945       }
5946     }
5947     if (!unconditional && !nevertaken) {
5948       nottaken = out;
5949       if (!(dops[i].opcode2 & 1)) // BLTZ/BLTZAL
5950         emit_jns(DJT_1);
5951       else                        // BGEZ/BGEZAL
5952         emit_js(DJT_1);
5953     }
5954     int adj;
5955     uint64_t ds_unneeded=branch_regs[i].u;
5956     ds_unneeded&=~((1LL<<dops[i+1].rs1)|(1LL<<dops[i+1].rs2));
5957     ds_unneeded|=1;
5958     // branch taken
5959     if(!nevertaken) {
5960       //assem_debug("1:\n");
5961       wb_invalidate(regs[i].regmap,branch_regs[i].regmap,regs[i].dirty,ds_unneeded);
5962       // load regs
5963       load_regs(regs[i].regmap,branch_regs[i].regmap,dops[i+1].rs1,dops[i+1].rs2);
5964       address_generation(i+1,&branch_regs[i],0);
5965       if (ram_offset)
5966         load_reg(regs[i].regmap,branch_regs[i].regmap,ROREG);
5967       load_regs(regs[i].regmap,branch_regs[i].regmap,CCREG,INVCP);
5968       ds_assemble(i+1,&branch_regs[i]);
5969       cc=get_reg(branch_regs[i].regmap,CCREG);
5970       if(cc==-1) {
5971         emit_loadreg(CCREG,cc=HOST_CCREG);
5972         // CHECK: Is the following instruction (fall thru) allocated ok?
5973       }
5974       assert(cc==HOST_CCREG);
5975       store_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5976       do_cc(i,i_regmap,&adj,cinfo[i].ba,TAKEN,0);
5977       assem_debug("cycle count (adj)\n");
5978       if(adj) emit_addimm(cc, cinfo[i].ccadj + CLOCK_ADJUST(2) - adj, cc);
5979       load_regs_bt(branch_regs[i].regmap,branch_regs[i].dirty,cinfo[i].ba);
5980       if(internal)
5981         assem_debug("branch: internal\n");
5982       else
5983         assem_debug("branch: external\n");
5984       if (internal && dops[(cinfo[i].ba - start) >> 2].is_ds) {
5985         ds_assemble_entry(i);
5986       }
5987       else {
5988         add_to_linker(out,cinfo[i].ba,internal);
5989         emit_jmp(0);
5990       }
5991     }
5992     // branch not taken
5993     if(!unconditional) {
5994       if (!nevertaken) {
5995         assert(nottaken);
5996         set_jump_target(nottaken, out);
5997       }
5998       assem_debug("1:\n");
5999       wb_invalidate(regs[i].regmap,branch_regs[i].regmap,regs[i].dirty,ds_unneeded);
6000       load_regs(regs[i].regmap,branch_regs[i].regmap,dops[i+1].rs1,dops[i+1].rs2);
6001       address_generation(i+1,&branch_regs[i],0);
6002       if (ram_offset)
6003         load_reg(regs[i].regmap,branch_regs[i].regmap,ROREG);
6004       load_regs(regs[i].regmap,branch_regs[i].regmap,CCREG,INVCP);
6005       ds_assemble(i+1,&branch_regs[i]);
6006       cc=get_reg(branch_regs[i].regmap,CCREG);
6007       if (cc == -1) {
6008         // Cycle count isn't in a register, temporarily load it then write it out
6009         emit_loadreg(CCREG,HOST_CCREG);
6010         emit_addimm_and_set_flags(cinfo[i].ccadj + CLOCK_ADJUST(2), HOST_CCREG);
6011         void *jaddr=out;
6012         emit_jns(0);
6013         add_stub(CC_STUB,jaddr,out,0,i,start+i*4+8,NOTTAKEN,0);
6014         emit_storereg(CCREG,HOST_CCREG);
6015       }
6016       else{
6017         cc=get_reg(i_regmap,CCREG);
6018         assert(cc==HOST_CCREG);
6019         emit_addimm_and_set_flags(cinfo[i].ccadj + CLOCK_ADJUST(2), cc);
6020         void *jaddr=out;
6021         emit_jns(0);
6022         add_stub(CC_STUB,jaddr,out,0,i,start+i*4+8,NOTTAKEN,0);
6023       }
6024     }
6025   }
6026 }
6027
6028 static void check_regmap(signed char *regmap)
6029 {
6030 #ifndef NDEBUG
6031   int i,j;
6032   for (i = 0; i < HOST_REGS; i++) {
6033     if (regmap[i] < 0)
6034       continue;
6035     for (j = i + 1; j < HOST_REGS; j++)
6036       assert(regmap[i] != regmap[j]);
6037   }
6038 #endif
6039 }
6040
6041 #ifdef DISASM
6042 #include <inttypes.h>
6043 static char insn[MAXBLOCK][10];
6044
6045 #define set_mnemonic(i_, n_) \
6046   strcpy(insn[i_], n_)
6047
6048 void print_regmap(const char *name, const signed char *regmap)
6049 {
6050   char buf[5];
6051   int i, l;
6052   fputs(name, stdout);
6053   for (i = 0; i < HOST_REGS; i++) {
6054     l = 0;
6055     if (regmap[i] >= 0)
6056       l = snprintf(buf, sizeof(buf), "$%d", regmap[i]);
6057     for (; l < 3; l++)
6058       buf[l] = ' ';
6059     buf[l] = 0;
6060     printf(" r%d=%s", i, buf);
6061   }
6062   fputs("\n", stdout);
6063 }
6064
6065   /* disassembly */
6066 void disassemble_inst(int i)
6067 {
6068     if (dops[i].bt) printf("*"); else printf(" ");
6069     switch(dops[i].itype) {
6070       case UJUMP:
6071         printf (" %x: %s %8x\n",start+i*4,insn[i],cinfo[i].ba);break;
6072       case CJUMP:
6073         printf (" %x: %s r%d,r%d,%8x\n",start+i*4,insn[i],dops[i].rs1,dops[i].rs2,i?start+i*4+4+((signed int)((unsigned int)source[i]<<16)>>14):cinfo[i].ba);break;
6074       case SJUMP:
6075         printf (" %x: %s r%d,%8x\n",start+i*4,insn[i],dops[i].rs1,start+i*4+4+((signed int)((unsigned int)source[i]<<16)>>14));break;
6076       case RJUMP:
6077         if (dops[i].opcode2 == 9 && dops[i].rt1 != 31)
6078           printf (" %x: %s r%d,r%d\n",start+i*4,insn[i],dops[i].rt1,dops[i].rs1);
6079         else
6080           printf (" %x: %s r%d\n",start+i*4,insn[i],dops[i].rs1);
6081         break;
6082       case IMM16:
6083         if(dops[i].opcode==0xf) //LUI
6084           printf (" %x: %s r%d,%4x0000\n",start+i*4,insn[i],dops[i].rt1,cinfo[i].imm&0xffff);
6085         else
6086           printf (" %x: %s r%d,r%d,%d\n",start+i*4,insn[i],dops[i].rt1,dops[i].rs1,cinfo[i].imm);
6087         break;
6088       case LOAD:
6089       case LOADLR:
6090         printf (" %x: %s r%d,r%d+%x\n",start+i*4,insn[i],dops[i].rt1,dops[i].rs1,cinfo[i].imm);
6091         break;
6092       case STORE:
6093       case STORELR:
6094         printf (" %x: %s r%d,r%d+%x\n",start+i*4,insn[i],dops[i].rs2,dops[i].rs1,cinfo[i].imm);
6095         break;
6096       case ALU:
6097       case SHIFT:
6098         printf (" %x: %s r%d,r%d,r%d\n",start+i*4,insn[i],dops[i].rt1,dops[i].rs1,dops[i].rs2);
6099         break;
6100       case MULTDIV:
6101         printf (" %x: %s r%d,r%d\n",start+i*4,insn[i],dops[i].rs1,dops[i].rs2);
6102         break;
6103       case SHIFTIMM:
6104         printf (" %x: %s r%d,r%d,%d\n",start+i*4,insn[i],dops[i].rt1,dops[i].rs1,cinfo[i].imm);
6105         break;
6106       case MOV:
6107         if((dops[i].opcode2&0x1d)==0x10)
6108           printf (" %x: %s r%d\n",start+i*4,insn[i],dops[i].rt1);
6109         else if((dops[i].opcode2&0x1d)==0x11)
6110           printf (" %x: %s r%d\n",start+i*4,insn[i],dops[i].rs1);
6111         else
6112           printf (" %x: %s\n",start+i*4,insn[i]);
6113         break;
6114       case COP0:
6115         if(dops[i].opcode2==0)
6116           printf (" %x: %s r%d,cpr0[%d]\n",start+i*4,insn[i],dops[i].rt1,(source[i]>>11)&0x1f); // MFC0
6117         else if(dops[i].opcode2==4)
6118           printf (" %x: %s r%d,cpr0[%d]\n",start+i*4,insn[i],dops[i].rs1,(source[i]>>11)&0x1f); // MTC0
6119         else printf (" %x: %s\n",start+i*4,insn[i]);
6120         break;
6121       case COP2:
6122         if(dops[i].opcode2<3)
6123           printf (" %x: %s r%d,cpr2[%d]\n",start+i*4,insn[i],dops[i].rt1,(source[i]>>11)&0x1f); // MFC2
6124         else if(dops[i].opcode2>3)
6125           printf (" %x: %s r%d,cpr2[%d]\n",start+i*4,insn[i],dops[i].rs1,(source[i]>>11)&0x1f); // MTC2
6126         else printf (" %x: %s\n",start+i*4,insn[i]);
6127         break;
6128       case C2LS:
6129         printf (" %x: %s cpr2[%d],r%d+%x\n",start+i*4,insn[i],(source[i]>>16)&0x1f,dops[i].rs1,cinfo[i].imm);
6130         break;
6131       case INTCALL:
6132         printf (" %x: %s (INTCALL)\n",start+i*4,insn[i]);
6133         break;
6134       default:
6135         //printf (" %s %8x\n",insn[i],source[i]);
6136         printf (" %x: %s\n",start+i*4,insn[i]);
6137     }
6138     #ifndef REGMAP_PRINT
6139     return;
6140     #endif
6141     printf("D: %x  WD: %x  U: %"PRIx64"  hC: %x  hWC: %x  hLC: %x\n",
6142       regs[i].dirty, regs[i].wasdirty, unneeded_reg[i],
6143       regs[i].isconst, regs[i].wasconst, regs[i].loadedconst);
6144     print_regmap("pre:   ", regmap_pre[i]);
6145     print_regmap("entry: ", regs[i].regmap_entry);
6146     print_regmap("map:   ", regs[i].regmap);
6147     if (dops[i].is_jump) {
6148       print_regmap("bentry:", branch_regs[i].regmap_entry);
6149       print_regmap("bmap:  ", branch_regs[i].regmap);
6150     }
6151 }
6152 #else
6153 #define set_mnemonic(i_, n_)
6154 static void disassemble_inst(int i) {}
6155 #endif // DISASM
6156
6157 #define DRC_TEST_VAL 0x74657374
6158
6159 static noinline void new_dynarec_test(void)
6160 {
6161   int (*testfunc)(void);
6162   void *beginning;
6163   int ret[2];
6164   size_t i;
6165
6166   // check structure linkage
6167   if ((u_char *)rcnts - (u_char *)&psxRegs != sizeof(psxRegs))
6168   {
6169     SysPrintf("linkage_arm* miscompilation/breakage detected.\n");
6170   }
6171
6172   SysPrintf("(%p) testing if we can run recompiled code @%p...\n",
6173     new_dynarec_test, out);
6174   ((volatile u_int *)NDRC_WRITE_OFFSET(out))[0]++; // make the cache dirty
6175
6176   for (i = 0; i < ARRAY_SIZE(ret); i++) {
6177     out = ndrc->translation_cache;
6178     beginning = start_block();
6179     emit_movimm(DRC_TEST_VAL + i, 0); // test
6180     emit_ret();
6181     literal_pool(0);
6182     end_block(beginning);
6183     testfunc = beginning;
6184     ret[i] = testfunc();
6185   }
6186
6187   if (ret[0] == DRC_TEST_VAL && ret[1] == DRC_TEST_VAL + 1)
6188     SysPrintf("test passed.\n");
6189   else
6190     SysPrintf("test failed, will likely crash soon (r=%08x %08x)\n", ret[0], ret[1]);
6191   out = ndrc->translation_cache;
6192 }
6193
6194 static int get_cycle_multiplier(void)
6195 {
6196   return Config.cycle_multiplier_override && Config.cycle_multiplier == CYCLE_MULT_DEFAULT
6197      ? Config.cycle_multiplier_override : Config.cycle_multiplier;
6198 }
6199
6200 // clear the state completely, instead of just marking
6201 // things invalid like invalidate_all_pages() does
6202 void new_dynarec_clear_full(void)
6203 {
6204   int n;
6205   out = ndrc->translation_cache;
6206   memset(invalid_code,1,sizeof(invalid_code));
6207   memset(hash_table,0xff,sizeof(hash_table));
6208   memset(mini_ht,-1,sizeof(mini_ht));
6209   memset(shadow,0,sizeof(shadow));
6210   copy=shadow;
6211   expirep = EXPIRITY_OFFSET;
6212   pending_exception=0;
6213   literalcount=0;
6214   stop_after_jal=0;
6215   inv_code_start=inv_code_end=~0;
6216   hack_addr=0;
6217   f1_hack=0;
6218   for (n = 0; n < ARRAY_SIZE(blocks); n++)
6219     blocks_clear(&blocks[n]);
6220   for (n = 0; n < ARRAY_SIZE(jumps); n++) {
6221     free(jumps[n]);
6222     jumps[n] = NULL;
6223   }
6224   stat_clear(stat_blocks);
6225   stat_clear(stat_links);
6226
6227   if (cycle_multiplier_old != Config.cycle_multiplier
6228       || new_dynarec_hacks_old != new_dynarec_hacks)
6229   {
6230     SysPrintf("ndrc config: mul=%d, ha=%x, pex=%d\n",
6231       get_cycle_multiplier(), new_dynarec_hacks, Config.PreciseExceptions);
6232   }
6233   cycle_multiplier_old = Config.cycle_multiplier;
6234   new_dynarec_hacks_old = new_dynarec_hacks;
6235 }
6236
6237 void new_dynarec_init(void)
6238 {
6239   SysPrintf("Init new dynarec, ndrc size %x\n", (int)sizeof(*ndrc));
6240
6241 #ifdef _3DS
6242   check_rosalina();
6243 #endif
6244 #ifdef BASE_ADDR_DYNAMIC
6245   #ifdef VITA
6246   sceBlock = getVMBlock(); //sceKernelAllocMemBlockForVM("code", sizeof(*ndrc));
6247   if (sceBlock <= 0)
6248     SysPrintf("sceKernelAllocMemBlockForVM failed: %x\n", sceBlock);
6249   int ret = sceKernelGetMemBlockBase(sceBlock, (void **)&ndrc);
6250   if (ret < 0)
6251     SysPrintf("sceKernelGetMemBlockBase failed: %x\n", ret);
6252   sceKernelOpenVMDomain();
6253   sceClibPrintf("translation_cache = 0x%08lx\n ", (long)ndrc->translation_cache);
6254   #elif defined(_MSC_VER)
6255   ndrc = VirtualAlloc(NULL, sizeof(*ndrc), MEM_COMMIT | MEM_RESERVE,
6256     PAGE_EXECUTE_READWRITE);
6257   #elif defined(HAVE_LIBNX)
6258   Result rc = jitCreate(&g_jit, sizeof(*ndrc));
6259   if (R_FAILED(rc))
6260     SysPrintf("jitCreate failed: %08x\n", rc);
6261   SysPrintf("jitCreate: RX: %p RW: %p type: %d\n", g_jit.rx_addr, g_jit.rw_addr, g_jit.type);
6262   jitTransitionToWritable(&g_jit);
6263   ndrc = g_jit.rx_addr;
6264   ndrc_write_ofs = (char *)g_jit.rw_addr - (char *)ndrc;
6265   memset(NDRC_WRITE_OFFSET(&ndrc->tramp), 0, sizeof(ndrc->tramp));
6266   #else
6267   uintptr_t desired_addr = 0;
6268   int prot = PROT_READ | PROT_WRITE | PROT_EXEC;
6269   int flags = MAP_PRIVATE | MAP_ANONYMOUS;
6270   int fd = -1;
6271   #ifdef __ELF__
6272   extern char _end;
6273   desired_addr = ((uintptr_t)&_end + 0xffffff) & ~0xffffffl;
6274   #endif
6275   #ifdef TC_WRITE_OFFSET
6276   // mostly for testing
6277   fd = open("/dev/shm/pcsxr", O_CREAT | O_RDWR, 0600);
6278   ftruncate(fd, sizeof(*ndrc));
6279   void *mw = mmap(NULL, sizeof(*ndrc), PROT_READ | PROT_WRITE,
6280                   (flags = MAP_SHARED), fd, 0);
6281   assert(mw != MAP_FAILED);
6282   prot = PROT_READ | PROT_EXEC;
6283   #endif
6284   ndrc = mmap((void *)desired_addr, sizeof(*ndrc), prot, flags, fd, 0);
6285   if (ndrc == MAP_FAILED) {
6286     SysPrintf("mmap() failed: %s\n", strerror(errno));
6287     abort();
6288   }
6289   #ifdef TC_WRITE_OFFSET
6290   ndrc_write_ofs = (char *)mw - (char *)ndrc;
6291   #endif
6292   #endif
6293 #else
6294   #ifndef NO_WRITE_EXEC
6295   // not all systems allow execute in data segment by default
6296   // size must be 4K aligned for 3DS?
6297   if (mprotect(ndrc, sizeof(*ndrc),
6298                PROT_READ | PROT_WRITE | PROT_EXEC) != 0)
6299     SysPrintf("mprotect() failed: %s\n", strerror(errno));
6300   #endif
6301 #endif
6302   out = ndrc->translation_cache;
6303   new_dynarec_clear_full();
6304 #ifdef HOST_IMM8
6305   // Copy this into local area so we don't have to put it in every literal pool
6306   invc_ptr=invalid_code;
6307 #endif
6308   arch_init();
6309   new_dynarec_test();
6310   ram_offset = (uintptr_t)psxM - 0x80000000;
6311   if (ram_offset!=0)
6312     SysPrintf("warning: RAM is not directly mapped, performance will suffer\n");
6313   SysPrintf("Mapped (RAM/scrp/ROM/LUTs/TC):\n");
6314   SysPrintf("%p/%p/%p/%p/%p\n", psxM, psxH, psxR, mem_rtab, out);
6315 }
6316
6317 void new_dynarec_cleanup(void)
6318 {
6319   int n;
6320 #ifdef BASE_ADDR_DYNAMIC
6321   #ifdef VITA
6322   // sceBlock is managed by retroarch's bootstrap code
6323   //sceKernelFreeMemBlock(sceBlock);
6324   //sceBlock = -1;
6325   #elif defined(HAVE_LIBNX)
6326   jitClose(&g_jit);
6327   ndrc = NULL;
6328   #else
6329   if (munmap(ndrc, sizeof(*ndrc)) < 0)
6330     SysPrintf("munmap() failed\n");
6331   ndrc = NULL;
6332   #endif
6333 #endif
6334   for (n = 0; n < ARRAY_SIZE(blocks); n++)
6335     blocks_clear(&blocks[n]);
6336   for (n = 0; n < ARRAY_SIZE(jumps); n++) {
6337     free(jumps[n]);
6338     jumps[n] = NULL;
6339   }
6340   stat_clear(stat_blocks);
6341   stat_clear(stat_links);
6342   new_dynarec_print_stats();
6343 }
6344
6345 static u_int *get_source_start(u_int addr, u_int *limit)
6346 {
6347   if (addr < 0x00800000
6348       || (0x80000000 <= addr && addr < 0x80800000)
6349       || (0xa0000000 <= addr && addr < 0xa0800000))
6350   {
6351     // used for BIOS calls mostly?
6352     *limit = (addr & 0xa0600000) + 0x00200000;
6353     return (u_int *)(psxM + (addr & 0x1fffff));
6354   }
6355   else if (
6356     /* (0x9fc00000 <= addr && addr < 0x9fc80000) ||*/
6357     (0xbfc00000 <= addr && addr < 0xbfc80000))
6358   {
6359     // BIOS. The multiplier should be much higher as it's uncached 8bit mem,
6360     // but timings in PCSX are too tied to the interpreter's 2-per-insn assumption
6361     if (!HACK_ENABLED(NDHACK_OVERRIDE_CYCLE_M))
6362       cycle_multiplier_active = 200;
6363
6364     *limit = (addr & 0xfff00000) | 0x80000;
6365     return (u_int *)((u_char *)psxR + (addr&0x7ffff));
6366   }
6367   return NULL;
6368 }
6369
6370 static u_int scan_for_ret(u_int addr)
6371 {
6372   u_int limit = 0;
6373   u_int *mem;
6374
6375   mem = get_source_start(addr, &limit);
6376   if (mem == NULL)
6377     return addr;
6378
6379   if (limit > addr + 0x1000)
6380     limit = addr + 0x1000;
6381   for (; addr < limit; addr += 4, mem++) {
6382     if (*mem == 0x03e00008) // jr $ra
6383       return addr + 8;
6384   }
6385   return addr;
6386 }
6387
6388 struct savestate_block {
6389   uint32_t addr;
6390   uint32_t regflags;
6391 };
6392
6393 static int addr_cmp(const void *p1_, const void *p2_)
6394 {
6395   const struct savestate_block *p1 = p1_, *p2 = p2_;
6396   return p1->addr - p2->addr;
6397 }
6398
6399 int new_dynarec_save_blocks(void *save, int size)
6400 {
6401   struct savestate_block *sblocks = save;
6402   int maxcount = size / sizeof(sblocks[0]);
6403   struct savestate_block tmp_blocks[1024];
6404   struct block_info *block;
6405   int p, s, d, o, bcnt;
6406   u_int addr;
6407
6408   o = 0;
6409   for (p = 0; p < ARRAY_SIZE(blocks); p++) {
6410     bcnt = 0;
6411     for (block = blocks[p]; block != NULL; block = block->next) {
6412       if (block->is_dirty)
6413         continue;
6414       tmp_blocks[bcnt].addr = block->start;
6415       tmp_blocks[bcnt].regflags = block->reg_sv_flags;
6416       bcnt++;
6417     }
6418     if (bcnt < 1)
6419       continue;
6420     qsort(tmp_blocks, bcnt, sizeof(tmp_blocks[0]), addr_cmp);
6421
6422     addr = tmp_blocks[0].addr;
6423     for (s = d = 0; s < bcnt; s++) {
6424       if (tmp_blocks[s].addr < addr)
6425         continue;
6426       if (d == 0 || tmp_blocks[d-1].addr != tmp_blocks[s].addr)
6427         tmp_blocks[d++] = tmp_blocks[s];
6428       addr = scan_for_ret(tmp_blocks[s].addr);
6429     }
6430
6431     if (o + d > maxcount)
6432       d = maxcount - o;
6433     memcpy(&sblocks[o], tmp_blocks, d * sizeof(sblocks[0]));
6434     o += d;
6435   }
6436
6437   return o * sizeof(sblocks[0]);
6438 }
6439
6440 void new_dynarec_load_blocks(const void *save, int size)
6441 {
6442   const struct savestate_block *sblocks = save;
6443   int count = size / sizeof(sblocks[0]);
6444   struct block_info *block;
6445   u_int regs_save[32];
6446   u_int page;
6447   uint32_t f;
6448   int i, b;
6449
6450   // restore clean blocks, if any
6451   for (page = 0, b = i = 0; page < ARRAY_SIZE(blocks); page++) {
6452     for (block = blocks[page]; block != NULL; block = block->next, b++) {
6453       if (!block->is_dirty)
6454         continue;
6455       assert(block->source && block->copy);
6456       if (memcmp(block->source, block->copy, block->len))
6457         continue;
6458
6459       // see try_restore_block
6460       block->is_dirty = 0;
6461       mark_invalid_code(block->start, block->len, 0);
6462       i++;
6463     }
6464   }
6465   inv_debug("load_blocks: %d/%d clean blocks\n", i, b);
6466
6467   // change GPRs for speculation to at least partially work..
6468   memcpy(regs_save, &psxRegs.GPR, sizeof(regs_save));
6469   for (i = 1; i < 32; i++)
6470     psxRegs.GPR.r[i] = 0x80000000;
6471
6472   for (b = 0; b < count; b++) {
6473     for (f = sblocks[b].regflags, i = 0; f; f >>= 1, i++) {
6474       if (f & 1)
6475         psxRegs.GPR.r[i] = 0x1f800000;
6476     }
6477
6478     ndrc_get_addr_ht(sblocks[b].addr);
6479
6480     for (f = sblocks[b].regflags, i = 0; f; f >>= 1, i++) {
6481       if (f & 1)
6482         psxRegs.GPR.r[i] = 0x80000000;
6483     }
6484   }
6485
6486   memcpy(&psxRegs.GPR, regs_save, sizeof(regs_save));
6487 }
6488
6489 void new_dynarec_print_stats(void)
6490 {
6491 #ifdef STAT_PRINT
6492   printf("cc %3d,%3d,%3d lu%6d,%3d,%3d c%3d inv%3d,%3d tc_offs %zu b %u,%u\n",
6493     stat_bc_pre, stat_bc_direct, stat_bc_restore,
6494     stat_ht_lookups, stat_jump_in_lookups, stat_restore_tries,
6495     stat_restore_compares, stat_inv_addr_calls, stat_inv_hits,
6496     out - ndrc->translation_cache, stat_blocks, stat_links);
6497   stat_bc_direct = stat_bc_pre = stat_bc_restore =
6498   stat_ht_lookups = stat_jump_in_lookups = stat_restore_tries =
6499   stat_restore_compares = stat_inv_addr_calls = stat_inv_hits = 0;
6500 #endif
6501 }
6502
6503 static int apply_hacks(void)
6504 {
6505   int i;
6506   if (HACK_ENABLED(NDHACK_NO_COMPAT_HACKS))
6507     return 0;
6508   /* special hack(s) */
6509   for (i = 0; i < slen - 4; i++)
6510   {
6511     // lui a4, 0xf200; jal <rcnt_read>; addu a0, 2; slti v0, 28224
6512     if (source[i] == 0x3c04f200 && dops[i+1].itype == UJUMP
6513         && source[i+2] == 0x34840002 && dops[i+3].opcode == 0x0a
6514         && cinfo[i+3].imm == 0x6e40 && dops[i+3].rs1 == 2)
6515     {
6516       SysPrintf("PE2 hack @%08x\n", start + (i+3)*4);
6517       dops[i + 3].itype = NOP;
6518     }
6519   }
6520   i = slen;
6521   if (i > 10 && source[i-1] == 0 && source[i-2] == 0x03e00008
6522       && source[i-4] == 0x8fbf0018 && source[i-6] == 0x00c0f809
6523       && dops[i-7].itype == STORE)
6524   {
6525     i = i-8;
6526     if (dops[i].itype == IMM16)
6527       i--;
6528     // swl r2, 15(r6); swr r2, 12(r6); sw r6, *; jalr r6
6529     if (dops[i].itype == STORELR && dops[i].rs1 == 6
6530       && dops[i-1].itype == STORELR && dops[i-1].rs1 == 6)
6531     {
6532       SysPrintf("F1 hack from %08x, old dst %08x\n", start, hack_addr);
6533       f1_hack = 1;
6534       return 1;
6535     }
6536   }
6537   return 0;
6538 }
6539
6540 static int is_ld_use_hazard(int ld_rt, const struct decoded_insn *op)
6541 {
6542   return ld_rt != 0 && (ld_rt == op->rs1 || ld_rt == op->rs2)
6543     && op->itype != LOADLR && op->itype != CJUMP && op->itype != SJUMP;
6544 }
6545
6546 static void force_intcall(int i)
6547 {
6548   memset(&dops[i], 0, sizeof(dops[i]));
6549   dops[i].itype = INTCALL;
6550   dops[i].rs1 = CCREG;
6551   dops[i].is_exception = 1;
6552   cinfo[i].ba = -1;
6553 }
6554
6555 static void disassemble_one(int i, u_int src)
6556 {
6557     unsigned int type, op, op2, op3;
6558     enum ls_width_type ls_type = LS_32;
6559     memset(&dops[i], 0, sizeof(dops[i]));
6560     memset(&cinfo[i], 0, sizeof(cinfo[i]));
6561     cinfo[i].ba = -1;
6562     cinfo[i].addr = -1;
6563     dops[i].opcode = op = src >> 26;
6564     op2 = 0;
6565     type = INTCALL;
6566     set_mnemonic(i, "???");
6567     switch(op)
6568     {
6569       case 0x00: set_mnemonic(i, "special");
6570         op2 = src & 0x3f;
6571         switch(op2)
6572         {
6573           case 0x00: set_mnemonic(i, "SLL"); type=SHIFTIMM; break;
6574           case 0x02: set_mnemonic(i, "SRL"); type=SHIFTIMM; break;
6575           case 0x03: set_mnemonic(i, "SRA"); type=SHIFTIMM; break;
6576           case 0x04: set_mnemonic(i, "SLLV"); type=SHIFT; break;
6577           case 0x06: set_mnemonic(i, "SRLV"); type=SHIFT; break;
6578           case 0x07: set_mnemonic(i, "SRAV"); type=SHIFT; break;
6579           case 0x08: set_mnemonic(i, "JR"); type=RJUMP; break;
6580           case 0x09: set_mnemonic(i, "JALR"); type=RJUMP; break;
6581           case 0x0C: set_mnemonic(i, "SYSCALL"); type=SYSCALL; break;
6582           case 0x0D: set_mnemonic(i, "BREAK"); type=SYSCALL; break;
6583           case 0x10: set_mnemonic(i, "MFHI"); type=MOV; break;
6584           case 0x11: set_mnemonic(i, "MTHI"); type=MOV; break;
6585           case 0x12: set_mnemonic(i, "MFLO"); type=MOV; break;
6586           case 0x13: set_mnemonic(i, "MTLO"); type=MOV; break;
6587           case 0x18: set_mnemonic(i, "MULT"); type=MULTDIV; break;
6588           case 0x19: set_mnemonic(i, "MULTU"); type=MULTDIV; break;
6589           case 0x1A: set_mnemonic(i, "DIV"); type=MULTDIV; break;
6590           case 0x1B: set_mnemonic(i, "DIVU"); type=MULTDIV; break;
6591           case 0x20: set_mnemonic(i, "ADD"); type=ALU; break;
6592           case 0x21: set_mnemonic(i, "ADDU"); type=ALU; break;
6593           case 0x22: set_mnemonic(i, "SUB"); type=ALU; break;
6594           case 0x23: set_mnemonic(i, "SUBU"); type=ALU; break;
6595           case 0x24: set_mnemonic(i, "AND"); type=ALU; break;
6596           case 0x25: set_mnemonic(i, "OR"); type=ALU; break;
6597           case 0x26: set_mnemonic(i, "XOR"); type=ALU; break;
6598           case 0x27: set_mnemonic(i, "NOR"); type=ALU; break;
6599           case 0x2A: set_mnemonic(i, "SLT"); type=ALU; break;
6600           case 0x2B: set_mnemonic(i, "SLTU"); type=ALU; break;
6601         }
6602         break;
6603       case 0x01: set_mnemonic(i, "regimm");
6604         type = SJUMP;
6605         op2 = (src >> 16) & 0x1f;
6606         switch(op2)
6607         {
6608           case 0x10: set_mnemonic(i, "BLTZAL"); break;
6609           case 0x11: set_mnemonic(i, "BGEZAL"); break;
6610           default:
6611             if (op2 & 1)
6612               set_mnemonic(i, "BGEZ");
6613             else
6614               set_mnemonic(i, "BLTZ");
6615         }
6616         break;
6617       case 0x02: set_mnemonic(i, "J"); type=UJUMP; break;
6618       case 0x03: set_mnemonic(i, "JAL"); type=UJUMP; break;
6619       case 0x04: set_mnemonic(i, "BEQ"); type=CJUMP; break;
6620       case 0x05: set_mnemonic(i, "BNE"); type=CJUMP; break;
6621       case 0x06: set_mnemonic(i, "BLEZ"); type=CJUMP; break;
6622       case 0x07: set_mnemonic(i, "BGTZ"); type=CJUMP; break;
6623       case 0x08: set_mnemonic(i, "ADDI"); type=IMM16; break;
6624       case 0x09: set_mnemonic(i, "ADDIU"); type=IMM16; break;
6625       case 0x0A: set_mnemonic(i, "SLTI"); type=IMM16; break;
6626       case 0x0B: set_mnemonic(i, "SLTIU"); type=IMM16; break;
6627       case 0x0C: set_mnemonic(i, "ANDI"); type=IMM16; break;
6628       case 0x0D: set_mnemonic(i, "ORI"); type=IMM16; break;
6629       case 0x0E: set_mnemonic(i, "XORI"); type=IMM16; break;
6630       case 0x0F: set_mnemonic(i, "LUI"); type=IMM16; break;
6631       case 0x10: set_mnemonic(i, "COP0");
6632         op2 = (src >> 21) & 0x1f;
6633         if (op2 & 0x10) {
6634           op3 = src & 0x1f;
6635           switch (op3)
6636           {
6637             case 0x01: case 0x02: case 0x06: case 0x08: type = INTCALL; break;
6638             case 0x10: set_mnemonic(i, "RFE"); type=RFE; break;
6639             default:   type = OTHER; break;
6640           }
6641           break;
6642         }
6643         switch(op2)
6644         {
6645           u32 rd;
6646           case 0x00:
6647             set_mnemonic(i, "MFC0");
6648             rd = (src >> 11) & 0x1F;
6649             if (!(0x00000417u & (1u << rd)))
6650               type = COP0;
6651             break;
6652           case 0x04: set_mnemonic(i, "MTC0"); type=COP0; break;
6653           case 0x02:
6654           case 0x06: type = INTCALL; break;
6655           default:   type = OTHER; break;
6656         }
6657         break;
6658       case 0x11: set_mnemonic(i, "COP1");
6659         op2 = (src >> 21) & 0x1f;
6660         break;
6661       case 0x12: set_mnemonic(i, "COP2");
6662         op2 = (src >> 21) & 0x1f;
6663         if (op2 & 0x10) {
6664           type = OTHER;
6665           if (gte_handlers[src & 0x3f] != NULL) {
6666 #ifdef DISASM
6667             if (gte_regnames[src & 0x3f] != NULL)
6668               strcpy(insn[i], gte_regnames[src & 0x3f]);
6669             else
6670               snprintf(insn[i], sizeof(insn[i]), "COP2 %x", src & 0x3f);
6671 #endif
6672             type = C2OP;
6673           }
6674         }
6675         else switch(op2)
6676         {
6677           case 0x00: set_mnemonic(i, "MFC2"); type=COP2; break;
6678           case 0x02: set_mnemonic(i, "CFC2"); type=COP2; break;
6679           case 0x04: set_mnemonic(i, "MTC2"); type=COP2; break;
6680           case 0x06: set_mnemonic(i, "CTC2"); type=COP2; break;
6681         }
6682         break;
6683       case 0x13: set_mnemonic(i, "COP3");
6684         op2 = (src >> 21) & 0x1f;
6685         break;
6686       case 0x20: set_mnemonic(i, "LB"); type=LOAD; ls_type = LS_8; break;
6687       case 0x21: set_mnemonic(i, "LH"); type=LOAD; ls_type = LS_16; break;
6688       case 0x22: set_mnemonic(i, "LWL"); type=LOADLR; ls_type = LS_LR; break;
6689       case 0x23: set_mnemonic(i, "LW"); type=LOAD; ls_type = LS_32; break;
6690       case 0x24: set_mnemonic(i, "LBU"); type=LOAD; ls_type = LS_8; break;
6691       case 0x25: set_mnemonic(i, "LHU"); type=LOAD; ls_type = LS_16; break;
6692       case 0x26: set_mnemonic(i, "LWR"); type=LOADLR; ls_type = LS_LR; break;
6693       case 0x28: set_mnemonic(i, "SB"); type=STORE; ls_type = LS_8; break;
6694       case 0x29: set_mnemonic(i, "SH"); type=STORE; ls_type = LS_16; break;
6695       case 0x2A: set_mnemonic(i, "SWL"); type=STORELR; ls_type = LS_LR; break;
6696       case 0x2B: set_mnemonic(i, "SW"); type=STORE; ls_type = LS_32; break;
6697       case 0x2E: set_mnemonic(i, "SWR"); type=STORELR; ls_type = LS_LR; break;
6698       case 0x32: set_mnemonic(i, "LWC2"); type=C2LS; ls_type = LS_32; break;
6699       case 0x3A: set_mnemonic(i, "SWC2"); type=C2LS; ls_type = LS_32; break;
6700       case 0x3B:
6701         if (Config.HLE && (src & 0x03ffffff) < ARRAY_SIZE(psxHLEt)) {
6702           set_mnemonic(i, "HLECALL");
6703           type = HLECALL;
6704         }
6705         break;
6706       default:
6707         break;
6708     }
6709     if (type == INTCALL)
6710       SysPrintf("NI %08x @%08x (%08x)\n", src, start + i*4, start);
6711     dops[i].itype = type;
6712     dops[i].opcode2 = op2;
6713     dops[i].ls_type = ls_type;
6714     /* Get registers/immediates */
6715     dops[i].use_lt1=0;
6716     gte_rs[i]=gte_rt[i]=0;
6717     dops[i].rs1 = 0;
6718     dops[i].rs2 = 0;
6719     dops[i].rt1 = 0;
6720     dops[i].rt2 = 0;
6721     switch(type) {
6722       case LOAD:
6723         dops[i].rs1 = (src >> 21) & 0x1f;
6724         dops[i].rt1 = (src >> 16) & 0x1f;
6725         cinfo[i].imm = (short)src;
6726         break;
6727       case STORE:
6728       case STORELR:
6729         dops[i].rs1 = (src >> 21) & 0x1f;
6730         dops[i].rs2 = (src >> 16) & 0x1f;
6731         cinfo[i].imm = (short)src;
6732         break;
6733       case LOADLR:
6734         // LWL/LWR only load part of the register,
6735         // therefore the target register must be treated as a source too
6736         dops[i].rs1 = (src >> 21) & 0x1f;
6737         dops[i].rs2 = (src >> 16) & 0x1f;
6738         dops[i].rt1 = (src >> 16) & 0x1f;
6739         cinfo[i].imm = (short)src;
6740         break;
6741       case IMM16:
6742         if (op==0x0f) dops[i].rs1=0; // LUI instruction has no source register
6743         else dops[i].rs1 = (src >> 21) & 0x1f;
6744         dops[i].rs2 = 0;
6745         dops[i].rt1 = (src >> 16) & 0x1f;
6746         if(op>=0x0c&&op<=0x0e) { // ANDI/ORI/XORI
6747           cinfo[i].imm = (unsigned short)src;
6748         }else{
6749           cinfo[i].imm = (short)src;
6750         }
6751         break;
6752       case UJUMP:
6753         // The JAL instruction writes to r31.
6754         if (op&1) {
6755           dops[i].rt1=31;
6756         }
6757         dops[i].rs2=CCREG;
6758         break;
6759       case RJUMP:
6760         dops[i].rs1 = (src >> 21) & 0x1f;
6761         // The JALR instruction writes to rd.
6762         if (op2&1) {
6763           dops[i].rt1 = (src >> 11) & 0x1f;
6764         }
6765         dops[i].rs2=CCREG;
6766         break;
6767       case CJUMP:
6768         dops[i].rs1 = (src >> 21) & 0x1f;
6769         dops[i].rs2 = (src >> 16) & 0x1f;
6770         if(op&2) { // BGTZ/BLEZ
6771           dops[i].rs2=0;
6772         }
6773         break;
6774       case SJUMP:
6775         dops[i].rs1 = (src >> 21) & 0x1f;
6776         dops[i].rs2 = CCREG;
6777         if (op2 == 0x10 || op2 == 0x11) { // BxxAL
6778           dops[i].rt1 = 31;
6779           // NOTE: If the branch is not taken, r31 is still overwritten
6780         }
6781         break;
6782       case ALU:
6783         dops[i].rs1=(src>>21)&0x1f; // source
6784         dops[i].rs2=(src>>16)&0x1f; // subtract amount
6785         dops[i].rt1=(src>>11)&0x1f; // destination
6786         break;
6787       case MULTDIV:
6788         dops[i].rs1=(src>>21)&0x1f; // source
6789         dops[i].rs2=(src>>16)&0x1f; // divisor
6790         dops[i].rt1=HIREG;
6791         dops[i].rt2=LOREG;
6792         break;
6793       case MOV:
6794         if(op2==0x10) dops[i].rs1=HIREG; // MFHI
6795         if(op2==0x11) dops[i].rt1=HIREG; // MTHI
6796         if(op2==0x12) dops[i].rs1=LOREG; // MFLO
6797         if(op2==0x13) dops[i].rt1=LOREG; // MTLO
6798         if((op2&0x1d)==0x10) dops[i].rt1=(src>>11)&0x1f; // MFxx
6799         if((op2&0x1d)==0x11) dops[i].rs1=(src>>21)&0x1f; // MTxx
6800         break;
6801       case SHIFT:
6802         dops[i].rs1=(src>>16)&0x1f; // target of shift
6803         dops[i].rs2=(src>>21)&0x1f; // shift amount
6804         dops[i].rt1=(src>>11)&0x1f; // destination
6805         break;
6806       case SHIFTIMM:
6807         dops[i].rs1=(src>>16)&0x1f;
6808         dops[i].rs2=0;
6809         dops[i].rt1=(src>>11)&0x1f;
6810         cinfo[i].imm=(src>>6)&0x1f;
6811         break;
6812       case COP0:
6813         if(op2==0) dops[i].rt1=(src>>16)&0x1F; // MFC0
6814         if(op2==4) dops[i].rs1=(src>>16)&0x1F; // MTC0
6815         if(op2==4&&((src>>11)&0x1e)==12) dops[i].rs2=CCREG;
6816         break;
6817       case COP2:
6818         if(op2<3) dops[i].rt1=(src>>16)&0x1F; // MFC2/CFC2
6819         if(op2>3) dops[i].rs1=(src>>16)&0x1F; // MTC2/CTC2
6820         int gr=(src>>11)&0x1F;
6821         switch(op2)
6822         {
6823           case 0x00: gte_rs[i]=1ll<<gr; break; // MFC2
6824           case 0x04: gte_rt[i]=1ll<<gr; break; // MTC2
6825           case 0x02: gte_rs[i]=1ll<<(gr+32); break; // CFC2
6826           case 0x06: gte_rt[i]=1ll<<(gr+32); break; // CTC2
6827         }
6828         break;
6829       case C2LS:
6830         dops[i].rs1=(src>>21)&0x1F;
6831         cinfo[i].imm=(short)src;
6832         if(op==0x32) gte_rt[i]=1ll<<((src>>16)&0x1F); // LWC2
6833         else gte_rs[i]=1ll<<((src>>16)&0x1F); // SWC2
6834         break;
6835       case C2OP:
6836         gte_rs[i]=gte_reg_reads[src&0x3f];
6837         gte_rt[i]=gte_reg_writes[src&0x3f];
6838         gte_rt[i]|=1ll<<63; // every op changes flags
6839         if((src&0x3f)==GTE_MVMVA) {
6840           int v = (src >> 15) & 3;
6841           gte_rs[i]&=~0xe3fll;
6842           if(v==3) gte_rs[i]|=0xe00ll;
6843           else gte_rs[i]|=3ll<<(v*2);
6844         }
6845         break;
6846       case SYSCALL:
6847       case HLECALL:
6848       case INTCALL:
6849         dops[i].rs1=CCREG;
6850         break;
6851       default:
6852         break;
6853     }
6854 }
6855
6856 static noinline void pass1_disassemble(u_int pagelimit)
6857 {
6858   int i, j, done = 0, ni_count = 0;
6859   int ds_next = 0;
6860
6861   for (i = 0; !done; i++)
6862   {
6863     int force_j_to_interpreter = 0;
6864     unsigned int type, op, op2;
6865
6866     disassemble_one(i, source[i]);
6867     dops[i].is_ds = ds_next; ds_next = 0;
6868     type = dops[i].itype;
6869     op = dops[i].opcode;
6870     op2 = dops[i].opcode2;
6871
6872     /* Calculate branch target addresses */
6873     if(type==UJUMP)
6874       cinfo[i].ba=((start+i*4+4)&0xF0000000)|(((unsigned int)source[i]<<6)>>4);
6875     else if(type==CJUMP&&dops[i].rs1==dops[i].rs2&&(op&1))
6876       cinfo[i].ba=start+i*4+8; // Ignore never taken branch
6877     else if(type==SJUMP&&dops[i].rs1==0&&!(op2&1))
6878       cinfo[i].ba=start+i*4+8; // Ignore never taken branch
6879     else if(type==CJUMP||type==SJUMP)
6880       cinfo[i].ba=start+i*4+4+((signed int)((unsigned int)source[i]<<16)>>14);
6881
6882     /* simplify always (not)taken branches */
6883     if (type == CJUMP && dops[i].rs1 == dops[i].rs2) {
6884       dops[i].rs1 = dops[i].rs2 = 0;
6885       if (!(op & 1)) {
6886         dops[i].itype = type = UJUMP;
6887         dops[i].rs2 = CCREG;
6888       }
6889     }
6890     else if (type == SJUMP && dops[i].rs1 == 0 && (op2 & 1))
6891       dops[i].itype = type = UJUMP;
6892
6893     dops[i].is_jump  = type == RJUMP || type == UJUMP || type == CJUMP || type == SJUMP;
6894     dops[i].is_ujump = type == RJUMP || type == UJUMP;
6895     dops[i].is_load  = type == LOAD || type == LOADLR || op == 0x32; // LWC2
6896     dops[i].is_delay_load = (dops[i].is_load || (source[i] & 0xf3d00000) == 0x40000000); // MFC/CFC
6897     dops[i].is_store = type == STORE || type == STORELR || op == 0x3a; // SWC2
6898     dops[i].is_exception = type == SYSCALL || type == HLECALL || type == INTCALL;
6899     dops[i].may_except = dops[i].is_exception || (type == ALU && (op2 == 0x20 || op2 == 0x22)) || op == 8;
6900     ds_next = dops[i].is_jump;
6901
6902     if (((op & 0x37) == 0x21 || op == 0x25) // LH/SH/LHU
6903         && ((cinfo[i].imm & 1) || Config.PreciseExceptions))
6904       dops[i].may_except = 1;
6905     if (((op & 0x37) == 0x23 || (op & 0x37) == 0x32) // LW/SW/LWC2/SWC2
6906         && ((cinfo[i].imm & 3) || Config.PreciseExceptions))
6907       dops[i].may_except = 1;
6908
6909     /* rare messy cases to just pass over to the interpreter */
6910     if (i > 0 && dops[i-1].is_jump) {
6911       j = i - 1;
6912       // branch in delay slot?
6913       if (dops[i].is_jump) {
6914         // don't handle first branch and call interpreter if it's hit
6915         SysPrintf("branch in DS @%08x (%08x)\n", start + i*4, start);
6916         force_j_to_interpreter = 1;
6917       }
6918       // load delay detection through a branch
6919       else if (dops[i].is_delay_load && dops[i].rt1 != 0) {
6920         const struct decoded_insn *dop = NULL;
6921         int t = -1;
6922         if (cinfo[i-1].ba != -1) {
6923           t = (cinfo[i-1].ba - start) / 4;
6924           if (t < 0 || t > i) {
6925             u_int limit = 0;
6926             u_int *mem = get_source_start(cinfo[i-1].ba, &limit);
6927             if (mem != NULL) {
6928               disassemble_one(MAXBLOCK - 1, mem[0]);
6929               dop = &dops[MAXBLOCK - 1];
6930             }
6931           }
6932           else
6933             dop = &dops[t];
6934         }
6935         if ((dop && is_ld_use_hazard(dops[i].rt1, dop))
6936             || (!dop && Config.PreciseExceptions)) {
6937           // jump target wants DS result - potential load delay effect
6938           SysPrintf("load delay in DS @%08x (%08x)\n", start + i*4, start);
6939           force_j_to_interpreter = 1;
6940           if (0 <= t && t < i)
6941             dops[t + 1].bt = 1; // expected return from interpreter
6942         }
6943         else if(i>=2&&dops[i-2].rt1==2&&dops[i].rt1==2&&dops[i].rs1!=2&&dops[i].rs2!=2&&dops[i-1].rs1!=2&&dops[i-1].rs2!=2&&
6944               !(i>=3&&dops[i-3].is_jump)) {
6945           // v0 overwrite like this is a sign of trouble, bail out
6946           SysPrintf("v0 overwrite @%08x (%08x)\n", start + i*4, start);
6947           force_j_to_interpreter = 1;
6948         }
6949       }
6950     }
6951     else if (i > 0 && dops[i-1].is_delay_load
6952              && is_ld_use_hazard(dops[i-1].rt1, &dops[i])
6953              && (i < 2 || !dops[i-2].is_ujump)) {
6954       SysPrintf("load delay @%08x (%08x)\n", start + i*4, start);
6955       for (j = i - 1; j > 0 && dops[j-1].is_delay_load; j--)
6956         if (dops[j-1].rt1 != dops[i-1].rt1)
6957           break;
6958       force_j_to_interpreter = 1;
6959     }
6960     if (force_j_to_interpreter) {
6961       force_intcall(j);
6962       done = 2;
6963       i = j; // don't compile the problematic branch/load/etc
6964     }
6965     if (dops[i].is_exception && i > 0 && dops[i-1].is_jump) {
6966       SysPrintf("exception in DS @%08x (%08x)\n", start + i*4, start);
6967       i--;
6968       force_intcall(i);
6969       done = 2;
6970     }
6971     if (i >= 2 && (source[i-2] & 0xffe0f800) == 0x40806000) // MTC0 $12
6972       dops[i].bt = 1;
6973     if (i >= 1 && (source[i-1] & 0xffe0f800) == 0x40806800) // MTC0 $13
6974       dops[i].bt = 1;
6975
6976     /* Is this the end of the block? */
6977     if (i > 0 && dops[i-1].is_ujump) {
6978       if (dops[i-1].rt1 == 0) { // not jal
6979         int found_bbranch = 0, t = (cinfo[i-1].ba - start) / 4;
6980         if ((u_int)(t - i) < 64 && start + (t+64)*4 < pagelimit) {
6981           // scan for a branch back to i+1
6982           for (j = t; j < t + 64; j++) {
6983             int tmpop = source[j] >> 26;
6984             if (tmpop == 1 || ((tmpop & ~3) == 4)) {
6985               int t2 = j + 1 + (int)(signed short)source[j];
6986               if (t2 == i + 1) {
6987                 //printf("blk expand %08x<-%08x\n", start + (i+1)*4, start + j*4);
6988                 found_bbranch = 1;
6989                 break;
6990               }
6991             }
6992           }
6993         }
6994         if (!found_bbranch)
6995           done = 2;
6996       }
6997       else {
6998         if(stop_after_jal) done=1;
6999         // Stop on BREAK
7000         if((source[i+1]&0xfc00003f)==0x0d) done=1;
7001       }
7002       // Don't recompile stuff that's already compiled
7003       if(check_addr(start+i*4+4)) done=1;
7004       // Don't get too close to the limit
7005       if (i > MAXBLOCK - 64)
7006         done = 1;
7007     }
7008     if (dops[i].itype == HLECALL)
7009       done = 1;
7010     else if (dops[i].itype == INTCALL)
7011       done = 2;
7012     else if (dops[i].is_exception)
7013       done = stop_after_jal ? 1 : 2;
7014     if (done == 2) {
7015       // Does the block continue due to a branch?
7016       for(j=i-1;j>=0;j--)
7017       {
7018         if(cinfo[j].ba==start+i*4) done=j=0; // Branch into delay slot
7019         if(cinfo[j].ba==start+i*4+4) done=j=0;
7020         if(cinfo[j].ba==start+i*4+8) done=j=0;
7021       }
7022     }
7023     //assert(i<MAXBLOCK-1);
7024     if(start+i*4==pagelimit-4) done=1;
7025     assert(start+i*4<pagelimit);
7026     if (i == MAXBLOCK - 2)
7027       done = 1;
7028     // Stop if we're compiling junk
7029     if (dops[i].itype == INTCALL && (++ni_count > 8 || dops[i].opcode == 0x11)) {
7030       done=stop_after_jal=1;
7031       SysPrintf("Disabled speculative precompilation\n");
7032     }
7033   }
7034   while (i > 0 && dops[i-1].is_jump)
7035     i--;
7036   assert(i > 0);
7037   assert(!dops[i-1].is_jump);
7038   slen = i;
7039 }
7040
7041 // Basic liveness analysis for MIPS registers
7042 static noinline void pass2_unneeded_regs(int istart,int iend,int r)
7043 {
7044   int i;
7045   uint64_t u,gte_u,b,gte_b;
7046   uint64_t temp_u,temp_gte_u=0;
7047   uint64_t gte_u_unknown=0;
7048   if (HACK_ENABLED(NDHACK_GTE_UNNEEDED))
7049     gte_u_unknown=~0ll;
7050   if(iend==slen-1) {
7051     u=1;
7052     gte_u=gte_u_unknown;
7053   }else{
7054     //u=unneeded_reg[iend+1];
7055     u=1;
7056     gte_u=gte_unneeded[iend+1];
7057   }
7058
7059   for (i=iend;i>=istart;i--)
7060   {
7061     //printf("unneeded registers i=%d (%d,%d) r=%d\n",i,istart,iend,r);
7062     if(dops[i].is_jump)
7063     {
7064       // If subroutine call, flag return address as a possible branch target
7065       if(dops[i].rt1==31 && i<slen-2) dops[i+2].bt=1;
7066
7067       if(cinfo[i].ba<start || cinfo[i].ba>=(start+slen*4))
7068       {
7069         // Branch out of this block, flush all regs
7070         u=1;
7071         gte_u=gte_u_unknown;
7072         branch_unneeded_reg[i]=u;
7073         // Merge in delay slot
7074         u|=(1LL<<dops[i+1].rt1)|(1LL<<dops[i+1].rt2);
7075         u&=~((1LL<<dops[i+1].rs1)|(1LL<<dops[i+1].rs2));
7076         u|=1;
7077         gte_u|=gte_rt[i+1];
7078         gte_u&=~gte_rs[i+1];
7079       }
7080       else
7081       {
7082         // Internal branch, flag target
7083         dops[(cinfo[i].ba-start)>>2].bt=1;
7084         if(cinfo[i].ba<=start+i*4) {
7085           // Backward branch
7086           if(dops[i].is_ujump)
7087           {
7088             // Unconditional branch
7089             temp_u=1;
7090             temp_gte_u=0;
7091           } else {
7092             // Conditional branch (not taken case)
7093             temp_u=unneeded_reg[i+2];
7094             temp_gte_u&=gte_unneeded[i+2];
7095           }
7096           // Merge in delay slot
7097           temp_u|=(1LL<<dops[i+1].rt1)|(1LL<<dops[i+1].rt2);
7098           temp_u&=~((1LL<<dops[i+1].rs1)|(1LL<<dops[i+1].rs2));
7099           temp_u|=1;
7100           temp_gte_u|=gte_rt[i+1];
7101           temp_gte_u&=~gte_rs[i+1];
7102           temp_u|=(1LL<<dops[i].rt1)|(1LL<<dops[i].rt2);
7103           temp_u&=~((1LL<<dops[i].rs1)|(1LL<<dops[i].rs2));
7104           temp_u|=1;
7105           temp_gte_u|=gte_rt[i];
7106           temp_gte_u&=~gte_rs[i];
7107           unneeded_reg[i]=temp_u;
7108           gte_unneeded[i]=temp_gte_u;
7109           // Only go three levels deep.  This recursion can take an
7110           // excessive amount of time if there are a lot of nested loops.
7111           if(r<2) {
7112             pass2_unneeded_regs((cinfo[i].ba-start)>>2,i-1,r+1);
7113           }else{
7114             unneeded_reg[(cinfo[i].ba-start)>>2]=1;
7115             gte_unneeded[(cinfo[i].ba-start)>>2]=gte_u_unknown;
7116           }
7117         } /*else*/ if(1) {
7118           if (dops[i].is_ujump)
7119           {
7120             // Unconditional branch
7121             u=unneeded_reg[(cinfo[i].ba-start)>>2];
7122             gte_u=gte_unneeded[(cinfo[i].ba-start)>>2];
7123             branch_unneeded_reg[i]=u;
7124             // Merge in delay slot
7125             u|=(1LL<<dops[i+1].rt1)|(1LL<<dops[i+1].rt2);
7126             u&=~((1LL<<dops[i+1].rs1)|(1LL<<dops[i+1].rs2));
7127             u|=1;
7128             gte_u|=gte_rt[i+1];
7129             gte_u&=~gte_rs[i+1];
7130           } else {
7131             // Conditional branch
7132             b=unneeded_reg[(cinfo[i].ba-start)>>2];
7133             gte_b=gte_unneeded[(cinfo[i].ba-start)>>2];
7134             branch_unneeded_reg[i]=b;
7135             // Branch delay slot
7136             b|=(1LL<<dops[i+1].rt1)|(1LL<<dops[i+1].rt2);
7137             b&=~((1LL<<dops[i+1].rs1)|(1LL<<dops[i+1].rs2));
7138             b|=1;
7139             gte_b|=gte_rt[i+1];
7140             gte_b&=~gte_rs[i+1];
7141             u&=b;
7142             gte_u&=gte_b;
7143             if(i<slen-1) {
7144               branch_unneeded_reg[i]&=unneeded_reg[i+2];
7145             } else {
7146               branch_unneeded_reg[i]=1;
7147             }
7148           }
7149         }
7150       }
7151     }
7152     //u=1; // DEBUG
7153     // Written registers are unneeded
7154     u|=1LL<<dops[i].rt1;
7155     u|=1LL<<dops[i].rt2;
7156     gte_u|=gte_rt[i];
7157     // Accessed registers are needed
7158     u&=~(1LL<<dops[i].rs1);
7159     u&=~(1LL<<dops[i].rs2);
7160     gte_u&=~gte_rs[i];
7161     if(gte_rs[i]&&dops[i].rt1&&(unneeded_reg[i+1]&(1ll<<dops[i].rt1)))
7162       gte_u|=gte_rs[i]&gte_unneeded[i+1]; // MFC2/CFC2 to dead register, unneeded
7163     if (dops[i].may_except || dops[i].itype == RFE)
7164     {
7165       // SYSCALL instruction, etc or conditional exception
7166       u=1;
7167     }
7168     // Source-target dependencies
7169     // R0 is always unneeded
7170     u|=1;
7171     // Save it
7172     unneeded_reg[i]=u;
7173     gte_unneeded[i]=gte_u;
7174     /*
7175     printf("ur (%d,%d) %x: ",istart,iend,start+i*4);
7176     printf("U:");
7177     int r;
7178     for(r=1;r<=CCREG;r++) {
7179       if((unneeded_reg[i]>>r)&1) {
7180         if(r==HIREG) printf(" HI");
7181         else if(r==LOREG) printf(" LO");
7182         else printf(" r%d",r);
7183       }
7184     }
7185     printf("\n");
7186     */
7187   }
7188 }
7189
7190 static noinline void pass2a_unneeded_other(void)
7191 {
7192   int i, j;
7193   for (i = 0; i < slen; i++)
7194   {
7195     // remove redundant alignment checks
7196     if (dops[i].may_except && (dops[i].is_load || dops[i].is_store)
7197         && dops[i].rt1 != dops[i].rs1 && !dops[i].is_ds)
7198     {
7199       int base = dops[i].rs1, lsb = cinfo[i].imm, ls_type = dops[i].ls_type;
7200       int mask = ls_type == LS_32 ? 3 : 1;
7201       lsb &= mask;
7202       for (j = i + 1; j < slen; j++) {
7203         if (dops[j].bt || dops[j].is_jump)
7204           break;
7205         if ((dops[j].is_load || dops[j].is_store) && dops[j].rs1 == base
7206             && dops[j].ls_type == ls_type && (cinfo[j].imm & mask) == lsb)
7207           dops[j].may_except = 0;
7208         if (dops[j].rt1 == base)
7209           break;
7210       }
7211     }
7212   }
7213 }
7214
7215 static noinline void pass3_register_alloc(u_int addr)
7216 {
7217   struct regstat current; // Current register allocations/status
7218   clear_all_regs(current.regmap_entry);
7219   clear_all_regs(current.regmap);
7220   current.wasdirty = current.dirty = 0;
7221   current.u = unneeded_reg[0];
7222   alloc_reg(&current, 0, CCREG);
7223   dirty_reg(&current, CCREG);
7224   current.wasconst = 0;
7225   current.isconst = 0;
7226   current.loadedconst = 0;
7227   current.noevict = 0;
7228   //current.waswritten = 0;
7229   int ds=0;
7230   int cc=0;
7231   int hr;
7232   int i, j;
7233
7234   if (addr & 1) {
7235     // First instruction is delay slot
7236     cc=-1;
7237     dops[1].bt=1;
7238     ds=1;
7239     unneeded_reg[0]=1;
7240   }
7241
7242   for(i=0;i<slen;i++)
7243   {
7244     if(dops[i].bt)
7245     {
7246       for(hr=0;hr<HOST_REGS;hr++)
7247       {
7248         // Is this really necessary?
7249         if(current.regmap[hr]==0) current.regmap[hr]=-1;
7250       }
7251       current.isconst=0;
7252       //current.waswritten=0;
7253     }
7254
7255     memcpy(regmap_pre[i],current.regmap,sizeof(current.regmap));
7256     regs[i].wasconst=current.isconst;
7257     regs[i].wasdirty=current.dirty;
7258     regs[i].dirty=0;
7259     regs[i].u=0;
7260     regs[i].isconst=0;
7261     regs[i].loadedconst=0;
7262     if (!dops[i].is_jump) {
7263       if(i+1<slen) {
7264         current.u=unneeded_reg[i+1]&~((1LL<<dops[i].rs1)|(1LL<<dops[i].rs2));
7265         current.u|=1;
7266       } else {
7267         current.u=1;
7268       }
7269     } else {
7270       if(i+1<slen) {
7271         current.u=branch_unneeded_reg[i]&~((1LL<<dops[i+1].rs1)|(1LL<<dops[i+1].rs2));
7272         current.u&=~((1LL<<dops[i].rs1)|(1LL<<dops[i].rs2));
7273         current.u|=1;
7274       } else {
7275         SysPrintf("oops, branch at end of block with no delay slot @%08x\n", start + i*4);
7276         abort();
7277       }
7278     }
7279     assert(dops[i].is_ds == ds);
7280     if(ds) {
7281       ds=0; // Skip delay slot, already allocated as part of branch
7282       // ...but we need to alloc it in case something jumps here
7283       if(i+1<slen) {
7284         current.u=branch_unneeded_reg[i-1]&unneeded_reg[i+1];
7285       }else{
7286         current.u=branch_unneeded_reg[i-1];
7287       }
7288       current.u&=~((1LL<<dops[i].rs1)|(1LL<<dops[i].rs2));
7289       current.u|=1;
7290       struct regstat temp;
7291       memcpy(&temp,&current,sizeof(current));
7292       temp.wasdirty=temp.dirty;
7293       // TODO: Take into account unconditional branches, as below
7294       delayslot_alloc(&temp,i);
7295       memcpy(regs[i].regmap,temp.regmap,sizeof(temp.regmap));
7296       regs[i].wasdirty=temp.wasdirty;
7297       regs[i].dirty=temp.dirty;
7298       regs[i].isconst=0;
7299       regs[i].wasconst=0;
7300       current.isconst=0;
7301       // Create entry (branch target) regmap
7302       for(hr=0;hr<HOST_REGS;hr++)
7303       {
7304         int r=temp.regmap[hr];
7305         if(r>=0) {
7306           if(r!=regmap_pre[i][hr]) {
7307             regs[i].regmap_entry[hr]=-1;
7308           }
7309           else
7310           {
7311               assert(r < 64);
7312               if((current.u>>r)&1) {
7313                 regs[i].regmap_entry[hr]=-1;
7314                 regs[i].regmap[hr]=-1;
7315                 //Don't clear regs in the delay slot as the branch might need them
7316                 //current.regmap[hr]=-1;
7317               }else
7318                 regs[i].regmap_entry[hr]=r;
7319           }
7320         } else {
7321           // First instruction expects CCREG to be allocated
7322           if(i==0&&hr==HOST_CCREG)
7323             regs[i].regmap_entry[hr]=CCREG;
7324           else
7325             regs[i].regmap_entry[hr]=-1;
7326         }
7327       }
7328     }
7329     else { // Not delay slot
7330       current.noevict = 0;
7331       switch(dops[i].itype) {
7332         case UJUMP:
7333           //current.isconst=0; // DEBUG
7334           //current.wasconst=0; // DEBUG
7335           //regs[i].wasconst=0; // DEBUG
7336           clear_const(&current,dops[i].rt1);
7337           alloc_cc(&current,i);
7338           dirty_reg(&current,CCREG);
7339           if (dops[i].rt1==31) {
7340             alloc_reg(&current,i,31);
7341             dirty_reg(&current,31);
7342             //assert(dops[i+1].rs1!=31&&dops[i+1].rs2!=31);
7343             //assert(dops[i+1].rt1!=dops[i].rt1);
7344             #ifdef REG_PREFETCH
7345             alloc_reg(&current,i,PTEMP);
7346             #endif
7347           }
7348           dops[i].ooo=1;
7349           delayslot_alloc(&current,i+1);
7350           //current.isconst=0; // DEBUG
7351           ds=1;
7352           break;
7353         case RJUMP:
7354           //current.isconst=0;
7355           //current.wasconst=0;
7356           //regs[i].wasconst=0;
7357           clear_const(&current,dops[i].rs1);
7358           clear_const(&current,dops[i].rt1);
7359           alloc_cc(&current,i);
7360           dirty_reg(&current,CCREG);
7361           if (!ds_writes_rjump_rs(i)) {
7362             alloc_reg(&current,i,dops[i].rs1);
7363             if (dops[i].rt1!=0) {
7364               alloc_reg(&current,i,dops[i].rt1);
7365               dirty_reg(&current,dops[i].rt1);
7366               #ifdef REG_PREFETCH
7367               alloc_reg(&current,i,PTEMP);
7368               #endif
7369             }
7370             #ifdef USE_MINI_HT
7371             if(dops[i].rs1==31) { // JALR
7372               alloc_reg(&current,i,RHASH);
7373               alloc_reg(&current,i,RHTBL);
7374             }
7375             #endif
7376             delayslot_alloc(&current,i+1);
7377           } else {
7378             // The delay slot overwrites our source register,
7379             // allocate a temporary register to hold the old value.
7380             current.isconst=0;
7381             current.wasconst=0;
7382             regs[i].wasconst=0;
7383             delayslot_alloc(&current,i+1);
7384             current.isconst=0;
7385             alloc_reg(&current,i,RTEMP);
7386           }
7387           //current.isconst=0; // DEBUG
7388           dops[i].ooo=1;
7389           ds=1;
7390           break;
7391         case CJUMP:
7392           //current.isconst=0;
7393           //current.wasconst=0;
7394           //regs[i].wasconst=0;
7395           clear_const(&current,dops[i].rs1);
7396           clear_const(&current,dops[i].rs2);
7397           if((dops[i].opcode&0x3E)==4) // BEQ/BNE
7398           {
7399             alloc_cc(&current,i);
7400             dirty_reg(&current,CCREG);
7401             if(dops[i].rs1) alloc_reg(&current,i,dops[i].rs1);
7402             if(dops[i].rs2) alloc_reg(&current,i,dops[i].rs2);
7403             if((dops[i].rs1&&(dops[i].rs1==dops[i+1].rt1||dops[i].rs1==dops[i+1].rt2))||
7404                (dops[i].rs2&&(dops[i].rs2==dops[i+1].rt1||dops[i].rs2==dops[i+1].rt2))) {
7405               // The delay slot overwrites one of our conditions.
7406               // Allocate the branch condition registers instead.
7407               current.isconst=0;
7408               current.wasconst=0;
7409               regs[i].wasconst=0;
7410               if(dops[i].rs1) alloc_reg(&current,i,dops[i].rs1);
7411               if(dops[i].rs2) alloc_reg(&current,i,dops[i].rs2);
7412             }
7413             else
7414             {
7415               dops[i].ooo=1;
7416               delayslot_alloc(&current,i+1);
7417             }
7418           }
7419           else
7420           if((dops[i].opcode&0x3E)==6) // BLEZ/BGTZ
7421           {
7422             alloc_cc(&current,i);
7423             dirty_reg(&current,CCREG);
7424             alloc_reg(&current,i,dops[i].rs1);
7425             if(dops[i].rs1&&(dops[i].rs1==dops[i+1].rt1||dops[i].rs1==dops[i+1].rt2)) {
7426               // The delay slot overwrites one of our conditions.
7427               // Allocate the branch condition registers instead.
7428               current.isconst=0;
7429               current.wasconst=0;
7430               regs[i].wasconst=0;
7431               if(dops[i].rs1) alloc_reg(&current,i,dops[i].rs1);
7432             }
7433             else
7434             {
7435               dops[i].ooo=1;
7436               delayslot_alloc(&current,i+1);
7437             }
7438           }
7439           else
7440           // Don't alloc the delay slot yet because we might not execute it
7441           if((dops[i].opcode&0x3E)==0x14) // BEQL/BNEL
7442           {
7443             current.isconst=0;
7444             current.wasconst=0;
7445             regs[i].wasconst=0;
7446             alloc_cc(&current,i);
7447             dirty_reg(&current,CCREG);
7448             alloc_reg(&current,i,dops[i].rs1);
7449             alloc_reg(&current,i,dops[i].rs2);
7450           }
7451           else
7452           if((dops[i].opcode&0x3E)==0x16) // BLEZL/BGTZL
7453           {
7454             current.isconst=0;
7455             current.wasconst=0;
7456             regs[i].wasconst=0;
7457             alloc_cc(&current,i);
7458             dirty_reg(&current,CCREG);
7459             alloc_reg(&current,i,dops[i].rs1);
7460           }
7461           ds=1;
7462           //current.isconst=0;
7463           break;
7464         case SJUMP:
7465           clear_const(&current,dops[i].rs1);
7466           clear_const(&current,dops[i].rt1);
7467           {
7468             alloc_cc(&current,i);
7469             dirty_reg(&current,CCREG);
7470             alloc_reg(&current,i,dops[i].rs1);
7471             if (dops[i].rt1 == 31) { // BLTZAL/BGEZAL
7472               alloc_reg(&current,i,31);
7473               dirty_reg(&current,31);
7474             }
7475             if ((dops[i].rs1 &&
7476                  (dops[i].rs1==dops[i+1].rt1||dops[i].rs1==dops[i+1].rt2)) // The delay slot overwrites the branch condition.
7477                ||(dops[i].rt1 == 31 && dops[i].rs1 == 31) // overwrites it's own condition
7478                ||(dops[i].rt1==31&&(dops[i+1].rs1==31||dops[i+1].rs2==31||dops[i+1].rt1==31||dops[i+1].rt2==31))) { // DS touches $ra
7479               // Allocate the branch condition registers instead.
7480               current.isconst=0;
7481               current.wasconst=0;
7482               regs[i].wasconst=0;
7483               if(dops[i].rs1) alloc_reg(&current,i,dops[i].rs1);
7484             }
7485             else
7486             {
7487               dops[i].ooo=1;
7488               delayslot_alloc(&current,i+1);
7489             }
7490           }
7491           ds=1;
7492           //current.isconst=0;
7493           break;
7494         case IMM16:
7495           imm16_alloc(&current,i);
7496           break;
7497         case LOAD:
7498         case LOADLR:
7499           load_alloc(&current,i);
7500           break;
7501         case STORE:
7502         case STORELR:
7503           store_alloc(&current,i);
7504           break;
7505         case ALU:
7506           alu_alloc(&current,i);
7507           break;
7508         case SHIFT:
7509           shift_alloc(&current,i);
7510           break;
7511         case MULTDIV:
7512           multdiv_alloc(&current,i);
7513           break;
7514         case SHIFTIMM:
7515           shiftimm_alloc(&current,i);
7516           break;
7517         case MOV:
7518           mov_alloc(&current,i);
7519           break;
7520         case COP0:
7521           cop0_alloc(&current,i);
7522           break;
7523         case RFE:
7524           rfe_alloc(&current,i);
7525           break;
7526         case COP2:
7527           cop2_alloc(&current,i);
7528           break;
7529         case C2LS:
7530           c2ls_alloc(&current,i);
7531           break;
7532         case C2OP:
7533           c2op_alloc(&current,i);
7534           break;
7535         case SYSCALL:
7536         case HLECALL:
7537         case INTCALL:
7538           syscall_alloc(&current,i);
7539           break;
7540       }
7541
7542       // Create entry (branch target) regmap
7543       for(hr=0;hr<HOST_REGS;hr++)
7544       {
7545         int r,or;
7546         r=current.regmap[hr];
7547         if(r>=0) {
7548           if(r!=regmap_pre[i][hr]) {
7549             // TODO: delay slot (?)
7550             or=get_reg(regmap_pre[i],r); // Get old mapping for this register
7551             if(or<0||r>=TEMPREG){
7552               regs[i].regmap_entry[hr]=-1;
7553             }
7554             else
7555             {
7556               // Just move it to a different register
7557               regs[i].regmap_entry[hr]=r;
7558               // If it was dirty before, it's still dirty
7559               if((regs[i].wasdirty>>or)&1) dirty_reg(&current,r);
7560             }
7561           }
7562           else
7563           {
7564             // Unneeded
7565             if(r==0){
7566               regs[i].regmap_entry[hr]=0;
7567             }
7568             else
7569             {
7570               assert(r<64);
7571               if((current.u>>r)&1) {
7572                 regs[i].regmap_entry[hr]=-1;
7573                 //regs[i].regmap[hr]=-1;
7574                 current.regmap[hr]=-1;
7575               }else
7576                 regs[i].regmap_entry[hr]=r;
7577             }
7578           }
7579         } else {
7580           // Branches expect CCREG to be allocated at the target
7581           if(regmap_pre[i][hr]==CCREG)
7582             regs[i].regmap_entry[hr]=CCREG;
7583           else
7584             regs[i].regmap_entry[hr]=-1;
7585         }
7586       }
7587       memcpy(regs[i].regmap,current.regmap,sizeof(current.regmap));
7588     }
7589
7590 #if 0 // see do_store_smc_check()
7591     if(i>0&&(dops[i-1].itype==STORE||dops[i-1].itype==STORELR||(dops[i-1].itype==C2LS&&dops[i-1].opcode==0x3a))&&(u_int)cinfo[i-1].imm<0x800)
7592       current.waswritten|=1<<dops[i-1].rs1;
7593     current.waswritten&=~(1<<dops[i].rt1);
7594     current.waswritten&=~(1<<dops[i].rt2);
7595     if((dops[i].itype==STORE||dops[i].itype==STORELR||(dops[i].itype==C2LS&&dops[i].opcode==0x3a))&&(u_int)cinfo[i].imm>=0x800)
7596       current.waswritten&=~(1<<dops[i].rs1);
7597 #endif
7598
7599     /* Branch post-alloc */
7600     if(i>0)
7601     {
7602       current.wasdirty=current.dirty;
7603       switch(dops[i-1].itype) {
7604         case UJUMP:
7605           memcpy(&branch_regs[i-1],&current,sizeof(current));
7606           branch_regs[i-1].isconst=0;
7607           branch_regs[i-1].wasconst=0;
7608           branch_regs[i-1].u=branch_unneeded_reg[i-1]&~((1LL<<dops[i-1].rs1)|(1LL<<dops[i-1].rs2));
7609           alloc_cc(&branch_regs[i-1],i-1);
7610           dirty_reg(&branch_regs[i-1],CCREG);
7611           if(dops[i-1].rt1==31) { // JAL
7612             alloc_reg(&branch_regs[i-1],i-1,31);
7613             dirty_reg(&branch_regs[i-1],31);
7614           }
7615           memcpy(&branch_regs[i-1].regmap_entry,&branch_regs[i-1].regmap,sizeof(current.regmap));
7616           memcpy(constmap[i],constmap[i-1],sizeof(constmap[i]));
7617           break;
7618         case RJUMP:
7619           memcpy(&branch_regs[i-1],&current,sizeof(current));
7620           branch_regs[i-1].isconst=0;
7621           branch_regs[i-1].wasconst=0;
7622           branch_regs[i-1].u=branch_unneeded_reg[i-1]&~((1LL<<dops[i-1].rs1)|(1LL<<dops[i-1].rs2));
7623           alloc_cc(&branch_regs[i-1],i-1);
7624           dirty_reg(&branch_regs[i-1],CCREG);
7625           alloc_reg(&branch_regs[i-1],i-1,dops[i-1].rs1);
7626           if(dops[i-1].rt1!=0) { // JALR
7627             alloc_reg(&branch_regs[i-1],i-1,dops[i-1].rt1);
7628             dirty_reg(&branch_regs[i-1],dops[i-1].rt1);
7629           }
7630           #ifdef USE_MINI_HT
7631           if(dops[i-1].rs1==31) { // JALR
7632             alloc_reg(&branch_regs[i-1],i-1,RHASH);
7633             alloc_reg(&branch_regs[i-1],i-1,RHTBL);
7634           }
7635           #endif
7636           memcpy(&branch_regs[i-1].regmap_entry,&branch_regs[i-1].regmap,sizeof(current.regmap));
7637           memcpy(constmap[i],constmap[i-1],sizeof(constmap[i]));
7638           break;
7639         case CJUMP:
7640           if((dops[i-1].opcode&0x3E)==4) // BEQ/BNE
7641           {
7642             alloc_cc(&current,i-1);
7643             dirty_reg(&current,CCREG);
7644             if((dops[i-1].rs1&&(dops[i-1].rs1==dops[i].rt1||dops[i-1].rs1==dops[i].rt2))||
7645                (dops[i-1].rs2&&(dops[i-1].rs2==dops[i].rt1||dops[i-1].rs2==dops[i].rt2))) {
7646               // The delay slot overwrote one of our conditions
7647               // Delay slot goes after the test (in order)
7648               current.u=branch_unneeded_reg[i-1]&~((1LL<<dops[i].rs1)|(1LL<<dops[i].rs2));
7649               current.u|=1;
7650               delayslot_alloc(&current,i);
7651               current.isconst=0;
7652             }
7653             else
7654             {
7655               current.u=branch_unneeded_reg[i-1]&~((1LL<<dops[i-1].rs1)|(1LL<<dops[i-1].rs2));
7656               // Alloc the branch condition registers
7657               if(dops[i-1].rs1) alloc_reg(&current,i-1,dops[i-1].rs1);
7658               if(dops[i-1].rs2) alloc_reg(&current,i-1,dops[i-1].rs2);
7659             }
7660             memcpy(&branch_regs[i-1],&current,sizeof(current));
7661             branch_regs[i-1].isconst=0;
7662             branch_regs[i-1].wasconst=0;
7663             memcpy(&branch_regs[i-1].regmap_entry,&current.regmap,sizeof(current.regmap));
7664             memcpy(constmap[i],constmap[i-1],sizeof(constmap[i]));
7665           }
7666           else
7667           if((dops[i-1].opcode&0x3E)==6) // BLEZ/BGTZ
7668           {
7669             alloc_cc(&current,i-1);
7670             dirty_reg(&current,CCREG);
7671             if(dops[i-1].rs1==dops[i].rt1||dops[i-1].rs1==dops[i].rt2) {
7672               // The delay slot overwrote the branch condition
7673               // Delay slot goes after the test (in order)
7674               current.u=branch_unneeded_reg[i-1]&~((1LL<<dops[i].rs1)|(1LL<<dops[i].rs2));
7675               current.u|=1;
7676               delayslot_alloc(&current,i);
7677               current.isconst=0;
7678             }
7679             else
7680             {
7681               current.u=branch_unneeded_reg[i-1]&~(1LL<<dops[i-1].rs1);
7682               // Alloc the branch condition register
7683               alloc_reg(&current,i-1,dops[i-1].rs1);
7684             }
7685             memcpy(&branch_regs[i-1],&current,sizeof(current));
7686             branch_regs[i-1].isconst=0;
7687             branch_regs[i-1].wasconst=0;
7688             memcpy(&branch_regs[i-1].regmap_entry,&current.regmap,sizeof(current.regmap));
7689             memcpy(constmap[i],constmap[i-1],sizeof(constmap[i]));
7690           }
7691           break;
7692         case SJUMP:
7693           {
7694             alloc_cc(&current,i-1);
7695             dirty_reg(&current,CCREG);
7696             if(dops[i-1].rs1==dops[i].rt1||dops[i-1].rs1==dops[i].rt2) {
7697               // The delay slot overwrote the branch condition
7698               // Delay slot goes after the test (in order)
7699               current.u=branch_unneeded_reg[i-1]&~((1LL<<dops[i].rs1)|(1LL<<dops[i].rs2));
7700               current.u|=1;
7701               delayslot_alloc(&current,i);
7702               current.isconst=0;
7703             }
7704             else
7705             {
7706               current.u=branch_unneeded_reg[i-1]&~(1LL<<dops[i-1].rs1);
7707               // Alloc the branch condition register
7708               alloc_reg(&current,i-1,dops[i-1].rs1);
7709             }
7710             memcpy(&branch_regs[i-1],&current,sizeof(current));
7711             branch_regs[i-1].isconst=0;
7712             branch_regs[i-1].wasconst=0;
7713             memcpy(&branch_regs[i-1].regmap_entry,&current.regmap,sizeof(current.regmap));
7714             memcpy(constmap[i],constmap[i-1],sizeof(constmap[i]));
7715           }
7716           break;
7717       }
7718
7719       if (dops[i-1].is_ujump)
7720       {
7721         if(dops[i-1].rt1==31) // JAL/JALR
7722         {
7723           // Subroutine call will return here, don't alloc any registers
7724           current.dirty=0;
7725           clear_all_regs(current.regmap);
7726           alloc_reg(&current,i,CCREG);
7727           dirty_reg(&current,CCREG);
7728         }
7729         else if(i+1<slen)
7730         {
7731           // Internal branch will jump here, match registers to caller
7732           current.dirty=0;
7733           clear_all_regs(current.regmap);
7734           alloc_reg(&current,i,CCREG);
7735           dirty_reg(&current,CCREG);
7736           for(j=i-1;j>=0;j--)
7737           {
7738             if(cinfo[j].ba==start+i*4+4) {
7739               memcpy(current.regmap,branch_regs[j].regmap,sizeof(current.regmap));
7740               current.dirty=branch_regs[j].dirty;
7741               break;
7742             }
7743           }
7744           while(j>=0) {
7745             if(cinfo[j].ba==start+i*4+4) {
7746               for(hr=0;hr<HOST_REGS;hr++) {
7747                 if(current.regmap[hr]!=branch_regs[j].regmap[hr]) {
7748                   current.regmap[hr]=-1;
7749                 }
7750                 current.dirty&=branch_regs[j].dirty;
7751               }
7752             }
7753             j--;
7754           }
7755         }
7756       }
7757     }
7758
7759     // Count cycles in between branches
7760     cinfo[i].ccadj = CLOCK_ADJUST(cc);
7761     if (i > 0 && (dops[i-1].is_jump || dops[i].is_exception))
7762     {
7763       cc=0;
7764     }
7765 #if !defined(DRC_DBG)
7766     else if(dops[i].itype==C2OP&&gte_cycletab[source[i]&0x3f]>2)
7767     {
7768       // this should really be removed since the real stalls have been implemented,
7769       // but doing so causes sizeable perf regression against the older version
7770       u_int gtec = gte_cycletab[source[i] & 0x3f];
7771       cc += HACK_ENABLED(NDHACK_NO_STALLS) ? gtec/2 : 2;
7772     }
7773     else if(i>1&&dops[i].itype==STORE&&dops[i-1].itype==STORE&&dops[i-2].itype==STORE&&!dops[i].bt)
7774     {
7775       cc+=4;
7776     }
7777     else if(dops[i].itype==C2LS)
7778     {
7779       // same as with C2OP
7780       cc += HACK_ENABLED(NDHACK_NO_STALLS) ? 4 : 2;
7781     }
7782 #endif
7783     else
7784     {
7785       cc++;
7786     }
7787
7788     if(!dops[i].is_ds) {
7789       regs[i].dirty=current.dirty;
7790       regs[i].isconst=current.isconst;
7791       memcpy(constmap[i],current_constmap,sizeof(constmap[i]));
7792     }
7793     for(hr=0;hr<HOST_REGS;hr++) {
7794       if(hr!=EXCLUDE_REG&&regs[i].regmap[hr]>=0) {
7795         if(regmap_pre[i][hr]!=regs[i].regmap[hr]) {
7796           regs[i].wasconst&=~(1<<hr);
7797         }
7798       }
7799     }
7800     //regs[i].waswritten=current.waswritten;
7801   }
7802 }
7803
7804 static noinline void pass4_cull_unused_regs(void)
7805 {
7806   u_int last_needed_regs[4] = {0,0,0,0};
7807   u_int nr=0;
7808   int i;
7809
7810   for (i=slen-1;i>=0;i--)
7811   {
7812     int hr;
7813     __builtin_prefetch(regs[i-2].regmap);
7814     if(dops[i].is_jump)
7815     {
7816       if(cinfo[i].ba<start || cinfo[i].ba>=(start+slen*4))
7817       {
7818         // Branch out of this block, don't need anything
7819         nr=0;
7820       }
7821       else
7822       {
7823         // Internal branch
7824         // Need whatever matches the target
7825         nr=0;
7826         int t=(cinfo[i].ba-start)>>2;
7827         for(hr=0;hr<HOST_REGS;hr++)
7828         {
7829           if(regs[i].regmap_entry[hr]>=0) {
7830             if(regs[i].regmap_entry[hr]==regs[t].regmap_entry[hr]) nr|=1<<hr;
7831           }
7832         }
7833       }
7834       // Conditional branch may need registers for following instructions
7835       if (!dops[i].is_ujump)
7836       {
7837         if(i<slen-2) {
7838           nr |= last_needed_regs[(i+2) & 3];
7839           for(hr=0;hr<HOST_REGS;hr++)
7840           {
7841             if(regmap_pre[i+2][hr]>=0&&get_reg(regs[i+2].regmap_entry,regmap_pre[i+2][hr])<0) nr&=~(1<<hr);
7842             //if((regmap_entry[i+2][hr])>=0) if(!((nr>>hr)&1)) printf("%x-bogus(%d=%d)\n",start+i*4,hr,regmap_entry[i+2][hr]);
7843           }
7844         }
7845       }
7846       // Don't need stuff which is overwritten
7847       //if(regs[i].regmap[hr]!=regmap_pre[i][hr]) nr&=~(1<<hr);
7848       //if(regs[i].regmap[hr]<0) nr&=~(1<<hr);
7849       // Merge in delay slot
7850       if (dops[i+1].rt1) nr &= ~get_regm(regs[i].regmap, dops[i+1].rt1);
7851       if (dops[i+1].rt2) nr &= ~get_regm(regs[i].regmap, dops[i+1].rt2);
7852       nr |= get_regm(regmap_pre[i], dops[i+1].rs1);
7853       nr |= get_regm(regmap_pre[i], dops[i+1].rs2);
7854       nr |= get_regm(regs[i].regmap_entry, dops[i+1].rs1);
7855       nr |= get_regm(regs[i].regmap_entry, dops[i+1].rs2);
7856       if (ram_offset && (dops[i+1].is_load || dops[i+1].is_store)) {
7857         nr |= get_regm(regmap_pre[i], ROREG);
7858         nr |= get_regm(regs[i].regmap_entry, ROREG);
7859       }
7860       if (dops[i+1].is_store) {
7861         nr |= get_regm(regmap_pre[i], INVCP);
7862         nr |= get_regm(regs[i].regmap_entry, INVCP);
7863       }
7864     }
7865     else if (dops[i].is_exception)
7866     {
7867       // SYSCALL instruction, etc
7868       nr=0;
7869     }
7870     else // Non-branch
7871     {
7872       if(i<slen-1) {
7873         for(hr=0;hr<HOST_REGS;hr++) {
7874           if(regmap_pre[i+1][hr]>=0&&get_reg(regs[i+1].regmap_entry,regmap_pre[i+1][hr])<0) nr&=~(1<<hr);
7875           if(regs[i].regmap[hr]!=regmap_pre[i+1][hr]) nr&=~(1<<hr);
7876           if(regs[i].regmap[hr]!=regmap_pre[i][hr]) nr&=~(1<<hr);
7877           if(regs[i].regmap[hr]<0) nr&=~(1<<hr);
7878         }
7879       }
7880     }
7881     // Overwritten registers are not needed
7882     if (dops[i].rt1) nr &= ~get_regm(regs[i].regmap, dops[i].rt1);
7883     if (dops[i].rt2) nr &= ~get_regm(regs[i].regmap, dops[i].rt2);
7884     nr &= ~get_regm(regs[i].regmap, FTEMP);
7885     // Source registers are needed
7886     nr |= get_regm(regmap_pre[i], dops[i].rs1);
7887     nr |= get_regm(regmap_pre[i], dops[i].rs2);
7888     nr |= get_regm(regs[i].regmap_entry, dops[i].rs1);
7889     nr |= get_regm(regs[i].regmap_entry, dops[i].rs2);
7890     if (ram_offset && (dops[i].is_load || dops[i].is_store)) {
7891       nr |= get_regm(regmap_pre[i], ROREG);
7892       nr |= get_regm(regs[i].regmap_entry, ROREG);
7893     }
7894     if (dops[i].is_store) {
7895       nr |= get_regm(regmap_pre[i], INVCP);
7896       nr |= get_regm(regs[i].regmap_entry, INVCP);
7897     }
7898
7899     if (i > 0 && !dops[i].bt && regs[i].wasdirty)
7900     for(hr=0;hr<HOST_REGS;hr++)
7901     {
7902       // Don't store a register immediately after writing it,
7903       // may prevent dual-issue.
7904       // But do so if this is a branch target, otherwise we
7905       // might have to load the register before the branch.
7906       if((regs[i].wasdirty>>hr)&1) {
7907         if((regmap_pre[i][hr]>0&&!((unneeded_reg[i]>>regmap_pre[i][hr])&1))) {
7908           if(dops[i-1].rt1==regmap_pre[i][hr]) nr|=1<<hr;
7909           if(dops[i-1].rt2==regmap_pre[i][hr]) nr|=1<<hr;
7910         }
7911         if((regs[i].regmap_entry[hr]>0&&!((unneeded_reg[i]>>regs[i].regmap_entry[hr])&1))) {
7912           if(dops[i-1].rt1==regs[i].regmap_entry[hr]) nr|=1<<hr;
7913           if(dops[i-1].rt2==regs[i].regmap_entry[hr]) nr|=1<<hr;
7914         }
7915       }
7916     }
7917     // Cycle count is needed at branches.  Assume it is needed at the target too.
7918     if (i == 0 || dops[i].bt || dops[i].may_except || dops[i].itype == CJUMP) {
7919       if(regmap_pre[i][HOST_CCREG]==CCREG) nr|=1<<HOST_CCREG;
7920       if(regs[i].regmap_entry[HOST_CCREG]==CCREG) nr|=1<<HOST_CCREG;
7921     }
7922     // Save it
7923     last_needed_regs[i & 3] = nr;
7924
7925     // Deallocate unneeded registers
7926     for(hr=0;hr<HOST_REGS;hr++)
7927     {
7928       if(!((nr>>hr)&1)) {
7929         if(regs[i].regmap_entry[hr]!=CCREG) regs[i].regmap_entry[hr]=-1;
7930         if(dops[i].is_jump)
7931         {
7932           int map1 = 0, map2 = 0, temp = 0; // or -1 ??
7933           if (dops[i+1].is_load || dops[i+1].is_store)
7934             map1 = ROREG;
7935           if (dops[i+1].is_store)
7936             map2 = INVCP;
7937           if(dops[i+1].itype==LOADLR || dops[i+1].itype==STORELR || dops[i+1].itype==C2LS)
7938             temp = FTEMP;
7939           if(regs[i].regmap[hr]!=dops[i].rs1 && regs[i].regmap[hr]!=dops[i].rs2 &&
7940              regs[i].regmap[hr]!=dops[i].rt1 && regs[i].regmap[hr]!=dops[i].rt2 &&
7941              regs[i].regmap[hr]!=dops[i+1].rt1 && regs[i].regmap[hr]!=dops[i+1].rt2 &&
7942              regs[i].regmap[hr]!=dops[i+1].rs1 && regs[i].regmap[hr]!=dops[i+1].rs2 &&
7943              regs[i].regmap[hr]!=temp && regs[i].regmap[hr]!=PTEMP &&
7944              regs[i].regmap[hr]!=RHASH && regs[i].regmap[hr]!=RHTBL &&
7945              regs[i].regmap[hr]!=RTEMP && regs[i].regmap[hr]!=CCREG &&
7946              regs[i].regmap[hr]!=map1 && regs[i].regmap[hr]!=map2)
7947           {
7948             regs[i].regmap[hr]=-1;
7949             regs[i].isconst&=~(1<<hr);
7950             regs[i].dirty&=~(1<<hr);
7951             regs[i+1].wasdirty&=~(1<<hr);
7952             if(branch_regs[i].regmap[hr]!=dops[i].rs1 && branch_regs[i].regmap[hr]!=dops[i].rs2 &&
7953                branch_regs[i].regmap[hr]!=dops[i].rt1 && branch_regs[i].regmap[hr]!=dops[i].rt2 &&
7954                branch_regs[i].regmap[hr]!=dops[i+1].rt1 && branch_regs[i].regmap[hr]!=dops[i+1].rt2 &&
7955                branch_regs[i].regmap[hr]!=dops[i+1].rs1 && branch_regs[i].regmap[hr]!=dops[i+1].rs2 &&
7956                branch_regs[i].regmap[hr]!=temp && branch_regs[i].regmap[hr]!=PTEMP &&
7957                branch_regs[i].regmap[hr]!=RHASH && branch_regs[i].regmap[hr]!=RHTBL &&
7958                branch_regs[i].regmap[hr]!=RTEMP && branch_regs[i].regmap[hr]!=CCREG &&
7959                branch_regs[i].regmap[hr]!=map1 && branch_regs[i].regmap[hr]!=map2)
7960             {
7961               branch_regs[i].regmap[hr]=-1;
7962               branch_regs[i].regmap_entry[hr]=-1;
7963               if (!dops[i].is_ujump)
7964               {
7965                 if (i < slen-2) {
7966                   regmap_pre[i+2][hr]=-1;
7967                   regs[i+2].wasconst&=~(1<<hr);
7968                 }
7969               }
7970             }
7971           }
7972         }
7973         else
7974         {
7975           // Non-branch
7976           if(i>0)
7977           {
7978             int map1 = -1, map2 = -1, temp=-1;
7979             if (dops[i].is_load || dops[i].is_store)
7980               map1 = ROREG;
7981             if (dops[i].is_store)
7982               map2 = INVCP;
7983             if (dops[i].itype==LOADLR || dops[i].itype==STORELR || dops[i].itype==C2LS)
7984               temp = FTEMP;
7985             if(regs[i].regmap[hr]!=dops[i].rt1 && regs[i].regmap[hr]!=dops[i].rt2 &&
7986                regs[i].regmap[hr]!=dops[i].rs1 && regs[i].regmap[hr]!=dops[i].rs2 &&
7987                regs[i].regmap[hr]!=temp && regs[i].regmap[hr]!=map1 && regs[i].regmap[hr]!=map2 &&
7988                //(dops[i].itype!=SPAN||regs[i].regmap[hr]!=CCREG)
7989                regs[i].regmap[hr] != CCREG)
7990             {
7991               if(i<slen-1&&!dops[i].is_ds) {
7992                 assert(regs[i].regmap[hr]<64);
7993                 if(regmap_pre[i+1][hr]!=-1 || regs[i].regmap[hr]>0)
7994                 if(regmap_pre[i+1][hr]!=regs[i].regmap[hr])
7995                 {
7996                   SysPrintf("fail: %x (%d %d!=%d)\n",start+i*4,hr,regmap_pre[i+1][hr],regs[i].regmap[hr]);
7997                   assert(regmap_pre[i+1][hr]==regs[i].regmap[hr]);
7998                 }
7999                 regmap_pre[i+1][hr]=-1;
8000                 if(regs[i+1].regmap_entry[hr]==CCREG) regs[i+1].regmap_entry[hr]=-1;
8001                 regs[i+1].wasconst&=~(1<<hr);
8002               }
8003               regs[i].regmap[hr]=-1;
8004               regs[i].isconst&=~(1<<hr);
8005               regs[i].dirty&=~(1<<hr);
8006               regs[i+1].wasdirty&=~(1<<hr);
8007             }
8008           }
8009         }
8010       } // if needed
8011     } // for hr
8012   }
8013 }
8014
8015 // If a register is allocated during a loop, try to allocate it for the
8016 // entire loop, if possible.  This avoids loading/storing registers
8017 // inside of the loop.
8018 static noinline void pass5a_preallocate1(void)
8019 {
8020   int i, j, hr;
8021   signed char f_regmap[HOST_REGS];
8022   clear_all_regs(f_regmap);
8023   for(i=0;i<slen-1;i++)
8024   {
8025     if(dops[i].itype==UJUMP||dops[i].itype==CJUMP||dops[i].itype==SJUMP)
8026     {
8027       if(cinfo[i].ba>=start && cinfo[i].ba<(start+i*4))
8028       if(dops[i+1].itype==NOP||dops[i+1].itype==MOV||dops[i+1].itype==ALU
8029       ||dops[i+1].itype==SHIFTIMM||dops[i+1].itype==IMM16||dops[i+1].itype==LOAD
8030       ||dops[i+1].itype==STORE||dops[i+1].itype==STORELR
8031       ||dops[i+1].itype==SHIFT
8032       ||dops[i+1].itype==COP2||dops[i+1].itype==C2LS||dops[i+1].itype==C2OP)
8033       {
8034         int t=(cinfo[i].ba-start)>>2;
8035         if(t > 0 && !dops[t-1].is_jump) // loop_preload can't handle jumps into delay slots
8036         if(t<2||(dops[t-2].itype!=UJUMP&&dops[t-2].itype!=RJUMP)||dops[t-2].rt1!=31) // call/ret assumes no registers allocated
8037         for(hr=0;hr<HOST_REGS;hr++)
8038         {
8039           if(regs[i].regmap[hr]>=0) {
8040             if(f_regmap[hr]!=regs[i].regmap[hr]) {
8041               // dealloc old register
8042               int n;
8043               for(n=0;n<HOST_REGS;n++)
8044               {
8045                 if(f_regmap[n]==regs[i].regmap[hr]) {f_regmap[n]=-1;}
8046               }
8047               // and alloc new one
8048               f_regmap[hr]=regs[i].regmap[hr];
8049             }
8050           }
8051           if(branch_regs[i].regmap[hr]>=0) {
8052             if(f_regmap[hr]!=branch_regs[i].regmap[hr]) {
8053               // dealloc old register
8054               int n;
8055               for(n=0;n<HOST_REGS;n++)
8056               {
8057                 if(f_regmap[n]==branch_regs[i].regmap[hr]) {f_regmap[n]=-1;}
8058               }
8059               // and alloc new one
8060               f_regmap[hr]=branch_regs[i].regmap[hr];
8061             }
8062           }
8063           if(dops[i].ooo) {
8064             if(count_free_regs(regs[i].regmap)<=cinfo[i+1].min_free_regs)
8065               f_regmap[hr]=branch_regs[i].regmap[hr];
8066           }else{
8067             if(count_free_regs(branch_regs[i].regmap)<=cinfo[i+1].min_free_regs)
8068               f_regmap[hr]=branch_regs[i].regmap[hr];
8069           }
8070           // Avoid dirty->clean transition
8071           #ifdef DESTRUCTIVE_WRITEBACK
8072           if(t>0) if(get_reg(regmap_pre[t],f_regmap[hr])>=0) if((regs[t].wasdirty>>get_reg(regmap_pre[t],f_regmap[hr]))&1) f_regmap[hr]=-1;
8073           #endif
8074           // This check is only strictly required in the DESTRUCTIVE_WRITEBACK
8075           // case above, however it's always a good idea.  We can't hoist the
8076           // load if the register was already allocated, so there's no point
8077           // wasting time analyzing most of these cases.  It only "succeeds"
8078           // when the mapping was different and the load can be replaced with
8079           // a mov, which is of negligible benefit.  So such cases are
8080           // skipped below.
8081           if(f_regmap[hr]>0) {
8082             if(regs[t].regmap[hr]==f_regmap[hr]||(regs[t].regmap_entry[hr]<0&&get_reg(regmap_pre[t],f_regmap[hr])<0)) {
8083               int r=f_regmap[hr];
8084               for(j=t;j<=i;j++)
8085               {
8086                 //printf("Test %x -> %x, %x %d/%d\n",start+i*4,cinfo[i].ba,start+j*4,hr,r);
8087                 if(r<34&&((unneeded_reg[j]>>r)&1)) break;
8088                 assert(r < 64);
8089                 if(regs[j].regmap[hr]==f_regmap[hr]&&f_regmap[hr]<TEMPREG) {
8090                   //printf("Hit %x -> %x, %x %d/%d\n",start+i*4,cinfo[i].ba,start+j*4,hr,r);
8091                   int k;
8092                   if(regs[i].regmap[hr]==-1&&branch_regs[i].regmap[hr]==-1) {
8093                     if(get_reg(regs[i].regmap,f_regmap[hr])>=0) break;
8094                     if(get_reg(regs[i+2].regmap,f_regmap[hr])>=0) break;
8095                     k=i;
8096                     while(k>1&&regs[k-1].regmap[hr]==-1) {
8097                       if(count_free_regs(regs[k-1].regmap)<=cinfo[k-1].min_free_regs) {
8098                         //printf("no free regs for store %x\n",start+(k-1)*4);
8099                         break;
8100                       }
8101                       if(get_reg(regs[k-1].regmap,f_regmap[hr])>=0) {
8102                         //printf("no-match due to different register\n");
8103                         break;
8104                       }
8105                       if (dops[k-2].is_jump) {
8106                         //printf("no-match due to branch\n");
8107                         break;
8108                       }
8109                       // call/ret fast path assumes no registers allocated
8110                       if(k>2&&(dops[k-3].itype==UJUMP||dops[k-3].itype==RJUMP)&&dops[k-3].rt1==31) {
8111                         break;
8112                       }
8113                       k--;
8114                     }
8115                     if(regs[k-1].regmap[hr]==f_regmap[hr]&&regmap_pre[k][hr]==f_regmap[hr]) {
8116                       //printf("Extend r%d, %x ->\n",hr,start+k*4);
8117                       while(k<i) {
8118                         regs[k].regmap_entry[hr]=f_regmap[hr];
8119                         regs[k].regmap[hr]=f_regmap[hr];
8120                         regmap_pre[k+1][hr]=f_regmap[hr];
8121                         regs[k].wasdirty&=~(1<<hr);
8122                         regs[k].dirty&=~(1<<hr);
8123                         regs[k].wasdirty|=(1<<hr)&regs[k-1].dirty;
8124                         regs[k].dirty|=(1<<hr)&regs[k].wasdirty;
8125                         regs[k].wasconst&=~(1<<hr);
8126                         regs[k].isconst&=~(1<<hr);
8127                         k++;
8128                       }
8129                     }
8130                     else {
8131                       //printf("Fail Extend r%d, %x ->\n",hr,start+k*4);
8132                       break;
8133                     }
8134                     assert(regs[i-1].regmap[hr]==f_regmap[hr]);
8135                     if(regs[i-1].regmap[hr]==f_regmap[hr]&&regmap_pre[i][hr]==f_regmap[hr]) {
8136                       //printf("OK fill %x (r%d)\n",start+i*4,hr);
8137                       regs[i].regmap_entry[hr]=f_regmap[hr];
8138                       regs[i].regmap[hr]=f_regmap[hr];
8139                       regs[i].wasdirty&=~(1<<hr);
8140                       regs[i].dirty&=~(1<<hr);
8141                       regs[i].wasdirty|=(1<<hr)&regs[i-1].dirty;
8142                       regs[i].dirty|=(1<<hr)&regs[i-1].dirty;
8143                       regs[i].wasconst&=~(1<<hr);
8144                       regs[i].isconst&=~(1<<hr);
8145                       branch_regs[i].regmap_entry[hr]=f_regmap[hr];
8146                       branch_regs[i].wasdirty&=~(1<<hr);
8147                       branch_regs[i].wasdirty|=(1<<hr)&regs[i].dirty;
8148                       branch_regs[i].regmap[hr]=f_regmap[hr];
8149                       branch_regs[i].dirty&=~(1<<hr);
8150                       branch_regs[i].dirty|=(1<<hr)&regs[i].dirty;
8151                       branch_regs[i].wasconst&=~(1<<hr);
8152                       branch_regs[i].isconst&=~(1<<hr);
8153                       if (!dops[i].is_ujump) {
8154                         regmap_pre[i+2][hr]=f_regmap[hr];
8155                         regs[i+2].wasdirty&=~(1<<hr);
8156                         regs[i+2].wasdirty|=(1<<hr)&regs[i].dirty;
8157                       }
8158                     }
8159                   }
8160                   for(k=t;k<j;k++) {
8161                     // Alloc register clean at beginning of loop,
8162                     // but may dirty it in pass 6
8163                     regs[k].regmap_entry[hr]=f_regmap[hr];
8164                     regs[k].regmap[hr]=f_regmap[hr];
8165                     regs[k].dirty&=~(1<<hr);
8166                     regs[k].wasconst&=~(1<<hr);
8167                     regs[k].isconst&=~(1<<hr);
8168                     if (dops[k].is_jump) {
8169                       branch_regs[k].regmap_entry[hr]=f_regmap[hr];
8170                       branch_regs[k].regmap[hr]=f_regmap[hr];
8171                       branch_regs[k].dirty&=~(1<<hr);
8172                       branch_regs[k].wasconst&=~(1<<hr);
8173                       branch_regs[k].isconst&=~(1<<hr);
8174                       if (!dops[k].is_ujump) {
8175                         regmap_pre[k+2][hr]=f_regmap[hr];
8176                         regs[k+2].wasdirty&=~(1<<hr);
8177                       }
8178                     }
8179                     else
8180                     {
8181                       regmap_pre[k+1][hr]=f_regmap[hr];
8182                       regs[k+1].wasdirty&=~(1<<hr);
8183                     }
8184                   }
8185                   if(regs[j].regmap[hr]==f_regmap[hr])
8186                     regs[j].regmap_entry[hr]=f_regmap[hr];
8187                   break;
8188                 }
8189                 if(j==i) break;
8190                 if(regs[j].regmap[hr]>=0)
8191                   break;
8192                 if(get_reg(regs[j].regmap,f_regmap[hr])>=0) {
8193                   //printf("no-match due to different register\n");
8194                   break;
8195                 }
8196                 if (dops[j].is_ujump)
8197                 {
8198                   // Stop on unconditional branch
8199                   break;
8200                 }
8201                 if(dops[j].itype==CJUMP||dops[j].itype==SJUMP)
8202                 {
8203                   if(dops[j].ooo) {
8204                     if(count_free_regs(regs[j].regmap)<=cinfo[j+1].min_free_regs)
8205                       break;
8206                   }else{
8207                     if(count_free_regs(branch_regs[j].regmap)<=cinfo[j+1].min_free_regs)
8208                       break;
8209                   }
8210                   if(get_reg(branch_regs[j].regmap,f_regmap[hr])>=0) {
8211                     //printf("no-match due to different register (branch)\n");
8212                     break;
8213                   }
8214                 }
8215                 if(count_free_regs(regs[j].regmap)<=cinfo[j].min_free_regs) {
8216                   //printf("No free regs for store %x\n",start+j*4);
8217                   break;
8218                 }
8219                 assert(f_regmap[hr]<64);
8220               }
8221             }
8222           }
8223         }
8224       }
8225     }else{
8226       // Non branch or undetermined branch target
8227       for(hr=0;hr<HOST_REGS;hr++)
8228       {
8229         if(hr!=EXCLUDE_REG) {
8230           if(regs[i].regmap[hr]>=0) {
8231             if(f_regmap[hr]!=regs[i].regmap[hr]) {
8232               // dealloc old register
8233               int n;
8234               for(n=0;n<HOST_REGS;n++)
8235               {
8236                 if(f_regmap[n]==regs[i].regmap[hr]) {f_regmap[n]=-1;}
8237               }
8238               // and alloc new one
8239               f_regmap[hr]=regs[i].regmap[hr];
8240             }
8241           }
8242         }
8243       }
8244       // Try to restore cycle count at branch targets
8245       if(dops[i].bt) {
8246         for(j=i;j<slen-1;j++) {
8247           if(regs[j].regmap[HOST_CCREG]!=-1) break;
8248           if(count_free_regs(regs[j].regmap)<=cinfo[j].min_free_regs) {
8249             //printf("no free regs for store %x\n",start+j*4);
8250             break;
8251           }
8252         }
8253         if(regs[j].regmap[HOST_CCREG]==CCREG) {
8254           int k=i;
8255           //printf("Extend CC, %x -> %x\n",start+k*4,start+j*4);
8256           while(k<j) {
8257             regs[k].regmap_entry[HOST_CCREG]=CCREG;
8258             regs[k].regmap[HOST_CCREG]=CCREG;
8259             regmap_pre[k+1][HOST_CCREG]=CCREG;
8260             regs[k+1].wasdirty|=1<<HOST_CCREG;
8261             regs[k].dirty|=1<<HOST_CCREG;
8262             regs[k].wasconst&=~(1<<HOST_CCREG);
8263             regs[k].isconst&=~(1<<HOST_CCREG);
8264             k++;
8265           }
8266           regs[j].regmap_entry[HOST_CCREG]=CCREG;
8267         }
8268         // Work backwards from the branch target
8269         if(j>i&&f_regmap[HOST_CCREG]==CCREG)
8270         {
8271           //printf("Extend backwards\n");
8272           int k;
8273           k=i;
8274           while(regs[k-1].regmap[HOST_CCREG]==-1) {
8275             if(count_free_regs(regs[k-1].regmap)<=cinfo[k-1].min_free_regs) {
8276               //printf("no free regs for store %x\n",start+(k-1)*4);
8277               break;
8278             }
8279             k--;
8280           }
8281           if(regs[k-1].regmap[HOST_CCREG]==CCREG) {
8282             //printf("Extend CC, %x ->\n",start+k*4);
8283             while(k<=i) {
8284               regs[k].regmap_entry[HOST_CCREG]=CCREG;
8285               regs[k].regmap[HOST_CCREG]=CCREG;
8286               regmap_pre[k+1][HOST_CCREG]=CCREG;
8287               regs[k+1].wasdirty|=1<<HOST_CCREG;
8288               regs[k].dirty|=1<<HOST_CCREG;
8289               regs[k].wasconst&=~(1<<HOST_CCREG);
8290               regs[k].isconst&=~(1<<HOST_CCREG);
8291               k++;
8292             }
8293           }
8294           else {
8295             //printf("Fail Extend CC, %x ->\n",start+k*4);
8296           }
8297         }
8298       }
8299       if(dops[i].itype!=STORE&&dops[i].itype!=STORELR&&dops[i].itype!=SHIFT&&
8300          dops[i].itype!=NOP&&dops[i].itype!=MOV&&dops[i].itype!=ALU&&dops[i].itype!=SHIFTIMM&&
8301          dops[i].itype!=IMM16&&dops[i].itype!=LOAD)
8302       {
8303         memcpy(f_regmap,regs[i].regmap,sizeof(f_regmap));
8304       }
8305     }
8306   }
8307 }
8308
8309 // This allocates registers (if possible) one instruction prior
8310 // to use, which can avoid a load-use penalty on certain CPUs.
8311 static noinline void pass5b_preallocate2(void)
8312 {
8313   int i, hr;
8314   for(i=0;i<slen-1;i++)
8315   {
8316     if (!i || !dops[i-1].is_jump)
8317     {
8318       if(!dops[i+1].bt)
8319       {
8320         int j, can_steal = 1;
8321         for (j = i; j < i + 2; j++) {
8322           int free_regs = 0;
8323           if (cinfo[j].min_free_regs == 0)
8324             continue;
8325           for (hr = 0; hr < HOST_REGS; hr++)
8326             if (hr != EXCLUDE_REG && regs[j].regmap[hr] < 0)
8327               free_regs++;
8328           if (free_regs <= cinfo[j].min_free_regs) {
8329             can_steal = 0;
8330             break;
8331           }
8332         }
8333         if (!can_steal)
8334           continue;
8335         if(dops[i].itype==ALU||dops[i].itype==MOV||dops[i].itype==LOAD||dops[i].itype==SHIFTIMM||dops[i].itype==IMM16
8336            ||(dops[i].itype==COP2&&dops[i].opcode2<3))
8337         {
8338           if(dops[i+1].rs1) {
8339             if((hr=get_reg(regs[i+1].regmap,dops[i+1].rs1))>=0)
8340             {
8341               if(regs[i].regmap[hr]<0&&regs[i+1].regmap_entry[hr]<0)
8342               {
8343                 regs[i].regmap[hr]=regs[i+1].regmap[hr];
8344                 regmap_pre[i+1][hr]=regs[i+1].regmap[hr];
8345                 regs[i+1].regmap_entry[hr]=regs[i+1].regmap[hr];
8346                 regs[i].isconst&=~(1<<hr);
8347                 regs[i].isconst|=regs[i+1].isconst&(1<<hr);
8348                 constmap[i][hr]=constmap[i+1][hr];
8349                 regs[i+1].wasdirty&=~(1<<hr);
8350                 regs[i].dirty&=~(1<<hr);
8351               }
8352             }
8353           }
8354           if(dops[i+1].rs2) {
8355             if((hr=get_reg(regs[i+1].regmap,dops[i+1].rs2))>=0)
8356             {
8357               if(regs[i].regmap[hr]<0&&regs[i+1].regmap_entry[hr]<0)
8358               {
8359                 regs[i].regmap[hr]=regs[i+1].regmap[hr];
8360                 regmap_pre[i+1][hr]=regs[i+1].regmap[hr];
8361                 regs[i+1].regmap_entry[hr]=regs[i+1].regmap[hr];
8362                 regs[i].isconst&=~(1<<hr);
8363                 regs[i].isconst|=regs[i+1].isconst&(1<<hr);
8364                 constmap[i][hr]=constmap[i+1][hr];
8365                 regs[i+1].wasdirty&=~(1<<hr);
8366                 regs[i].dirty&=~(1<<hr);
8367               }
8368             }
8369           }
8370           // Preload target address for load instruction (non-constant)
8371           if(dops[i+1].itype==LOAD&&dops[i+1].rs1&&get_reg(regs[i+1].regmap,dops[i+1].rs1)<0) {
8372             if((hr=get_reg_w(regs[i+1].regmap, dops[i+1].rt1))>=0)
8373             {
8374               if(regs[i].regmap[hr]<0&&regs[i+1].regmap_entry[hr]<0)
8375               {
8376                 regs[i].regmap[hr]=dops[i+1].rs1;
8377                 regmap_pre[i+1][hr]=dops[i+1].rs1;
8378                 regs[i+1].regmap_entry[hr]=dops[i+1].rs1;
8379                 regs[i].isconst&=~(1<<hr);
8380                 regs[i].isconst|=regs[i+1].isconst&(1<<hr);
8381                 constmap[i][hr]=constmap[i+1][hr];
8382                 regs[i+1].wasdirty&=~(1<<hr);
8383                 regs[i].dirty&=~(1<<hr);
8384               }
8385             }
8386           }
8387           // Load source into target register
8388           if(dops[i+1].use_lt1&&get_reg(regs[i+1].regmap,dops[i+1].rs1)<0) {
8389             if((hr=get_reg_w(regs[i+1].regmap, dops[i+1].rt1))>=0)
8390             {
8391               if(regs[i].regmap[hr]<0&&regs[i+1].regmap_entry[hr]<0)
8392               {
8393                 regs[i].regmap[hr]=dops[i+1].rs1;
8394                 regmap_pre[i+1][hr]=dops[i+1].rs1;
8395                 regs[i+1].regmap_entry[hr]=dops[i+1].rs1;
8396                 regs[i].isconst&=~(1<<hr);
8397                 regs[i].isconst|=regs[i+1].isconst&(1<<hr);
8398                 constmap[i][hr]=constmap[i+1][hr];
8399                 regs[i+1].wasdirty&=~(1<<hr);
8400                 regs[i].dirty&=~(1<<hr);
8401               }
8402             }
8403           }
8404           // Address for store instruction (non-constant)
8405           if (dops[i+1].is_store) { // SB/SH/SW/SWC2
8406             if(get_reg(regs[i+1].regmap,dops[i+1].rs1)<0) {
8407               hr=get_reg2(regs[i].regmap,regs[i+1].regmap,-1);
8408               if(hr<0) hr=get_reg_temp(regs[i+1].regmap);
8409               else {
8410                 regs[i+1].regmap[hr]=AGEN1+((i+1)&1);
8411                 regs[i+1].isconst&=~(1<<hr);
8412                 regs[i+1].dirty&=~(1<<hr);
8413                 regs[i+2].wasdirty&=~(1<<hr);
8414               }
8415               assert(hr>=0);
8416               #if 0 // what is this for? double allocs $0 in ps1_rom.bin
8417               if(regs[i].regmap[hr]<0&&regs[i+1].regmap_entry[hr]<0)
8418               {
8419                 regs[i].regmap[hr]=dops[i+1].rs1;
8420                 regmap_pre[i+1][hr]=dops[i+1].rs1;
8421                 regs[i+1].regmap_entry[hr]=dops[i+1].rs1;
8422                 regs[i].isconst&=~(1<<hr);
8423                 regs[i].isconst|=regs[i+1].isconst&(1<<hr);
8424                 constmap[i][hr]=constmap[i+1][hr];
8425                 regs[i+1].wasdirty&=~(1<<hr);
8426                 regs[i].dirty&=~(1<<hr);
8427               }
8428               #endif
8429             }
8430           }
8431           if (dops[i+1].itype == LOADLR || dops[i+1].opcode == 0x32) { // LWC2
8432             if(get_reg(regs[i+1].regmap,dops[i+1].rs1)<0) {
8433               int nr;
8434               hr=get_reg(regs[i+1].regmap,FTEMP);
8435               assert(hr>=0);
8436               if(regs[i].regmap[hr]<0&&regs[i+1].regmap_entry[hr]<0)
8437               {
8438                 regs[i].regmap[hr]=dops[i+1].rs1;
8439                 regmap_pre[i+1][hr]=dops[i+1].rs1;
8440                 regs[i+1].regmap_entry[hr]=dops[i+1].rs1;
8441                 regs[i].isconst&=~(1<<hr);
8442                 regs[i].isconst|=regs[i+1].isconst&(1<<hr);
8443                 constmap[i][hr]=constmap[i+1][hr];
8444                 regs[i+1].wasdirty&=~(1<<hr);
8445                 regs[i].dirty&=~(1<<hr);
8446               }
8447               else if((nr=get_reg2(regs[i].regmap,regs[i+1].regmap,-1))>=0)
8448               {
8449                 // move it to another register
8450                 regs[i+1].regmap[hr]=-1;
8451                 regmap_pre[i+2][hr]=-1;
8452                 regs[i+1].regmap[nr]=FTEMP;
8453                 regmap_pre[i+2][nr]=FTEMP;
8454                 regs[i].regmap[nr]=dops[i+1].rs1;
8455                 regmap_pre[i+1][nr]=dops[i+1].rs1;
8456                 regs[i+1].regmap_entry[nr]=dops[i+1].rs1;
8457                 regs[i].isconst&=~(1<<nr);
8458                 regs[i+1].isconst&=~(1<<nr);
8459                 regs[i].dirty&=~(1<<nr);
8460                 regs[i+1].wasdirty&=~(1<<nr);
8461                 regs[i+1].dirty&=~(1<<nr);
8462                 regs[i+2].wasdirty&=~(1<<nr);
8463               }
8464             }
8465           }
8466           if(dops[i+1].itype==LOAD||dops[i+1].itype==LOADLR||dops[i+1].itype==STORE||dops[i+1].itype==STORELR/*||dops[i+1].itype==C2LS*/) {
8467             hr = -1;
8468             if(dops[i+1].itype==LOAD)
8469               hr=get_reg_w(regs[i+1].regmap, dops[i+1].rt1);
8470             if (dops[i+1].itype == LOADLR || dops[i+1].opcode == 0x32) // LWC2
8471               hr=get_reg(regs[i+1].regmap,FTEMP);
8472             if (dops[i+1].is_store) {
8473               hr=get_reg(regs[i+1].regmap,AGEN1+((i+1)&1));
8474               if(hr<0) hr=get_reg_temp(regs[i+1].regmap);
8475             }
8476             if(hr>=0&&regs[i].regmap[hr]<0) {
8477               int rs=get_reg(regs[i+1].regmap,dops[i+1].rs1);
8478               if(rs>=0&&((regs[i+1].wasconst>>rs)&1)) {
8479                 regs[i].regmap[hr]=AGEN1+((i+1)&1);
8480                 regmap_pre[i+1][hr]=AGEN1+((i+1)&1);
8481                 regs[i+1].regmap_entry[hr]=AGEN1+((i+1)&1);
8482                 regs[i].isconst&=~(1<<hr);
8483                 regs[i+1].wasdirty&=~(1<<hr);
8484                 regs[i].dirty&=~(1<<hr);
8485               }
8486             }
8487           }
8488         }
8489       }
8490     }
8491   }
8492 }
8493
8494 // Write back dirty registers as soon as we will no longer modify them,
8495 // so that we don't end up with lots of writes at the branches.
8496 static noinline void pass6_clean_registers(int istart, int iend, int wr)
8497 {
8498   static u_int wont_dirty[MAXBLOCK];
8499   static u_int will_dirty[MAXBLOCK];
8500   int i;
8501   int r;
8502   u_int will_dirty_i,will_dirty_next,temp_will_dirty;
8503   u_int wont_dirty_i,wont_dirty_next,temp_wont_dirty;
8504   if(iend==slen-1) {
8505     will_dirty_i=will_dirty_next=0;
8506     wont_dirty_i=wont_dirty_next=0;
8507   }else{
8508     will_dirty_i=will_dirty_next=will_dirty[iend+1];
8509     wont_dirty_i=wont_dirty_next=wont_dirty[iend+1];
8510   }
8511   for (i=iend;i>=istart;i--)
8512   {
8513     signed char rregmap_i[RRMAP_SIZE];
8514     u_int hr_candirty = 0;
8515     assert(HOST_REGS < 32);
8516     make_rregs(regs[i].regmap, rregmap_i, &hr_candirty);
8517     __builtin_prefetch(regs[i-1].regmap);
8518     if(dops[i].is_jump)
8519     {
8520       signed char branch_rregmap_i[RRMAP_SIZE];
8521       u_int branch_hr_candirty = 0;
8522       make_rregs(branch_regs[i].regmap, branch_rregmap_i, &branch_hr_candirty);
8523       if(cinfo[i].ba<start || cinfo[i].ba>=(start+slen*4))
8524       {
8525         // Branch out of this block, flush all regs
8526         will_dirty_i = 0;
8527         will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt1) & 31);
8528         will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt2) & 31);
8529         will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt1) & 31);
8530         will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt2) & 31);
8531         will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, CCREG) & 31);
8532         will_dirty_i &= branch_hr_candirty;
8533         if (dops[i].is_ujump)
8534         {
8535           // Unconditional branch
8536           wont_dirty_i = 0;
8537           // Merge in delay slot (will dirty)
8538           will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8539           will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8540           will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt1) & 31);
8541           will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt2) & 31);
8542           will_dirty_i |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8543           will_dirty_i &= hr_candirty;
8544         }
8545         else
8546         {
8547           // Conditional branch
8548           wont_dirty_i = wont_dirty_next;
8549           // Merge in delay slot (will dirty)
8550           // (the original code had no explanation why these 2 are commented out)
8551           //will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8552           //will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8553           will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt1) & 31);
8554           will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt2) & 31);
8555           will_dirty_i |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8556           will_dirty_i &= hr_candirty;
8557         }
8558         // Merge in delay slot (wont dirty)
8559         wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8560         wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8561         wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt1) & 31);
8562         wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt2) & 31);
8563         wont_dirty_i |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8564         wont_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt1) & 31);
8565         wont_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt2) & 31);
8566         wont_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt1) & 31);
8567         wont_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt2) & 31);
8568         wont_dirty_i |= 1u << (get_rreg(branch_rregmap_i, CCREG) & 31);
8569         wont_dirty_i &= ~(1u << 31);
8570         if(wr) {
8571           #ifndef DESTRUCTIVE_WRITEBACK
8572           branch_regs[i].dirty&=wont_dirty_i;
8573           #endif
8574           branch_regs[i].dirty|=will_dirty_i;
8575         }
8576       }
8577       else
8578       {
8579         // Internal branch
8580         if(cinfo[i].ba<=start+i*4) {
8581           // Backward branch
8582           if (dops[i].is_ujump)
8583           {
8584             // Unconditional branch
8585             temp_will_dirty=0;
8586             temp_wont_dirty=0;
8587             // Merge in delay slot (will dirty)
8588             temp_will_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt1) & 31);
8589             temp_will_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt2) & 31);
8590             temp_will_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt1) & 31);
8591             temp_will_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt2) & 31);
8592             temp_will_dirty |= 1u << (get_rreg(branch_rregmap_i, CCREG) & 31);
8593             temp_will_dirty &= branch_hr_candirty;
8594             temp_will_dirty |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8595             temp_will_dirty |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8596             temp_will_dirty |= 1u << (get_rreg(rregmap_i, dops[i+1].rt1) & 31);
8597             temp_will_dirty |= 1u << (get_rreg(rregmap_i, dops[i+1].rt2) & 31);
8598             temp_will_dirty |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8599             temp_will_dirty &= hr_candirty;
8600           } else {
8601             // Conditional branch (not taken case)
8602             temp_will_dirty=will_dirty_next;
8603             temp_wont_dirty=wont_dirty_next;
8604             // Merge in delay slot (will dirty)
8605             temp_will_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt1) & 31);
8606             temp_will_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt2) & 31);
8607             temp_will_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt1) & 31);
8608             temp_will_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt2) & 31);
8609             temp_will_dirty |= 1u << (get_rreg(branch_rregmap_i, CCREG) & 31);
8610             temp_will_dirty &= branch_hr_candirty;
8611             //temp_will_dirty |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8612             //temp_will_dirty |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8613             temp_will_dirty |= 1u << (get_rreg(rregmap_i, dops[i+1].rt1) & 31);
8614             temp_will_dirty |= 1u << (get_rreg(rregmap_i, dops[i+1].rt2) & 31);
8615             temp_will_dirty |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8616             temp_will_dirty &= hr_candirty;
8617           }
8618           // Merge in delay slot (wont dirty)
8619           temp_wont_dirty |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8620           temp_wont_dirty |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8621           temp_wont_dirty |= 1u << (get_rreg(rregmap_i, dops[i+1].rt1) & 31);
8622           temp_wont_dirty |= 1u << (get_rreg(rregmap_i, dops[i+1].rt2) & 31);
8623           temp_wont_dirty |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8624           temp_wont_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt1) & 31);
8625           temp_wont_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt2) & 31);
8626           temp_wont_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt1) & 31);
8627           temp_wont_dirty |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt2) & 31);
8628           temp_wont_dirty |= 1u << (get_rreg(branch_rregmap_i, CCREG) & 31);
8629           temp_wont_dirty &= ~(1u << 31);
8630           // Deal with changed mappings
8631           if(i<iend) {
8632             for(r=0;r<HOST_REGS;r++) {
8633               if(r!=EXCLUDE_REG) {
8634                 if(regs[i].regmap[r]!=regmap_pre[i][r]) {
8635                   temp_will_dirty&=~(1<<r);
8636                   temp_wont_dirty&=~(1<<r);
8637                   if(regmap_pre[i][r]>0 && regmap_pre[i][r]<34) {
8638                     temp_will_dirty|=((unneeded_reg[i]>>regmap_pre[i][r])&1)<<r;
8639                     temp_wont_dirty|=((unneeded_reg[i]>>regmap_pre[i][r])&1)<<r;
8640                   } else {
8641                     temp_will_dirty|=1<<r;
8642                     temp_wont_dirty|=1<<r;
8643                   }
8644                 }
8645               }
8646             }
8647           }
8648           if(wr) {
8649             will_dirty[i]=temp_will_dirty;
8650             wont_dirty[i]=temp_wont_dirty;
8651             pass6_clean_registers((cinfo[i].ba-start)>>2,i-1,0);
8652           }else{
8653             // Limit recursion.  It can take an excessive amount
8654             // of time if there are a lot of nested loops.
8655             will_dirty[(cinfo[i].ba-start)>>2]=0;
8656             wont_dirty[(cinfo[i].ba-start)>>2]=-1;
8657           }
8658         }
8659         /*else*/ if(1)
8660         {
8661           if (dops[i].is_ujump)
8662           {
8663             // Unconditional branch
8664             will_dirty_i=0;
8665             wont_dirty_i=0;
8666           //if(cinfo[i].ba>start+i*4) { // Disable recursion (for debugging)
8667             for(r=0;r<HOST_REGS;r++) {
8668               if(r!=EXCLUDE_REG) {
8669                 if(branch_regs[i].regmap[r]==regs[(cinfo[i].ba-start)>>2].regmap_entry[r]) {
8670                   will_dirty_i|=will_dirty[(cinfo[i].ba-start)>>2]&(1<<r);
8671                   wont_dirty_i|=wont_dirty[(cinfo[i].ba-start)>>2]&(1<<r);
8672                 }
8673                 if(branch_regs[i].regmap[r]>=0) {
8674                   will_dirty_i|=((unneeded_reg[(cinfo[i].ba-start)>>2]>>branch_regs[i].regmap[r])&1)<<r;
8675                   wont_dirty_i|=((unneeded_reg[(cinfo[i].ba-start)>>2]>>branch_regs[i].regmap[r])&1)<<r;
8676                 }
8677               }
8678             }
8679           //}
8680             // Merge in delay slot
8681             will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt1) & 31);
8682             will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt2) & 31);
8683             will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt1) & 31);
8684             will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt2) & 31);
8685             will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, CCREG) & 31);
8686             will_dirty_i &= branch_hr_candirty;
8687             will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8688             will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8689             will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt1) & 31);
8690             will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt2) & 31);
8691             will_dirty_i |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8692             will_dirty_i &= hr_candirty;
8693           } else {
8694             // Conditional branch
8695             will_dirty_i=will_dirty_next;
8696             wont_dirty_i=wont_dirty_next;
8697           //if(cinfo[i].ba>start+i*4) // Disable recursion (for debugging)
8698             for(r=0;r<HOST_REGS;r++) {
8699               if(r!=EXCLUDE_REG) {
8700                 signed char target_reg=branch_regs[i].regmap[r];
8701                 if(target_reg==regs[(cinfo[i].ba-start)>>2].regmap_entry[r]) {
8702                   will_dirty_i&=will_dirty[(cinfo[i].ba-start)>>2]&(1<<r);
8703                   wont_dirty_i|=wont_dirty[(cinfo[i].ba-start)>>2]&(1<<r);
8704                 }
8705                 else if(target_reg>=0) {
8706                   will_dirty_i&=((unneeded_reg[(cinfo[i].ba-start)>>2]>>target_reg)&1)<<r;
8707                   wont_dirty_i|=((unneeded_reg[(cinfo[i].ba-start)>>2]>>target_reg)&1)<<r;
8708                 }
8709               }
8710             }
8711             // Merge in delay slot
8712             will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt1) & 31);
8713             will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt2) & 31);
8714             will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt1) & 31);
8715             will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt2) & 31);
8716             will_dirty_i |= 1u << (get_rreg(branch_rregmap_i, CCREG) & 31);
8717             will_dirty_i &= branch_hr_candirty;
8718             //will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8719             //will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8720             will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt1) & 31);
8721             will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt2) & 31);
8722             will_dirty_i |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8723             will_dirty_i &= hr_candirty;
8724           }
8725           // Merge in delay slot (won't dirty)
8726           wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8727           wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8728           wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt1) & 31);
8729           wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i+1].rt2) & 31);
8730           wont_dirty_i |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8731           wont_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt1) & 31);
8732           wont_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i].rt2) & 31);
8733           wont_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt1) & 31);
8734           wont_dirty_i |= 1u << (get_rreg(branch_rregmap_i, dops[i+1].rt2) & 31);
8735           wont_dirty_i |= 1u << (get_rreg(branch_rregmap_i, CCREG) & 31);
8736           wont_dirty_i &= ~(1u << 31);
8737           if(wr) {
8738             #ifndef DESTRUCTIVE_WRITEBACK
8739             branch_regs[i].dirty&=wont_dirty_i;
8740             #endif
8741             branch_regs[i].dirty|=will_dirty_i;
8742           }
8743         }
8744       }
8745     }
8746     else if (dops[i].is_exception)
8747     {
8748       // SYSCALL instruction, etc
8749       will_dirty_i=0;
8750       wont_dirty_i=0;
8751     }
8752     will_dirty_next=will_dirty_i;
8753     wont_dirty_next=wont_dirty_i;
8754     will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8755     will_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8756     will_dirty_i |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8757     will_dirty_i &= hr_candirty;
8758     wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt1) & 31);
8759     wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i].rt2) & 31);
8760     wont_dirty_i |= 1u << (get_rreg(rregmap_i, CCREG) & 31);
8761     wont_dirty_i &= ~(1u << 31);
8762     if (i > istart && !dops[i].is_jump) {
8763       // Don't store a register immediately after writing it,
8764       // may prevent dual-issue.
8765       wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i-1].rt1) & 31);
8766       wont_dirty_i |= 1u << (get_rreg(rregmap_i, dops[i-1].rt2) & 31);
8767     }
8768     // Save it
8769     will_dirty[i]=will_dirty_i;
8770     wont_dirty[i]=wont_dirty_i;
8771     // Mark registers that won't be dirtied as not dirty
8772     if(wr) {
8773         regs[i].dirty|=will_dirty_i;
8774         #ifndef DESTRUCTIVE_WRITEBACK
8775         regs[i].dirty&=wont_dirty_i;
8776         if(dops[i].is_jump)
8777         {
8778           if (i < iend-1 && !dops[i].is_ujump) {
8779             for(r=0;r<HOST_REGS;r++) {
8780               if(r!=EXCLUDE_REG) {
8781                 if(regs[i].regmap[r]==regmap_pre[i+2][r]) {
8782                   regs[i+2].wasdirty&=wont_dirty_i|~(1<<r);
8783                 }else {/*printf("i: %x (%d) mismatch(+2): %d\n",start+i*4,i,r);assert(!((wont_dirty_i>>r)&1));*/}
8784               }
8785             }
8786           }
8787         }
8788         else
8789         {
8790           if(i<iend) {
8791             for(r=0;r<HOST_REGS;r++) {
8792               if(r!=EXCLUDE_REG) {
8793                 if(regs[i].regmap[r]==regmap_pre[i+1][r]) {
8794                   regs[i+1].wasdirty&=wont_dirty_i|~(1<<r);
8795                 }else {/*printf("i: %x (%d) mismatch(+1): %d\n",start+i*4,i,r);assert(!((wont_dirty_i>>r)&1));*/}
8796               }
8797             }
8798           }
8799         }
8800         #endif
8801     }
8802     // Deal with changed mappings
8803     temp_will_dirty=will_dirty_i;
8804     temp_wont_dirty=wont_dirty_i;
8805     for(r=0;r<HOST_REGS;r++) {
8806       if(r!=EXCLUDE_REG) {
8807         int nr;
8808         if(regs[i].regmap[r]==regmap_pre[i][r]) {
8809           if(wr) {
8810             #ifndef DESTRUCTIVE_WRITEBACK
8811             regs[i].wasdirty&=wont_dirty_i|~(1<<r);
8812             #endif
8813             regs[i].wasdirty|=will_dirty_i&(1<<r);
8814           }
8815         }
8816         else if(regmap_pre[i][r]>=0&&(nr=get_rreg(rregmap_i,regmap_pre[i][r]))>=0) {
8817           // Register moved to a different register
8818           will_dirty_i&=~(1<<r);
8819           wont_dirty_i&=~(1<<r);
8820           will_dirty_i|=((temp_will_dirty>>nr)&1)<<r;
8821           wont_dirty_i|=((temp_wont_dirty>>nr)&1)<<r;
8822           if(wr) {
8823             #ifndef DESTRUCTIVE_WRITEBACK
8824             regs[i].wasdirty&=wont_dirty_i|~(1<<r);
8825             #endif
8826             regs[i].wasdirty|=will_dirty_i&(1<<r);
8827           }
8828         }
8829         else {
8830           will_dirty_i&=~(1<<r);
8831           wont_dirty_i&=~(1<<r);
8832           if(regmap_pre[i][r]>0 && regmap_pre[i][r]<34) {
8833             will_dirty_i|=((unneeded_reg[i]>>regmap_pre[i][r])&1)<<r;
8834             wont_dirty_i|=((unneeded_reg[i]>>regmap_pre[i][r])&1)<<r;
8835           } else {
8836             wont_dirty_i|=1<<r;
8837             /*printf("i: %x (%d) mismatch: %d\n",start+i*4,i,r);assert(!((will_dirty>>r)&1));*/
8838           }
8839         }
8840       }
8841     }
8842   }
8843 }
8844
8845 static noinline void pass10_expire_blocks(void)
8846 {
8847   u_int step = MAX_OUTPUT_BLOCK_SIZE / PAGE_COUNT / 2;
8848   // not sizeof(ndrc->translation_cache) due to vita hack
8849   u_int step_mask = ((1u << TARGET_SIZE_2) - 1u) & ~(step - 1u);
8850   u_int end = (out - ndrc->translation_cache + EXPIRITY_OFFSET) & step_mask;
8851   u_int base_shift = __builtin_ctz(MAX_OUTPUT_BLOCK_SIZE);
8852   int hit;
8853
8854   for (; expirep != end; expirep = ((expirep + step) & step_mask))
8855   {
8856     u_int base_offs = expirep & ~(MAX_OUTPUT_BLOCK_SIZE - 1);
8857     u_int block_i = expirep / step & (PAGE_COUNT - 1);
8858     u_int phase = (expirep >> (base_shift - 1)) & 1u;
8859     if (!(expirep & (MAX_OUTPUT_BLOCK_SIZE / 2 - 1))) {
8860       inv_debug("EXP: base_offs %x/%lx phase %u\n", base_offs,
8861         (long)(out - ndrc->translation_cache), phase);
8862     }
8863
8864     if (!phase) {
8865       hit = blocks_remove_matching_addrs(&blocks[block_i], base_offs, base_shift);
8866       if (hit) {
8867         do_clear_cache();
8868         #ifdef USE_MINI_HT
8869         memset(mini_ht, -1, sizeof(mini_ht));
8870         #endif
8871       }
8872     }
8873     else
8874       unlink_jumps_tc_range(jumps[block_i], base_offs, base_shift);
8875   }
8876 }
8877
8878 static struct block_info *new_block_info(u_int start, u_int len,
8879   const void *source, const void *copy, u_char *beginning, u_short jump_in_count)
8880 {
8881   struct block_info **b_pptr;
8882   struct block_info *block;
8883   u_int page = get_page(start);
8884
8885   block = malloc(sizeof(*block) + jump_in_count * sizeof(block->jump_in[0]));
8886   assert(block);
8887   assert(jump_in_count > 0);
8888   block->source = source;
8889   block->copy = copy;
8890   block->start = start;
8891   block->len = len;
8892   block->reg_sv_flags = 0;
8893   block->tc_offs = beginning - ndrc->translation_cache;
8894   //block->tc_len = out - beginning;
8895   block->is_dirty = 0;
8896   block->inv_near_misses = 0;
8897   block->jump_in_cnt = jump_in_count;
8898
8899   // insert sorted by start mirror-unmasked vaddr
8900   for (b_pptr = &blocks[page]; ; b_pptr = &((*b_pptr)->next)) {
8901     if (*b_pptr == NULL || (*b_pptr)->start >= start) {
8902       block->next = *b_pptr;
8903       *b_pptr = block;
8904       break;
8905     }
8906   }
8907   stat_inc(stat_blocks);
8908   return block;
8909 }
8910
8911 static int new_recompile_block(u_int addr)
8912 {
8913   u_int pagelimit = 0;
8914   u_int state_rflags = 0;
8915   int i;
8916
8917   assem_debug("NOTCOMPILED: addr = %x -> %p\n", addr, out);
8918
8919   if (addr & 3) {
8920     if (addr != hack_addr) {
8921       SysPrintf("game crash @%08x, ra=%08x\n", addr, psxRegs.GPR.n.ra);
8922       hack_addr = addr;
8923     }
8924     return -1;
8925   }
8926
8927   // this is just for speculation
8928   for (i = 1; i < 32; i++) {
8929     if ((psxRegs.GPR.r[i] & 0xffff0000) == 0x1f800000)
8930       state_rflags |= 1 << i;
8931   }
8932
8933   start = addr;
8934   new_dynarec_did_compile=1;
8935   if (Config.HLE && start == 0x80001000) // hlecall
8936   {
8937     void *beginning = start_block();
8938
8939     emit_movimm(start,0);
8940     emit_writeword(0,&pcaddr);
8941     emit_far_jump(new_dyna_leave);
8942     literal_pool(0);
8943     end_block(beginning);
8944     struct block_info *block = new_block_info(start, 4, NULL, NULL, beginning, 1);
8945     block->jump_in[0].vaddr = start;
8946     block->jump_in[0].addr = beginning;
8947     return 0;
8948   }
8949   else if (f1_hack && hack_addr == 0) {
8950     void *beginning = start_block();
8951     emit_movimm(start, 0);
8952     emit_writeword(0, &hack_addr);
8953     emit_readword(&psxRegs.GPR.n.sp, 0);
8954     emit_readptr(&mem_rtab, 1);
8955     emit_shrimm(0, 12, 2);
8956     emit_readptr_dualindexedx_ptrlen(1, 2, 1);
8957     emit_addimm(0, 0x18, 0);
8958     emit_adds_ptr(1, 1, 1);
8959     emit_ldr_dualindexed(1, 0, 0);
8960     emit_writeword(0, &psxRegs.GPR.r[26]); // lw k0, 0x18(sp)
8961     emit_far_call(ndrc_get_addr_ht);
8962     emit_jmpreg(0); // jr k0
8963     literal_pool(0);
8964     end_block(beginning);
8965
8966     struct block_info *block = new_block_info(start, 4, NULL, NULL, beginning, 1);
8967     block->jump_in[0].vaddr = start;
8968     block->jump_in[0].addr = beginning;
8969     SysPrintf("F1 hack to   %08x\n", start);
8970     return 0;
8971   }
8972
8973   cycle_multiplier_active = get_cycle_multiplier();
8974
8975   source = get_source_start(start, &pagelimit);
8976   if (source == NULL) {
8977     if (addr != hack_addr) {
8978       SysPrintf("Compile at bogus memory address: %08x, ra=%x\n",
8979         addr, psxRegs.GPR.n.ra);
8980       hack_addr = addr;
8981     }
8982     //abort();
8983     return -1;
8984   }
8985
8986   /* Pass 1: disassemble */
8987   /* Pass 2: register dependencies, branch targets */
8988   /* Pass 3: register allocation */
8989   /* Pass 4: branch dependencies */
8990   /* Pass 5: pre-alloc */
8991   /* Pass 6: optimize clean/dirty state */
8992   /* Pass 7: flag 32-bit registers */
8993   /* Pass 8: assembly */
8994   /* Pass 9: linker */
8995   /* Pass 10: garbage collection / free memory */
8996
8997   /* Pass 1 disassembly */
8998
8999   pass1_disassemble(pagelimit);
9000
9001   int clear_hack_addr = apply_hacks();
9002
9003   /* Pass 2 - Register dependencies and branch targets */
9004
9005   pass2_unneeded_regs(0,slen-1,0);
9006
9007   pass2a_unneeded_other();
9008
9009   /* Pass 3 - Register allocation */
9010
9011   pass3_register_alloc(addr);
9012
9013   /* Pass 4 - Cull unused host registers */
9014
9015   pass4_cull_unused_regs();
9016
9017   /* Pass 5 - Pre-allocate registers */
9018
9019   pass5a_preallocate1();
9020   pass5b_preallocate2();
9021
9022   /* Pass 6 - Optimize clean/dirty state */
9023   pass6_clean_registers(0, slen-1, 1);
9024
9025   /* Pass 7 */
9026   for (i=slen-1;i>=0;i--)
9027   {
9028     if(dops[i].itype==CJUMP||dops[i].itype==SJUMP)
9029     {
9030       // Conditional branch
9031       if((source[i]>>16)!=0x1000&&i<slen-2) {
9032         // Mark this address as a branch target since it may be called
9033         // upon return from interrupt
9034         dops[i+2].bt=1;
9035       }
9036     }
9037   }
9038
9039   /* Pass 8 - Assembly */
9040   linkcount=0;stubcount=0;
9041   is_delayslot=0;
9042   u_int dirty_pre=0;
9043   void *beginning=start_block();
9044   void *instr_addr0_override = NULL;
9045   int ds = 0;
9046
9047   if (start == 0x80030000) {
9048     // nasty hack for the fastbios thing
9049     // override block entry to this code
9050     instr_addr0_override = out;
9051     emit_movimm(start,0);
9052     // abuse io address var as a flag that we
9053     // have already returned here once
9054     emit_readword(&address,1);
9055     emit_writeword(0,&pcaddr);
9056     emit_writeword(0,&address);
9057     emit_cmp(0,1);
9058     #ifdef __aarch64__
9059     emit_jeq(out + 4*2);
9060     emit_far_jump(new_dyna_leave);
9061     #else
9062     emit_jne(new_dyna_leave);
9063     #endif
9064   }
9065   for(i=0;i<slen;i++)
9066   {
9067     __builtin_prefetch(regs[i+1].regmap);
9068     check_regmap(regmap_pre[i]);
9069     check_regmap(regs[i].regmap_entry);
9070     check_regmap(regs[i].regmap);
9071     //if(ds) printf("ds: ");
9072     disassemble_inst(i);
9073     if(ds) {
9074       ds=0; // Skip delay slot
9075       if(dops[i].bt) assem_debug("OOPS - branch into delay slot\n");
9076       instr_addr[i] = NULL;
9077     } else {
9078       speculate_register_values(i);
9079       #ifndef DESTRUCTIVE_WRITEBACK
9080       if (i < 2 || !dops[i-2].is_ujump)
9081       {
9082         wb_valid(regmap_pre[i],regs[i].regmap_entry,dirty_pre,regs[i].wasdirty,unneeded_reg[i]);
9083       }
9084       if((dops[i].itype==CJUMP||dops[i].itype==SJUMP)) {
9085         dirty_pre=branch_regs[i].dirty;
9086       }else{
9087         dirty_pre=regs[i].dirty;
9088       }
9089       #endif
9090       // write back
9091       if (i < 2 || !dops[i-2].is_ujump)
9092       {
9093         wb_invalidate(regmap_pre[i],regs[i].regmap_entry,regs[i].wasdirty,unneeded_reg[i]);
9094         loop_preload(regmap_pre[i],regs[i].regmap_entry);
9095       }
9096       // branch target entry point
9097       instr_addr[i] = out;
9098       assem_debug("<->\n");
9099       drc_dbg_emit_do_cmp(i, cinfo[i].ccadj);
9100       if (clear_hack_addr) {
9101         emit_movimm(0, 0);
9102         emit_writeword(0, &hack_addr);
9103         clear_hack_addr = 0;
9104       }
9105
9106       // load regs
9107       if(regs[i].regmap_entry[HOST_CCREG]==CCREG&&regs[i].regmap[HOST_CCREG]!=CCREG)
9108         wb_register(CCREG,regs[i].regmap_entry,regs[i].wasdirty);
9109       load_regs(regs[i].regmap_entry,regs[i].regmap,dops[i].rs1,dops[i].rs2);
9110       address_generation(i,&regs[i],regs[i].regmap_entry);
9111       load_consts(regmap_pre[i],regs[i].regmap,i);
9112       if(dops[i].is_jump)
9113       {
9114         // Load the delay slot registers if necessary
9115         if(dops[i+1].rs1!=dops[i].rs1&&dops[i+1].rs1!=dops[i].rs2&&(dops[i+1].rs1!=dops[i].rt1||dops[i].rt1==0))
9116           load_regs(regs[i].regmap_entry,regs[i].regmap,dops[i+1].rs1,dops[i+1].rs1);
9117         if(dops[i+1].rs2!=dops[i+1].rs1&&dops[i+1].rs2!=dops[i].rs1&&dops[i+1].rs2!=dops[i].rs2&&(dops[i+1].rs2!=dops[i].rt1||dops[i].rt1==0))
9118           load_regs(regs[i].regmap_entry,regs[i].regmap,dops[i+1].rs2,dops[i+1].rs2);
9119         if (ram_offset && (dops[i+1].is_load || dops[i+1].is_store))
9120           load_reg(regs[i].regmap_entry,regs[i].regmap,ROREG);
9121         if (dops[i+1].is_store)
9122           load_reg(regs[i].regmap_entry,regs[i].regmap,INVCP);
9123       }
9124       else if(i+1<slen)
9125       {
9126         // Preload registers for following instruction
9127         if(dops[i+1].rs1!=dops[i].rs1&&dops[i+1].rs1!=dops[i].rs2)
9128           if(dops[i+1].rs1!=dops[i].rt1&&dops[i+1].rs1!=dops[i].rt2)
9129             load_regs(regs[i].regmap_entry,regs[i].regmap,dops[i+1].rs1,dops[i+1].rs1);
9130         if(dops[i+1].rs2!=dops[i+1].rs1&&dops[i+1].rs2!=dops[i].rs1&&dops[i+1].rs2!=dops[i].rs2)
9131           if(dops[i+1].rs2!=dops[i].rt1&&dops[i+1].rs2!=dops[i].rt2)
9132             load_regs(regs[i].regmap_entry,regs[i].regmap,dops[i+1].rs2,dops[i+1].rs2);
9133       }
9134       // TODO: if(is_ooo(i)) address_generation(i+1);
9135       if (!dops[i].is_jump || dops[i].itype == CJUMP)
9136         load_reg(regs[i].regmap_entry,regs[i].regmap,CCREG);
9137       if (ram_offset && (dops[i].is_load || dops[i].is_store))
9138         load_reg(regs[i].regmap_entry,regs[i].regmap,ROREG);
9139       if (dops[i].is_store)
9140         load_reg(regs[i].regmap_entry,regs[i].regmap,INVCP);
9141
9142       ds = assemble(i, &regs[i], cinfo[i].ccadj);
9143
9144       drc_dbg_emit_wb_dirtys(i, &regs[i]);
9145       if (dops[i].is_ujump)
9146         literal_pool(1024);
9147       else
9148         literal_pool_jumpover(256);
9149     }
9150   }
9151
9152   assert(slen > 0);
9153   if (slen > 0 && dops[slen-1].itype == INTCALL) {
9154     // no ending needed for this block since INTCALL never returns
9155   }
9156   // If the block did not end with an unconditional branch,
9157   // add a jump to the next instruction.
9158   else if (i > 1) {
9159     if (!dops[i-2].is_ujump) {
9160       assert(!dops[i-1].is_jump);
9161       assert(i==slen);
9162       if(dops[i-2].itype!=CJUMP&&dops[i-2].itype!=SJUMP) {
9163         store_regs_bt(regs[i-1].regmap,regs[i-1].dirty,start+i*4);
9164         if(regs[i-1].regmap[HOST_CCREG]!=CCREG)
9165           emit_loadreg(CCREG,HOST_CCREG);
9166         emit_addimm(HOST_CCREG, cinfo[i-1].ccadj + CLOCK_ADJUST(1), HOST_CCREG);
9167       }
9168       else
9169       {
9170         store_regs_bt(branch_regs[i-2].regmap,branch_regs[i-2].dirty,start+i*4);
9171         assert(branch_regs[i-2].regmap[HOST_CCREG]==CCREG);
9172       }
9173       add_to_linker(out,start+i*4,0);
9174       emit_jmp(0);
9175     }
9176   }
9177   else
9178   {
9179     assert(i>0);
9180     assert(!dops[i-1].is_jump);
9181     store_regs_bt(regs[i-1].regmap,regs[i-1].dirty,start+i*4);
9182     if(regs[i-1].regmap[HOST_CCREG]!=CCREG)
9183       emit_loadreg(CCREG,HOST_CCREG);
9184     emit_addimm(HOST_CCREG, cinfo[i-1].ccadj + CLOCK_ADJUST(1), HOST_CCREG);
9185     add_to_linker(out,start+i*4,0);
9186     emit_jmp(0);
9187   }
9188
9189   // Stubs
9190   for(i = 0; i < stubcount; i++)
9191   {
9192     switch(stubs[i].type)
9193     {
9194       case LOADB_STUB:
9195       case LOADH_STUB:
9196       case LOADW_STUB:
9197       case LOADBU_STUB:
9198       case LOADHU_STUB:
9199         do_readstub(i);break;
9200       case STOREB_STUB:
9201       case STOREH_STUB:
9202       case STOREW_STUB:
9203         do_writestub(i);break;
9204       case CC_STUB:
9205         do_ccstub(i);break;
9206       case INVCODE_STUB:
9207         do_invstub(i);break;
9208       case STORELR_STUB:
9209         do_unalignedwritestub(i);break;
9210       case OVERFLOW_STUB:
9211         do_overflowstub(i); break;
9212       case ALIGNMENT_STUB:
9213         do_alignmentstub(i); break;
9214       default:
9215         assert(0);
9216     }
9217   }
9218
9219   if (instr_addr0_override)
9220     instr_addr[0] = instr_addr0_override;
9221
9222 #if 0
9223   /* check for improper expiration */
9224   for (i = 0; i < ARRAY_SIZE(jumps); i++) {
9225     int j;
9226     if (!jumps[i])
9227       continue;
9228     for (j = 0; j < jumps[i]->count; j++)
9229       assert(jumps[i]->e[j].stub < beginning || (u_char *)jumps[i]->e[j].stub > out);
9230   }
9231 #endif
9232
9233   /* Pass 9 - Linker */
9234   for(i=0;i<linkcount;i++)
9235   {
9236     assem_debug("%p -> %8x\n",link_addr[i].addr,link_addr[i].target);
9237     literal_pool(64);
9238     if (!link_addr[i].internal)
9239     {
9240       void *stub = out;
9241       void *addr = check_addr(link_addr[i].target);
9242       emit_extjump(link_addr[i].addr, link_addr[i].target);
9243       if (addr) {
9244         set_jump_target(link_addr[i].addr, addr);
9245         ndrc_add_jump_out(link_addr[i].target,stub);
9246       }
9247       else
9248         set_jump_target(link_addr[i].addr, stub);
9249     }
9250     else
9251     {
9252       // Internal branch
9253       int target=(link_addr[i].target-start)>>2;
9254       assert(target>=0&&target<slen);
9255       assert(instr_addr[target]);
9256       //#ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
9257       //set_jump_target_fillslot(link_addr[i].addr,instr_addr[target],link_addr[i].ext>>1);
9258       //#else
9259       set_jump_target(link_addr[i].addr, instr_addr[target]);
9260       //#endif
9261     }
9262   }
9263
9264   u_int source_len = slen*4;
9265   if (dops[slen-1].itype == INTCALL && source_len > 4)
9266     // no need to treat the last instruction as compiled
9267     // as interpreter fully handles it
9268     source_len -= 4;
9269
9270   if ((u_char *)copy + source_len > (u_char *)shadow + sizeof(shadow))
9271     copy = shadow;
9272
9273   // External Branch Targets (jump_in)
9274   int jump_in_count = 1;
9275   assert(instr_addr[0]);
9276   for (i = 1; i < slen; i++)
9277   {
9278     if (dops[i].bt && instr_addr[i])
9279       jump_in_count++;
9280   }
9281
9282   struct block_info *block =
9283     new_block_info(start, slen * 4, source, copy, beginning, jump_in_count);
9284   block->reg_sv_flags = state_rflags;
9285
9286   int jump_in_i = 0;
9287   for (i = 0; i < slen; i++)
9288   {
9289     if ((i == 0 || dops[i].bt) && instr_addr[i])
9290     {
9291       assem_debug("%p (%d) <- %8x\n", instr_addr[i], i, start + i*4);
9292       u_int vaddr = start + i*4;
9293
9294       literal_pool(256);
9295       void *entry = out;
9296       load_regs_entry(i);
9297       if (entry == out)
9298         entry = instr_addr[i];
9299       else
9300         emit_jmp(instr_addr[i]);
9301
9302       block->jump_in[jump_in_i].vaddr = vaddr;
9303       block->jump_in[jump_in_i].addr = entry;
9304       jump_in_i++;
9305     }
9306   }
9307   assert(jump_in_i == jump_in_count);
9308   hash_table_add(block->jump_in[0].vaddr, block->jump_in[0].addr);
9309   // Write out the literal pool if necessary
9310   literal_pool(0);
9311   #ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
9312   // Align code
9313   if(((u_int)out)&7) emit_addnop(13);
9314   #endif
9315   assert(out - (u_char *)beginning < MAX_OUTPUT_BLOCK_SIZE);
9316   //printf("shadow buffer: %p-%p\n",copy,(u_char *)copy+slen*4);
9317   memcpy(copy, source, source_len);
9318   copy += source_len;
9319
9320   end_block(beginning);
9321
9322   // If we're within 256K of the end of the buffer,
9323   // start over from the beginning. (Is 256K enough?)
9324   if (out > ndrc->translation_cache + sizeof(ndrc->translation_cache) - MAX_OUTPUT_BLOCK_SIZE)
9325     out = ndrc->translation_cache;
9326
9327   // Trap writes to any of the pages we compiled
9328   mark_invalid_code(start, slen*4, 0);
9329
9330   /* Pass 10 - Free memory by expiring oldest blocks */
9331
9332   pass10_expire_blocks();
9333
9334 #ifdef ASSEM_PRINT
9335   fflush(stdout);
9336 #endif
9337   stat_inc(stat_bc_direct);
9338   return 0;
9339 }
9340
9341 // vim:shiftwidth=2:expandtab